


"""simple docstring"""



import argparse
import json
from pathlib import Path

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

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


logging.set_verbosity_info()
__snake_case         =					logging.get_logger(__name__)







def 						__lowerCAmelCase		(		lowercase						:						Optional[Any]		,							lowercase						:						str=False				)			->		Union[str, Any]:


    """simple docstring"""





    snake_case					:   Optional[Any]         =					[]
    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"),
            ]				)

        # if just the base model, we should remove "vit" from all keys that start with "vit"
        snake_case					:   Tuple         =					[(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 						__lowerCAmelCase		(		lowercase						:						int		,							lowercase						:						Optional[int]		,							lowercase						:						Union[str, Any]=False				)			->		Optional[Any]:


    """simple docstring"""





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







def 						__lowerCAmelCase		(		lowercase						:						int				)			->		Union[str, Any]:


    """simple docstring"""





    snake_case					:   Any         =					["head.weight", "head.bias"]
    for k in ignore_keys:
        state_dict.pop(lowercase		,							lowercase				)







def 						__lowerCAmelCase		(		lowercase						:						List[str]		,							lowercase						:						List[str]		,							lowercase						:						int				)			->		Tuple:


    """simple docstring"""





    snake_case					:   List[Any]         =					dct.pop(lowercase				)
    snake_case					:   List[str]         =					val







def 						__lowerCAmelCase		(		)			->		Dict:


    """simple docstring"""





    snake_case					:   Optional[Any]         =					"http://images.cocodataset.org/val2017/000000039769.jpg"
    snake_case					:   Optional[Any]         =					Image.open(requests.get(lowercase		,							stream=lowercase				).raw				)
    return im







@torch.no_grad()
def 						__lowerCAmelCase		(		lowercase						:						int		,							lowercase						:						Any		,							lowercase						:						str=True				)			->		Dict:


    """simple docstring"""





    snake_case					:   Optional[int]         =					ViTConfig()
    # patch_size
    if model_name[-1] == "8":
        snake_case					:   str         =					8
    # set labels if required
    if not base_model:
        snake_case					:   Tuple         =					1000
        snake_case					:   str         =					"huggingface/label-files"
        snake_case					:   Optional[int]         =					"imagenet-1k-id2label.json"
        snake_case					:   Dict         =					json.load(open(hf_hub_download(lowercase		,							lowercase		,							repo_type="dataset"				)		,							"r"				)				)
        snake_case					:   Optional[int]         =					{int(lowercase				): v for k, v in idalabel.items()}
        snake_case					:   Optional[int]         =					idalabel
        snake_case					:   Optional[int]         =					{v: k for k, v in idalabel.items()}
    # size of the architecture
    if model_name in ["dino_vits8", "dino_vits16"]:
        snake_case					:   Optional[int]         =					384
        snake_case					:   Union[str, Any]         =					1536
        snake_case					:   Optional[Any]         =					12
        snake_case					:   Dict         =					6

    # load original model from torch hub
    snake_case					:   List[Any]         =					torch.hub.load("facebookresearch/dino:main"		,							lowercase				)
    original_model.eval()

    # load state_dict of original model, remove and rename some keys
    snake_case					:   Optional[Any]         =					original_model.state_dict()
    if base_model:
        remove_classification_head_(lowercase				)
    snake_case					:   Optional[Any]         =					create_rename_keys(lowercase		,							base_model=lowercase				)
    for src, dest in rename_keys:
        rename_key(lowercase		,							lowercase		,							lowercase				)
    read_in_q_k_v(lowercase		,							lowercase		,							lowercase				)

    # load HuggingFace model
    if base_model:
        snake_case					:   str         =					ViTModel(lowercase		,							add_pooling_layer=lowercase				).eval()
    else:
        snake_case					:   Dict         =					ViTForImageClassification(lowercase				).eval()
    model.load_state_dict(lowercase				)

    # Check outputs on an image, prepared by ViTImageProcessor
    snake_case					:   Tuple         =					ViTImageProcessor()
    snake_case					:   List[str]         =					image_processor(images=prepare_img()		,							return_tensors="pt"				)
    snake_case					:   Optional[Any]         =					encoding["pixel_values"]
    snake_case					:   List[str]         =					model(lowercase				)

    if base_model:
        snake_case					:   str         =					original_model(lowercase				)
        assert torch.allclose(lowercase		,							outputs.last_hidden_state[:, 0, :]		,							atol=1e-1				)
    else:
        snake_case					:   Any         =					original_model(lowercase				)
        assert logits.shape == outputs.logits.shape
        assert torch.allclose(lowercase		,							outputs.logits		,							atol=1e-3				)

    Path(lowercase				).mkdir(exist_ok=lowercase				)
    print(F'Saving model {model_name} to {pytorch_dump_folder_path}'				)
    model.save_pretrained(lowercase				)
    print(F'Saving image processor to {pytorch_dump_folder_path}'				)
    image_processor.save_pretrained(lowercase				)


if __name__ == "__main__":
  __snake_case         =					argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      """--model_name""",
      default="""dino_vitb16""",
      type=str,
      help="""Name of the model trained with DINO you'd like to convert.""",
  )
  parser.add_argument(
      """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
  )
  parser.add_argument(
      """--base_model""",
      action="""store_true""",
      help="""Whether to only convert the base model (no projection head weights).""",
  )

  parser.set_defaults(base_model=True)
  __snake_case         =					parser.parse_args()
  convert_vit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.base_model)









"""simple docstring"""



from __future__ import annotations

from cmath import sqrt







def 						__lowerCAmelCase		(		lowercase						:						int		,							lowercase						:						int		,							lowercase						:						int				)			->		tuple[complex, complex]:


    """simple docstring"""





    if a == 0:
        raise ValueError("Coefficient 'a' must not be zero."				)
    snake_case					:   Dict         =					b * b - 4 * a * c

    snake_case					:   Tuple         =					(-b + sqrt(lowercase				)) / (2 * a)
    snake_case					:   Optional[int]         =					(-b - sqrt(lowercase				)) / (2 * a)

    return (
        root_a.real if not root_a.imag else root_a,
        root_a.real if not root_a.imag else root_a,
    )







def 						__lowerCAmelCase		(		)			->		List[Any]:


    """simple docstring"""





    snake_case      ,snake_case					:   Optional[Any]         =					quadratic_roots(a=5		,							b=6		,							c=1				)
    print(F'The solutions are: {solutiona} and {solutiona}'				)


if __name__ == "__main__":
  main()





