

import argparse
import json

import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm.models import create_model

from transformers import (
    BeitImageProcessor,
    DataaVecVisionConfig,
    DataaVecVisionForImageClassification,
    DataaVecVisionModel,
)





def    _snake_case		(snake_case_				:    Tuple						,					snake_case_				:    List[Any]=False						,					snake_case_				:    Union[str, Any]=False						,					snake_case_				:    List[Any]="data2vec."     )       ->		Optional[int]:
		__UpperCAmelCase  :     Optional[Any]		=    'backbone.' if is_semantic else ''

		__UpperCAmelCase  :     Any		=    []
		for i in range(config.num_hidden_layers     ):
				# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
				rename_keys.append(
				    (F"{prefix}blocks.{i}.norm1.weight", F"{hf_prefix}encoder.layer.{i}.layernorm_before.weight")     )
				rename_keys.append((F"{prefix}blocks.{i}.norm1.bias", F"{hf_prefix}encoder.layer.{i}.layernorm_before.bias")     )
				rename_keys.append(
				    (F"{prefix}blocks.{i}.attn.proj.weight", F"{hf_prefix}encoder.layer.{i}.attention.output.dense.weight")     )
				rename_keys.append(
				    (F"{prefix}blocks.{i}.attn.proj.bias", F"{hf_prefix}encoder.layer.{i}.attention.output.dense.bias")     )
				rename_keys.append(
				    (F"{prefix}blocks.{i}.norm2.weight", F"{hf_prefix}encoder.layer.{i}.layernorm_after.weight")     )
				rename_keys.append((F"{prefix}blocks.{i}.norm2.bias", F"{hf_prefix}encoder.layer.{i}.layernorm_after.bias")     )
				rename_keys.append(
				    (F"{prefix}blocks.{i}.mlp.fc1.weight", F"{hf_prefix}encoder.layer.{i}.intermediate.dense.weight")     )
				rename_keys.append(
				    (F"{prefix}blocks.{i}.mlp.fc1.bias", F"{hf_prefix}encoder.layer.{i}.intermediate.dense.bias")     )
				rename_keys.append((F"{prefix}blocks.{i}.mlp.fc2.weight", F"{hf_prefix}encoder.layer.{i}.output.dense.weight")     )
				rename_keys.append((F"{prefix}blocks.{i}.mlp.fc2.bias", F"{hf_prefix}encoder.layer.{i}.output.dense.bias")     )

		# projection layer + position embeddings
		rename_keys.extend(
		    [
		        (F"{prefix}cls_token", F"{hf_prefix}embeddings.cls_token"),
		        (F"{prefix}patch_embed.proj.weight", F"{hf_prefix}embeddings.patch_embeddings.projection.weight"),
		        (F"{prefix}patch_embed.proj.bias", F"{hf_prefix}embeddings.patch_embeddings.projection.bias"),
		    ]     )

		if has_lm_head:
				# mask token + shared relative position bias + layernorm
				rename_keys.extend(
				    [
				        ('mask_token', F"{hf_prefix}embeddings.mask_token"),
				        (
				            'rel_pos_bias.relative_position_bias_table',
				            F"{hf_prefix}encoder.relative_position_bias.relative_position_bias_table",
				        ),
				        (
				            'rel_pos_bias.relative_position_index',
				            F"{hf_prefix}encoder.relative_position_bias.relative_position_index",
				        ),
				        ('norm.weight', 'layernorm.weight'),
				        ('norm.bias', 'layernorm.bias'),
				    ]     )
		elif is_semantic:
				# semantic segmentation classification heads
				rename_keys.extend(
				    [
				        ('decode_head.conv_seg.weight', 'decode_head.classifier.weight'),
				        ('decode_head.conv_seg.bias', 'decode_head.classifier.bias'),
				        ('auxiliary_head.conv_seg.weight', 'auxiliary_head.classifier.weight'),
				        ('auxiliary_head.conv_seg.bias', 'auxiliary_head.classifier.bias'),
				    ]     )
		else:
				# layernorm + classification head
				rename_keys.extend(
				    [
				        ('fc_norm.weight', F"{hf_prefix}pooler.layernorm.weight"),
				        ('fc_norm.bias', F"{hf_prefix}pooler.layernorm.bias"),
				        ('head.weight', 'classifier.weight'),
				        ('head.bias', 'classifier.bias'),
				    ]     )

		return rename_keys





