
'''simple docstring'''
import argparse
import json
import os

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

from transformers import ConvNextImageProcessor, ConvNextVaConfig, ConvNextVaForImageClassification
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


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

def   UpperCamelCase_   (		__SCREAMING_SNAKE_CASE				):
    """simple docstring"""






    snake_case_       :			Optional[int]   	=  ConvNextVaConfig()

    if "atto" in checkpoint_url:
        snake_case_       :			Any   	=  [2, 2, 6, 2]
        snake_case_       :			int   	=  [4_0, 8_0, 1_6_0, 3_2_0]
    if "femto" in checkpoint_url:
        snake_case_       :			Union[str, Any]   	=  [2, 2, 6, 2]
        snake_case_       :			Dict   	=  [4_8, 9_6, 1_9_2, 3_8_4]
    if "pico" in checkpoint_url:
        snake_case_       :			Optional[Any]   	=  [2, 2, 6, 2]
        snake_case_       :			List[Any]   	=  [6_4, 1_2_8, 2_5_6, 5_1_2]
    if "nano" in checkpoint_url:
        snake_case_       :			Union[str, Any]   	=  [2, 2, 8, 2]
        snake_case_       :			Dict   	=  [8_0, 1_6_0, 3_2_0, 6_4_0]
    if "tiny" in checkpoint_url:
        snake_case_       :			Any   	=  [3, 3, 9, 3]
        snake_case_       :			Dict   	=  [9_6, 1_9_2, 3_8_4, 7_6_8]
    if "base" in checkpoint_url:
        snake_case_       :			List[str]   	=  [3, 3, 2_7, 3]
        snake_case_       :			Optional[int]   	=  [1_2_8, 2_5_6, 5_1_2, 1_0_2_4]
    if "large" in checkpoint_url:
        snake_case_       :			Any   	=  [3, 3, 2_7, 3]
        snake_case_       :			Union[str, Any]   	=  [1_9_2, 3_8_4, 7_6_8, 1_5_3_6]
    if "huge" in checkpoint_url:
        snake_case_       :			List[Any]   	=  [3, 3, 2_7, 3]
        snake_case_       :			Tuple   	=  [3_5_2, 7_0_4, 1_4_0_8, 2_8_1_6]

    snake_case_       :			Union[str, Any]   	=  1_0_0_0
    snake_case_       :			int   	=  """imagenet-1k-id2label.json"""
    snake_case_       :			str   	=  (1, 1_0_0_0)

    snake_case_       :			Optional[int]   	=  """huggingface/label-files"""
    snake_case_       :			Dict   	=  num_labels
    snake_case_       :			List[str]   	=  json.load(open(hf_hub_download(__UpperCAmelCase,						__UpperCAmelCase,						repo_type="dataset"				),						"r"				)				)
    snake_case_       :			Union[str, Any]   	=  {int(__UpperCAmelCase				): v for k, v in idalabel.items()}

    snake_case_       :			Dict   	=  idalabel
    snake_case_       :			str   	=  {v: k for k, v in idalabel.items()}
    snake_case_       :			Optional[Any]   	=  hidden_sizes
    snake_case_       :			Union[str, Any]   	=  depths

    return config, expected_shape

