





def   a_   (			lowerCAmelCase_				:      int = 100_0000     ):
   __lowerCAmelCase							     =     [i - 1 for i in range(limit + 1     )]

   for i in range(2,     limit + 1     ):
      if phi[i] == i - 1:
         for j in range(2 * i,     limit + 1,     lowerCAmelCase_     ):
            phi[j] -= phi[j] // i

   return sum(phi[2 : limit + 1]     )


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








import argparse
import json
from pathlib import Path

import requests
import timm
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import DeiTImageProcessor, ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel
from transformers.utils import logging


logging.set_verbosity_info()
_snake_case  :   List[str]						   =  logging.get_logger(__name__)

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

   # projection layer + position embeddings
   rename_keys.extend(
       [
           ('cls_token', 'vit.embeddings.cls_token'),
           ('patch_embed.proj.weight', 'vit.embeddings.patch_embeddings.projection.weight'),
           ('patch_embed.proj.bias', 'vit.embeddings.patch_embeddings.projection.bias'),
           ('pos_embed', 'vit.embeddings.position_embeddings'),
       ]     )

   if base_model:
      # layernorm + pooler
      rename_keys.extend(
          [
              ('norm.weight', 'layernorm.weight'),
              ('norm.bias', 'layernorm.bias'),
              ('pre_logits.fc.weight', 'pooler.dense.weight'),
              ('pre_logits.fc.bias', 'pooler.dense.bias'),
          ]     )

      # if just the base model, we should remove "vit" from all keys that start with "vit"
      __lowerCAmelCase							     =     [(pair[0], pair[1][4:]) if pair[1].startswith('vit'     ) else pair for pair in rename_keys]
   else:
      # layernorm + classification head
      rename_keys.extend(
          [
              ('norm.weight', 'vit.layernorm.weight'),
              ('norm.bias', 'vit.layernorm.bias'),
              ('head.weight', 'classifier.weight'),
              ('head.bias', 'classifier.bias'),
          ]     )

   return rename_keys

def   a_   (			lowerCAmelCase_				:      List[Any],     lowerCAmelCase_				:      Dict,     lowerCAmelCase_				:      int=False     ):
   for i in range(config.num_hidden_layers     ):
      if base_model:
         __lowerCAmelCase							     =     ''
      else:
         __lowerCAmelCase							     =     'vit.'
      # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
      __lowerCAmelCase							     =     state_dict.pop(F"""blocks.{i}.attn.qkv.weight"""     )
      __lowerCAmelCase							     =     state_dict.pop(F"""blocks.{i}.attn.qkv.bias"""     )
      # next, add query, keys and values (in that order) to the state dict
      __lowerCAmelCase							     =     in_proj_weight[
          : config.hidden_size, :
      ]
      __lowerCAmelCase							     =     in_proj_bias[: config.hidden_size]
      __lowerCAmelCase							     =     in_proj_weight[
          config.hidden_size : config.hidden_size * 2, :
      ]
      __lowerCAmelCase							     =     in_proj_bias[
          config.hidden_size : config.hidden_size * 2
      ]
      __lowerCAmelCase							     =     in_proj_weight[
          -config.hidden_size :, :
      ]
      __lowerCAmelCase							     =     in_proj_bias[-config.hidden_size :]

def   a_   (			lowerCAmelCase_				:      Optional[int]     ):
   __lowerCAmelCase							     =     ['head.weight', 'head.bias']
   for k in ignore_keys:
      state_dict.pop(lowerCAmelCase_,     lowerCAmelCase_     )

def   a_   (			lowerCAmelCase_				:      Optional[Any],     lowerCAmelCase_				:      Tuple,     lowerCAmelCase_				:      Optional[int]     ):
   __lowerCAmelCase							     =     dct.pop(lowerCAmelCase_     )
   __lowerCAmelCase							     =     val

def   a_   (			):
   __lowerCAmelCase							     =     'http://images.cocodataset.org/val2017/000000039769.jpg'
   __lowerCAmelCase							     =     Image.open(requests.get(lowerCAmelCase_,     stream=lowerCAmelCase_     ).raw     )
   return im