def    _snake_case		(snake_case_				:    Union[str, Any]						,					snake_case_				:    str						,					snake_case_				:    Tuple=False						,					snake_case_				:    Tuple=False						,					snake_case_				:    int="data2vec_vision."     )       ->		Dict:
		for i in range(config.num_hidden_layers     ):
				__UpperCAmelCase  :     Any		=    'backbone.' if is_semantic else ''
				# queries, keys and values
				__UpperCAmelCase  :     List[str]		=    state_dict.pop(F"{prefix}blocks.{i}.attn.qkv.weight"     )
				__UpperCAmelCase  :     int		=    state_dict.pop(F"{prefix}blocks.{i}.attn.q_bias"     )
				__UpperCAmelCase  :     List[Any]		=    state_dict.pop(F"{prefix}blocks.{i}.attn.v_bias"     )

				__UpperCAmelCase  :     str		=    in_proj_weight[
				    : config.hidden_size, :
				]
				__UpperCAmelCase  :     Union[str, Any]		=    q_bias
				__UpperCAmelCase  :     Any		=    in_proj_weight[
				    config.hidden_size : config.hidden_size * 2, :
				]
				__UpperCAmelCase  :     Dict		=    in_proj_weight[
				    -config.hidden_size :, :
				]
				__UpperCAmelCase  :     Optional[int]		=    v_bias

				# gamma_1 and gamma_2
				# we call them lambda because otherwise they are renamed when using .from_pretrained
				__UpperCAmelCase  :     int		=    state_dict.pop(F"{prefix}blocks.{i}.gamma_1"     )
				__UpperCAmelCase  :     Union[str, Any]		=    state_dict.pop(F"{prefix}blocks.{i}.gamma_2"     )

				__UpperCAmelCase  :     Dict		=    gamma_a
				__UpperCAmelCase  :     int		=    gamma_a

				# relative_position bias table + index
				if not has_lm_head:
						# each layer has its own relative position bias
						__UpperCAmelCase  :     int		=    state_dict.pop(F"{prefix}blocks.{i}.attn.relative_position_bias_table"     )
						__UpperCAmelCase  :     int		=    state_dict.pop(F"{prefix}blocks.{i}.attn.relative_position_index"     )

						__UpperCAmelCase  :     List[str]		=    table
						__UpperCAmelCase  :     Union[str, Any]		=    index





def    _snake_case		()       ->		Any:
		__UpperCAmelCase  :     Any		=    argparse.ArgumentParser(
		    'Convert Data2VecVision to HF for image classification and pretraining'						,					add_help=snake_case_     )
		parser.add_argument('--hf_checkpoint_name'						,					type=snake_case_     )
		parser.add_argument('--input_size'						,					default=224						,					type=snake_case_						,					help='images input size'     )
		parser.add_argument('--beit_checkpoint'						,					default=''						,					help='beit checkpoint'     )

		return parser.parse_args()