def   UpperCamelCase_   (		__SCREAMING_SNAKE_CASE				):
    """simple docstring"""






    if "downsample_layers.0.0" in name:
        snake_case_       :			str   	=  name.replace("downsample_layers.0.0",						"embeddings.patch_embeddings"				)
    if "downsample_layers.0.1" in name:
        snake_case_       :			Optional[int]   	=  name.replace("downsample_layers.0.1",						"embeddings.norm"				)  # we rename to layernorm later on
    if "downsample_layers.1.0" in name:
        snake_case_       :			List[str]   	=  name.replace("downsample_layers.1.0",						"stages.1.downsampling_layer.0"				)
    if "downsample_layers.1.1" in name:
        snake_case_       :			Any   	=  name.replace("downsample_layers.1.1",						"stages.1.downsampling_layer.1"				)
    if "downsample_layers.2.0" in name:
        snake_case_       :			Any   	=  name.replace("downsample_layers.2.0",						"stages.2.downsampling_layer.0"				)
    if "downsample_layers.2.1" in name:
        snake_case_       :			Union[str, Any]   	=  name.replace("downsample_layers.2.1",						"stages.2.downsampling_layer.1"				)
    if "downsample_layers.3.0" in name:
        snake_case_       :			List[Any]   	=  name.replace("downsample_layers.3.0",						"stages.3.downsampling_layer.0"				)
    if "downsample_layers.3.1" in name:
        snake_case_       :			str   	=  name.replace("downsample_layers.3.1",						"stages.3.downsampling_layer.1"				)
    if "stages" in name and "downsampling_layer" not in name:
        # stages.0.0. for instance should be renamed to stages.0.layers.0.
        snake_case_       :			List[Any]   	=  name[: len("stages.0"				)] + """.layers""" + name[len("stages.0"				) :]
    if "gamma" in name:
        snake_case_       :			Union[str, Any]   	=  name.replace("gamma",						"weight"				)
    if "beta" in name:
        snake_case_       :			List[str]   	=  name.replace("beta",						"bias"				)
    if "stages" in name:
        snake_case_       :			int   	=  name.replace("stages",						"encoder.stages"				)
    if "norm" in name:
        snake_case_       :			Any   	=  name.replace("norm",						"layernorm"				)
    if "head" in name:
        snake_case_       :			str   	=  name.replace("head",						"classifier"				)

    return name

def   UpperCamelCase_   (		):
    """simple docstring"""






    snake_case_       :			str   	=  """http://images.cocodataset.org/val2017/000000039769.jpg"""
    snake_case_       :			List[str]   	=  Image.open(requests.get(__UpperCAmelCase,						stream=__UpperCAmelCase				).raw				)
    return im

def   UpperCamelCase_   (		__SCREAMING_SNAKE_CASE				):
    """simple docstring"""






    if "224" in checkpoint_url:
        snake_case_       :			Optional[int]   	=  2_2_4
        snake_case_       :			Optional[Any]   	=  2_2_4 / 2_5_6
    elif "384" in checkpoint_url:
        snake_case_       :			Any   	=  3_8_4
        snake_case_       :			Tuple   	=  None
    else:
        snake_case_       :			Dict   	=  5_1_2
        snake_case_       :			str   	=  None

    return ConvNextImageProcessor(
        size=__UpperCAmelCase,						crop_pct=__UpperCAmelCase,						image_mean=[0.485, 0.456, 0.406],						image_std=[0.229, 0.224, 0.225],						resample=PILImageResampling.BICUBIC,						)