@torch.no_grad()
def   a_   (			lowerCAmelCase_				:      List[str],     lowerCAmelCase_				:      Union[str, Any]     ):
   __lowerCAmelCase							     =     ViTConfig()
   __lowerCAmelCase							     =     False
   # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size
   if vit_name[-5:] == "in21k":
      __lowerCAmelCase							     =     True
      __lowerCAmelCase							     =     int(vit_name[-12:-10]     )
      __lowerCAmelCase							     =     int(vit_name[-9:-6]     )
   else:
      __lowerCAmelCase							     =     1000
      __lowerCAmelCase							     =     'huggingface/label-files'
      __lowerCAmelCase							     =     'imagenet-1k-id2label.json'
      __lowerCAmelCase							     =     json.load(open(hf_hub_download(lowerCAmelCase_,     lowerCAmelCase_,     repo_type='dataset'     ),     'r'     )     )
      __lowerCAmelCase							     =     {int(lowerCAmelCase_     ): v for k, v in idalabel.items()}
      __lowerCAmelCase							     =     idalabel
      __lowerCAmelCase							     =     {v: k for k, v in idalabel.items()}
      __lowerCAmelCase							     =     int(vit_name[-6:-4]     )
      __lowerCAmelCase							     =     int(vit_name[-3:]     )
   # size of the architecture
   if "deit" in vit_name:
      if vit_name[9:].startswith('tiny'     ):
         __lowerCAmelCase							     =     192
         __lowerCAmelCase							     =     768
         __lowerCAmelCase							     =     12
         __lowerCAmelCase							     =     3
      elif vit_name[9:].startswith('small'     ):
         __lowerCAmelCase							     =     384
         __lowerCAmelCase							     =     1536
         __lowerCAmelCase							     =     12
         __lowerCAmelCase							     =     6
      else:
         pass
   else:
      if vit_name[4:].startswith('small'     ):
         __lowerCAmelCase							     =     768
         __lowerCAmelCase							     =     2304
         __lowerCAmelCase							     =     8
         __lowerCAmelCase							     =     8
      elif vit_name[4:].startswith('base'     ):
         pass
      elif vit_name[4:].startswith('large'     ):
         __lowerCAmelCase							     =     1024
         __lowerCAmelCase							     =     4096
         __lowerCAmelCase							     =     24
         __lowerCAmelCase							     =     16
      elif vit_name[4:].startswith('huge'     ):
         __lowerCAmelCase							     =     1280
         __lowerCAmelCase							     =     5120
         __lowerCAmelCase							     =     32
         __lowerCAmelCase							     =     16

    # load original model from timm
   __lowerCAmelCase							     =     timm.create_model(lowerCAmelCase_,     pretrained=lowerCAmelCase_     )
   timm_model.eval()

   # load state_dict of original model, remove and rename some keys
   __lowerCAmelCase							     =     timm_model.state_dict()
   if base_model:
      remove_classification_head_(lowerCAmelCase_     )
   __lowerCAmelCase							     =     create_rename_keys(lowerCAmelCase_,     lowerCAmelCase_     )
   for src, dest in rename_keys:
      rename_key(lowerCAmelCase_,     lowerCAmelCase_,     lowerCAmelCase_     )
   read_in_q_k_v(lowerCAmelCase_,     lowerCAmelCase_,     lowerCAmelCase_     )

   # load HuggingFace model
   if vit_name[-5:] == "in21k":
      __lowerCAmelCase							     =     ViTModel(lowerCAmelCase_     ).eval()
   else:
      __lowerCAmelCase							     =     ViTForImageClassification(lowerCAmelCase_     ).eval()
   model.load_state_dict(lowerCAmelCase_     )

   # Check outputs on an image, prepared by ViTImageProcessor/DeiTImageProcessor
   if "deit" in vit_name:
      __lowerCAmelCase							     =     DeiTImageProcessor(size=config.image_size     )
   else:
      __lowerCAmelCase							     =     ViTImageProcessor(size=config.image_size     )
   __lowerCAmelCase							     =     image_processor(images=prepare_img(),     return_tensors='pt'     )
   __lowerCAmelCase							     =     encoding['pixel_values']
   __lowerCAmelCase							     =     model(lowerCAmelCase_     )

   if base_model:
      __lowerCAmelCase							     =     timm_model.forward_features(lowerCAmelCase_     )
      assert timm_pooled_output.shape == outputs.pooler_output.shape
      assert torch.allclose(lowerCAmelCase_,     outputs.pooler_output,     atol=1E-3     )
   else:
      __lowerCAmelCase							     =     timm_model(lowerCAmelCase_     )
      assert timm_logits.shape == outputs.logits.shape
      assert torch.allclose(lowerCAmelCase_,     outputs.logits,     atol=1E-3     )

   Path(lowerCAmelCase_     ).mkdir(exist_ok=lowerCAmelCase_     )
   print(F"""Saving model {vit_name} to {pytorch_dump_folder_path}"""     )
   model.save_pretrained(lowerCAmelCase_     )
   print(F"""Saving image processor to {pytorch_dump_folder_path}"""     )
   image_processor.save_pretrained(lowerCAmelCase_     )


if __name__ == "__main__":
     _snake_case  :   List[Any]						   =  argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '--vit_name',
         default='vit_base_patch16_224',
         type=str,
         help='Name of the ViT timm model you\'d like to convert.',
     )
     parser.add_argument(
         '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
     )

     _snake_case  :   Optional[int]						   =  parser.parse_args()
     convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path)