def    _snake_case		(snake_case_				:    Tuple						,					snake_case_				:    List[Any]						,					snake_case_				:    Union[str, Any]     )       ->		Optional[Any]:
		def load_state_dict(snake_case_				:    List[Any]						,					snake_case_				:    List[str]						,					snake_case_				:    int=""						,					snake_case_				:    List[str]="relative_position_index"     ):
				__UpperCAmelCase  :     int		=    []
				__UpperCAmelCase  :     Dict		=    []
				__UpperCAmelCase  :     List[Any]		=    []
				# copy state_dict so _load_from_state_dict can modify it
				__UpperCAmelCase  :     int		=    getattr(snake_case_						,					'_metadata'						,					snake_case_     )
				__UpperCAmelCase  :     Dict		=    state_dict.copy()
				if metadata is not None:
						__UpperCAmelCase  :     List[Any]		=    metadata

				def load(snake_case_				:    Optional[int]						,					snake_case_				:    Optional[int]=""     ):
						__UpperCAmelCase  :     List[str]		=    {} if metadata is None else metadata.get(prefix[:-1]						,					{}     )
						module._load_from_state_dict(
						    snake_case_						,					snake_case_						,					snake_case_						,					snake_case_						,					snake_case_						,					snake_case_						,					snake_case_     )
						for name, child in module._modules.items():
								if child is not None:
										load(snake_case_						,					prefix + name + '.'     )

				load(snake_case_						,					prefix=snake_case_     )

				__UpperCAmelCase  :     Any		=    []
				__UpperCAmelCase  :     Union[str, Any]		=    []
				for key in missing_keys:
						__UpperCAmelCase  :     Any		=    True
						for ignore_key in ignore_missing.split('|'     ):
								if ignore_key in key:
										__UpperCAmelCase  :     Optional[int]		=    False
										break
						if keep_flag:
								warn_missing_keys.append(snake_case_     )
						else:
								ignore_missing_keys.append(snake_case_     )

				__UpperCAmelCase  :     Any		=    warn_missing_keys

				if len(snake_case_     ) > 0:
						print(
						    'Weights of {} not initialized from pretrained model: {}'.format(
						        model.__class__.__name__						,					snake_case_     )     )
				if len(snake_case_     ) > 0:
						print('Weights from pretrained model not used in {}: {}'.format(model.__class__.__name__						,					snake_case_     )     )
				if len(snake_case_     ) > 0:
						print(
						    'Ignored weights of {} not initialized from pretrained model: {}'.format(
						        model.__class__.__name__						,					snake_case_     )     )
				if len(snake_case_     ) > 0:
						print('\n'.join(snake_case_     )     )

		__UpperCAmelCase  :     List[Any]		=    {
		    'pretrained': False,
		    'use_shared_rel_pos_bias': True,
		    'use_abs_pos_emb': False,
		    'init_values': 0.1,
		}

		if is_finetuned:
				model_kwargs.update(
				    {
				        'num_classes': 1000,
				        'use_mean_pooling': True,
				        'init_scale': 0.001,
				        'use_rel_pos_bias': True,
				    }     )

		__UpperCAmelCase  :     Optional[Any]		=    create_model(
		    'beit_large_patch16_224' if is_large else 'beit_base_patch16_224'						,					**snake_case_						,					)
		__UpperCAmelCase  :     List[str]		=    model.patch_embed.patch_size
		__UpperCAmelCase  :     Tuple		=    (args.input_size // patch_size[0], args.input_size // patch_size[1])
		__UpperCAmelCase  :     int		=    torch.load(args.beit_checkpoint						,					map_location='cpu'     )

		print(F"Load ckpt from {args.beit_checkpoint}"     )
		__UpperCAmelCase  :     Optional[Any]		=    None
		for model_key in ("model", "module"):
				if model_key in checkpoint:
						__UpperCAmelCase  :     Any		=    checkpoint[model_key]
						print(F"Load state_dict by model_key = {model_key}"     )
						break

		__UpperCAmelCase  :     Dict		=    list(checkpoint_model.keys()     )
		for key in all_keys:
				if "relative_position_index" in key:
						checkpoint_model.pop(snake_case_     )

				if "relative_position_bias_table" in key:
						__UpperCAmelCase  :     int		=    checkpoint_model[key]
						__UpperCAmelCase  :     List[Any]		=    rel_pos_bias.size()
						__UpperCAmelCase  :     str		=    model.state_dict()[key].size()
						__UpperCAmelCase  :     Dict		=    model.patch_embed.patch_shape
						if dst_patch_shape[0] != dst_patch_shape[1]:
								raise NotImplementedError()

		load_state_dict(snake_case_						,					snake_case_						,					prefix=''     )

		return model





def    _snake_case		()       ->		Any:
		__UpperCAmelCase  :     Optional[Any]		=    get_args()

		__UpperCAmelCase  :     Union[str, Any]		=    'ft1k' in args.hf_checkpoint_name
		__UpperCAmelCase  :     Optional[Any]		=    'large' in args.hf_checkpoint_name

		if is_finetuned:
				# To convert Beit's data2vec_vision to HF you need to copy
				# https://github.com/facebookresearch/data2vec_vision/blob/main/beit/modeling_finetune.py
				# into this folder.
				import modeling_finetune  # noqa: F401
		else:
				# To convert Beit's data2vec_vision to HF you need to copy
				# https://github.com/facebookresearch/data2vec_vision/blob/main/beit/modeling_cyclical.py
				# into this folder
				# IMPORTANT: Note that for now we've only converted the down-stream
				# model and not the full pretrained model. This means for the integration
				# test you need to add a `return x` after the following line:
				# https://github.com/facebookresearch/data2vec_vision/blob/af9a36349aaed59ae66e69b5dabeef2d62fdc5da/beit/modeling_cyclical.py#L197
				# to make the integration test pass.
				import modeling_cyclical  # noqa: F401

		# 1. Create model config
		__UpperCAmelCase  :     Any		=    DataaVecVisionConfig()
		if is_finetuned:
				__UpperCAmelCase  :     List[str]		=    True
				__UpperCAmelCase  :     Optional[Any]		=    False
				__UpperCAmelCase  :     int		=    True
				__UpperCAmelCase  :     int		=    1000

				__UpperCAmelCase  :     List[str]		=    'huggingface/label-files'
				__UpperCAmelCase  :     Any		=    'imagenet-1k-id2label.json'
				__UpperCAmelCase  :     int		=    json.load(open(hf_hub_download(snake_case_						,					snake_case_						,					repo_type='dataset'     )						,					'r'     )     )
				__UpperCAmelCase  :     List[str]		=    {int(snake_case_     ): v for k, v in idalabel.items()}
				__UpperCAmelCase  :     str		=    idalabel
				__UpperCAmelCase  :     int		=    {v: k for k, v in idalabel.items()}
		else:
				__UpperCAmelCase  :     str		=    False
				__UpperCAmelCase  :     Any		=    True
				__UpperCAmelCase  :     Optional[Any]		=    False

		if is_large:
				__UpperCAmelCase  :     Union[str, Any]		=    1024
				__UpperCAmelCase  :     Dict		=    4096
				__UpperCAmelCase  :     Dict		=    24
				__UpperCAmelCase  :     Optional[Any]		=    16

		# 2. Load Beit model
		__UpperCAmelCase  :     Dict		=    load_beit_model(snake_case_						,					snake_case_						,					snake_case_     )
		orig_model.eval()

		# 3. Forward Beit model
		__UpperCAmelCase  :     int		=    BeitImageProcessor(size=config.image_size						,					do_center_crop=snake_case_     )
		__UpperCAmelCase  :     List[Any]		=    Image.open('../../../../tests/fixtures/tests_samples/COCO/000000039769.png'     )
		__UpperCAmelCase  :     Optional[Any]		=    image_processor(images=snake_case_						,					return_tensors='pt'     )
		__UpperCAmelCase  :     int		=    encoding['pixel_values']

		__UpperCAmelCase  :     int		=    (pixel_values,) if is_finetuned else (pixel_values, None)
		with torch.no_grad():
				__UpperCAmelCase  :     Union[str, Any]		=    orig_model(*snake_case_     )

		# 4. Load HF Data2VecVision model
		if is_finetuned:
				__UpperCAmelCase  :     Any		=    DataaVecVisionForImageClassification(snake_case_     )
				hf_model.eval()
				__UpperCAmelCase  :     List[str]		=    False
				__UpperCAmelCase  :     Tuple		=    'data2vec_vision.'
		else:
				__UpperCAmelCase  :     Optional[int]		=    DataaVecVisionModel(snake_case_     )
				hf_model.eval()
				__UpperCAmelCase  :     List[Any]		=    True
				__UpperCAmelCase  :     List[Any]		=    ''

		__UpperCAmelCase  :     str		=    create_rename_keys(snake_case_						,					hf_prefix=snake_case_						,					has_lm_head=snake_case_     )
		__UpperCAmelCase  :     str		=    orig_model.state_dict()
		for src, dest in rename_keys:
				__UpperCAmelCase  :     Dict		=    state_dict.pop(snake_case_     )
				__UpperCAmelCase  :     Any		=    val

		read_in_q_k_v(snake_case_						,					snake_case_						,					hf_prefix=snake_case_						,					has_lm_head=snake_case_     )
		__UpperCAmelCase  :     Any		=    hf_model.load_state_dict(snake_case_						,					strict=snake_case_     )
		print('HF missing'						,					snake_case_     )
		print('HF unexpected_keys'						,					snake_case_     )

		# 5. Forward HF Data2VecVision model
		with torch.no_grad():
				__UpperCAmelCase  :     Tuple		=    hf_model(snake_case_     )

		__UpperCAmelCase  :     Union[str, Any]		=    hf_model_output.logits if is_finetuned else hf_model_output.last_hidden_state

		# 6. Compare
		__UpperCAmelCase  :     List[Any]		=    torch.max(torch.abs(hf_output - orig_model_output     )     ).item()

		print(F"max_absolute_diff = {max_absolute_diff}"     )
		__UpperCAmelCase  :     Any		=    torch.allclose(snake_case_						,					snake_case_						,					atol=1e-3     )
		print('Do both models output the same tensors?'						,					'🔥' if success else '💩'     )
		if not success:
				raise Exception('Something went wRoNg'     )

		# 7. Save
		print(F"Saving to {args.hf_checkpoint_name}"     )
		hf_model.save_pretrained(args.hf_checkpoint_name     )
		image_processor.save_pretrained(args.hf_checkpoint_name     )


if __name__ == "__main__":
						main()
						# Run the following to convert checkpoints
						#  python ./convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py \
						#          --beit_checkpoint ./pretrained_base.pt \
						#          --hf_checkpoint_name "./data2vec-vision-base"
						#  python ./convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py \
						#          --beit_checkpoint ./finetuned_base.pt \
						#          --hf_checkpoint_name "./data2vec-vision-base-ft1k"
						#  python ./convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py \
						#          --beit_checkpoint ./pretrained_large.pt \
						#          --hf_checkpoint_name "./data2vec-vision-large"
						#  python ./convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py \
						#          --beit_checkpoint ./finetuned_large.pt \
						#          --hf_checkpoint_name "./data2vec-vision-large-ft1k"








import math
from itertools import permutations





def    _snake_case		(snake_case_				:    int     )       ->		bool:

  if 1 < number < 4:
    # 2 and 3 are primes
    return True
  elif number < 2 or number % 2 == 0 or number % 3 == 0:
    # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
    return False

  # All primes number are in format of 6k +/- 1
  for i in range(5						,					int(math.sqrt(snake_case_     ) + 1     )						,					6     ):
    if number % i == 0 or number % (i + 2) == 0:
      return False
  return True





def    _snake_case		(snake_case_				:    int						,					snake_case_				:    list     )       ->		bool:
  __UpperCAmelCase, __UpperCAmelCase  :     Any		=    0, len(snake_case_     ) - 1
  while left <= right:
    __UpperCAmelCase  :     List[str]		=    (left + right) // 2
    if prime_list[middle] == target:
      return True
    elif prime_list[middle] < target:
      __UpperCAmelCase  :     Tuple		=    middle + 1
    else:
      __UpperCAmelCase  :     Tuple		=    middle - 1

  return False





def    _snake_case		()       ->		str:
  __UpperCAmelCase  :     List[Any]		=    [n for n in range(1001						,					1_0000						,					2     ) if is_prime(snake_case_     )]
  __UpperCAmelCase  :     Tuple		=    []

  for number in prime_list:
    __UpperCAmelCase  :     List[str]		=    []

    for prime_member in permutations(list(str(snake_case_     )     )     ):
      __UpperCAmelCase  :     Dict		=    int(''.join(snake_case_     )     )

      if prime % 2 == 0:
        continue

      if search(snake_case_						,					snake_case_     ):
        tmp_numbers.append(snake_case_     )

    tmp_numbers.sort()
    if len(snake_case_     ) >= 3:
      candidates.append(snake_case_     )

  __UpperCAmelCase  :     Optional[int]		=    []
  for candidate in candidates:
    __UpperCAmelCase  :     int		=    len(snake_case_     )
    __UpperCAmelCase  :     List[Any]		=    False

    for i in range(snake_case_     ):
      for j in range(i + 1						,					snake_case_     ):
        for k in range(j + 1						,					snake_case_     ):
          if (
              abs(candidate[i] - candidate[j]     )
              == abs(candidate[j] - candidate[k]     )
              and len({candidate[i], candidate[j], candidate[k]}     ) == 3
          ):
            passed.append(
                sorted([candidate[i], candidate[j], candidate[k]]     )     )
            __UpperCAmelCase  :     Any		=    True

          if found:
            break
        if found:
          break
      if found:
        break

  __UpperCAmelCase  :     Dict		=    set()
  for seq in passed:
    answer.add(''.join([str(snake_case_     ) for i in seq]     )     )

  return max(int(snake_case_     ) for x in answer     )


if __name__ == "__main__":
      print(solution())