@torch.no_grad()
def   UpperCamelCase_   (		__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE				):
    """simple docstring"""






    print("Downloading original model from checkpoint..."				)
    # define ConvNeXTV2 configuration based on URL
    snake_case_       :			Tuple   	=  get_convnextva_config(__UpperCAmelCase				)
    # load original state_dict from URL
    snake_case_       :			List[Any]   	=  torch.hub.load_state_dict_from_url(__UpperCAmelCase				)["""model"""]

    print("Converting model parameters..."				)
    # rename keys
    for key in state_dict.copy().keys():
        snake_case_       :			List[Any]   	=  state_dict.pop(__UpperCAmelCase				)
        snake_case_       :			Optional[int]   	=  val
    # add prefix to all keys expect classifier head
    for key in state_dict.copy().keys():
        snake_case_       :			str   	=  state_dict.pop(__UpperCAmelCase				)
        if not key.startswith("classifier"				):
            snake_case_       :			int   	=  """convnextv2.""" + key
        snake_case_       :			Union[str, Any]   	=  val

    # load HuggingFace model
    snake_case_       :			Optional[Any]   	=  ConvNextVaForImageClassification(__UpperCAmelCase				)
    model.load_state_dict(__UpperCAmelCase				)
    model.eval()

    # Check outputs on an image, prepared by ConvNextImageProcessor
    snake_case_       :			Any   	=  convert_preprocessor(__UpperCAmelCase				)
    snake_case_       :			Optional[int]   	=  preprocessor(images=prepare_img(),						return_tensors="pt"				)
    snake_case_       :			int   	=  model(**__UpperCAmelCase				).logits

    # note: the logits below were obtained without center cropping
    if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt":
        snake_case_       :			Tuple   	=  torch.tensor([-0.3930, 0.1747, -0.5246, 0.4177, 0.4295]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_femto_1k_224_ema.pt":
        snake_case_       :			Dict   	=  torch.tensor([-0.1727, -0.5341, -0.7818, -0.4745, -0.6566]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_pico_1k_224_ema.pt":
        snake_case_       :			Dict   	=  torch.tensor([-0.0333, 0.1563, -0.9137, 0.1054, 0.0381]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_nano_1k_224_ema.pt":
        snake_case_       :			Union[str, Any]   	=  torch.tensor([-0.1744, -0.1555, -0.0713, 0.0950, -0.1431]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_tiny_1k_224_ema.pt":
        snake_case_       :			Union[str, Any]   	=  torch.tensor([0.9996, 0.1966, -0.4386, -0.3472, 0.6661]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_base_1k_224_ema.pt":
        snake_case_       :			str   	=  torch.tensor([-0.2553, -0.6708, -0.1359, 0.2518, -0.2488]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_large_1k_224_ema.pt":
        snake_case_       :			Dict   	=  torch.tensor([-0.0673, -0.5627, -0.3753, -0.2722, 0.0178]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_huge_1k_224_ema.pt":
        snake_case_       :			Any   	=  torch.tensor([-0.6377, -0.7458, -0.2150, 0.1184, -0.0597]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_224_ema.pt":
        snake_case_       :			Any   	=  torch.tensor([1.0799, 0.2322, -0.8860, 1.0219, 0.6231]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_384_ema.pt":
        snake_case_       :			Tuple   	=  torch.tensor([0.3766, 0.4917, -1.1426, 0.9942, 0.6024]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_224_ema.pt":
        snake_case_       :			str   	=  torch.tensor([0.4220, -0.6919, -0.4317, -0.2881, -0.6609]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_384_ema.pt":
        snake_case_       :			List[str]   	=  torch.tensor([0.1082, -0.8286, -0.5095, 0.4681, -0.8085]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_224_ema.pt":
        snake_case_       :			int   	=  torch.tensor([-0.2419, -0.6221, 0.2176, -0.0980, -0.7527]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_384_ema.pt":
        snake_case_       :			List[str]   	=  torch.tensor([0.0391, -0.4371, 0.3786, 0.1251, -0.2784]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_224_ema.pt":
        snake_case_       :			Any   	=  torch.tensor([-0.0504, 0.5636, -0.1729, -0.6507, -0.3949]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_384_ema.pt":
        snake_case_       :			Dict   	=  torch.tensor([0.3560, 0.9486, 0.3149, -0.2667, -0.5138]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_384_ema.pt":
        snake_case_       :			Dict   	=  torch.tensor([-0.2469, -0.4550, -0.5853, -0.0810, 0.0309]				)
    elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_512_ema.pt":
        snake_case_       :			List[str]   	=  torch.tensor([-0.3090, 0.0802, -0.0682, -0.1979, -0.2826]				)
    else:
        raise ValueError(f'Unknown URL: {checkpoint_url}'				)

    assert torch.allclose(logits[0, :5],						__UpperCAmelCase,						atol=1E-3				)
    assert logits.shape == expected_shape
    print("Model outputs match the original results!"				)

    if save_model:
        print("Saving model to local..."				)
        # Create folder to save model
        if not os.path.isdir(__UpperCAmelCase				):
            os.mkdir(__UpperCAmelCase				)

        model.save_pretrained(__UpperCAmelCase				)
        preprocessor.save_pretrained(__UpperCAmelCase				)

    snake_case_       :			List[str]   	=  """convnextv2"""
    if "atto" in checkpoint_url:
        model_name += "-atto"
    if "femto" in checkpoint_url:
        model_name += "-femto"
    if "pico" in checkpoint_url:
        model_name += "-pico"
    if "nano" in checkpoint_url:
        model_name += "-nano"
    elif "tiny" in checkpoint_url:
        model_name += "-tiny"
    elif "base" in checkpoint_url:
        model_name += "-base"
    elif "large" in checkpoint_url:
        model_name += "-large"
    elif "huge" in checkpoint_url:
        model_name += "-huge"
    if "22k" in checkpoint_url and "1k" not in checkpoint_url:
        model_name += "-22k"
    elif "22k" in checkpoint_url and "1k" in checkpoint_url:
        model_name += "-22k-1k"
    elif "1k" in checkpoint_url:
        model_name += "-1k"
    if "224" in checkpoint_url:
        model_name += "-224"
    elif "384" in checkpoint_url:
        model_name += "-384"
    elif "512" in checkpoint_url:
        model_name += "-512"

    if push_to_hub:
        print(f'Pushing {model_name} to the hub...'				)
        model.push_to_hub(__UpperCAmelCase				)
        preprocessor.push_to_hub(__UpperCAmelCase				)


if __name__ == "__main__":
  a_      =  argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      "--checkpoint_url",
      default="https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt",
      type=str,
      help="URL of the original ConvNeXTV2 checkpoint you'd like to convert.",
  )
  parser.add_argument(
      "--pytorch_dump_folder_path",
      default="model",
      type=str,
      help="Path to the output PyTorch model directory.",
  )
  parser.add_argument("--save_model", action="store_true", help="Save model to local")
  parser.add_argument("--push_to_hub", action="store_true", help="Push model and image preprocessor to the hub")

  a_      =  parser.parse_args()
  convert_convnextva_checkpoint(
      args.checkpoint_url, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub
  )









"""simple docstring"""







import numpy as np
import torch
import torch.nn as nn
from transformers import CLIPConfig, CLIPVisionModel, PreTrainedModel

from ...utils import logging


UpperCAmelCase:   Dict       			=							logging.get_logger(__name__)


def       __SCREAMING_SNAKE_CASE      (   __UpperCAmelCase					,							__UpperCAmelCase	):
		_lowercase							:      List[str]			=					nn.functional.normalize(__UpperCAmelCase	)
		_lowercase							:      int			=					nn.functional.normalize(__UpperCAmelCase	)
		return torch.mm(__UpperCAmelCase					,							normalized_text_embeds.t()	)





class    UpperCamelCase     (			snake_case    ):




	"""simple docstring"""
	SCREAMING_SNAKE_CASE_				:    List[str]		    =   CLIPConfig

	SCREAMING_SNAKE_CASE_				:    List[Any]		    =   ["CLIPEncoderLayer"]






	def __init__(			self							,UpperCAmelCase_					):
			super().__init__(UpperCAmelCase_					)

			_lowercase							:      Any			=					CLIPVisionModel(config.vision_config					)
			_lowercase							:      Any			=					nn.Linear(config.vision_config.hidden_size							,config.projection_dim							,bias=UpperCAmelCase_					)

			_lowercase							:      Dict			=					nn.Parameter(torch.ones(17							,config.projection_dim					)							,requires_grad=UpperCAmelCase_					)
			_lowercase							:      Tuple			=					nn.Parameter(torch.ones(3							,config.projection_dim					)							,requires_grad=UpperCAmelCase_					)

			_lowercase							:      Optional[int]			=					nn.Parameter(torch.ones(17					)							,requires_grad=UpperCAmelCase_					)
			_lowercase							:      List[Any]			=					nn.Parameter(torch.ones(3					)							,requires_grad=UpperCAmelCase_					)






	@torch.no_grad()
	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_					):
			_lowercase							:      List[str]			=					self.vision_model(UpperCAmelCase_					)[1]  # pooled_output
			_lowercase							:      str			=					self.visual_projection(UpperCAmelCase_					)

			# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
			_lowercase							:      Union[str, Any]			=					cosine_distance(UpperCAmelCase_							,self.special_care_embeds					).cpu().float().numpy()
			_lowercase							:      str			=					cosine_distance(UpperCAmelCase_							,self.concept_embeds					).cpu().float().numpy()

			_lowercase							:      List[str]			=					[]
			_lowercase							:      Optional[Any]			=					image_embeds.shape[0]
			for i in range(UpperCAmelCase_					):
					_lowercase							:      int			=					{"""special_scores""": {}, """special_care""": [], """concept_scores""": {}, """bad_concepts""": []}

					# increase this value to create a stronger `nfsw` filter
					# at the cost of increasing the possibility of filtering benign images
					_lowercase							:      str			=					0.0

					for concept_idx in range(len(special_cos_dist[0]					)					):
							_lowercase							:      Optional[Any]			=					special_cos_dist[i][concept_idx]
							_lowercase							:      str			=					self.special_care_embeds_weights[concept_idx].item()
							_lowercase							:      Tuple			=					round(concept_cos - concept_threshold + adjustment							,3					)
							if result_img["special_scores"][concept_idx] > 0:
									result_img["special_care"].append({concept_idx, result_img["""special_scores"""][concept_idx]}					)
									_lowercase							:      Union[str, Any]			=					0.01

					for concept_idx in range(len(cos_dist[0]					)					):
							_lowercase							:      Union[str, Any]			=					cos_dist[i][concept_idx]
							_lowercase							:      str			=					self.concept_embeds_weights[concept_idx].item()
							_lowercase							:      str			=					round(concept_cos - concept_threshold + adjustment							,3					)
							if result_img["concept_scores"][concept_idx] > 0:
									result_img["bad_concepts"].append(UpperCAmelCase_					)

					result.append(UpperCAmelCase_					)

			_lowercase							:      List[str]			=					[len(res["""bad_concepts"""]					) > 0 for res in result]

			for idx, has_nsfw_concept in enumerate(UpperCAmelCase_					):
					if has_nsfw_concept:
							if torch.is_tensor(UpperCAmelCase_					) or torch.is_tensor(images[0]					):
									_lowercase							:      List[Any]			=					torch.zeros_like(images[idx]					)  # black image
							else:
									_lowercase							:      Any			=					np.zeros(images[idx].shape					)  # black image

			if any(UpperCAmelCase_					):
					logger.warning(
					    """Potential NSFW content was detected in one or more images. A black image will be returned instead."""
					    """ Try again with a different prompt and/or seed."""					)

			return images, has_nsfw_concepts






	@torch.no_grad()
	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_					):
			_lowercase							:      List[Any]			=					self.vision_model(UpperCAmelCase_					)[1]  # pooled_output
			_lowercase							:      Optional[int]			=					self.visual_projection(UpperCAmelCase_					)

			_lowercase							:      Union[str, Any]			=					cosine_distance(UpperCAmelCase_							,self.special_care_embeds					)
			_lowercase							:      Tuple			=					cosine_distance(UpperCAmelCase_							,self.concept_embeds					)

			# increase this value to create a stronger `nsfw` filter
			# at the cost of increasing the possibility of filtering benign images
			_lowercase							:      Any			=					0.0

			_lowercase							:      Tuple			=					special_cos_dist - self.special_care_embeds_weights + adjustment
			# special_scores = special_scores.round(decimals=3)
			_lowercase							:      Dict			=					torch.any(special_scores > 0							,dim=1					)
			_lowercase							:      Any			=					special_care * 0.01
			_lowercase							:      Optional[int]			=					special_adjustment.unsqueeze(1					).expand(-1							,cos_dist.shape[1]					)

			_lowercase							:      Optional[Any]			=					(cos_dist - self.concept_embeds_weights) + special_adjustment
			# concept_scores = concept_scores.round(decimals=3)
			_lowercase							:      Optional[int]			=					torch.any(concept_scores > 0							,dim=1					)

			_lowercase							:      Tuple			=					0.0  # black image

			return images, has_nsfw_concepts



