






import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import VivitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor


if is_torch_available():
					import torch
					from torch import nn

					from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VivitForVideoClassification, VivitModel
					from transformers.models.vivit.modeling_vivit import VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from transformers import VivitImageProcessor


class 			__SCREAMING_SNAKE_CASE    :






						def __init__(		self   ,  _UpperCamelCase   ,  _UpperCamelCase=2   ,  _UpperCamelCase=True   ,  _UpperCamelCase=True   ,  _UpperCamelCase=10   ,  _UpperCamelCase=10   ,  _UpperCamelCase=8   ,  _UpperCamelCase=[2, 4, 4]   ,  _UpperCamelCase=3   ,  _UpperCamelCase=7_68   ,  _UpperCamelCase=5   ,  _UpperCamelCase=4   ,  _UpperCamelCase=37   ,  _UpperCamelCase="gelu_fast"   ,  _UpperCamelCase=0.0   ,  _UpperCamelCase=0.0   ,  _UpperCamelCase=0.02   ,  _UpperCamelCase=1E-06   ,  _UpperCamelCase=True   ,  _UpperCamelCase=None   ,  ):






												"""simple docstring"""
												lowerCAmelCase__			  =  parent
												lowerCAmelCase__			  =  batch_size
												lowerCAmelCase__			  =  is_training
												lowerCAmelCase__			  =  use_labels
												lowerCAmelCase__			  =  num_labels
												lowerCAmelCase__			  =  image_size
												lowerCAmelCase__			  =  num_frames
												lowerCAmelCase__			  =  tubelet_size
												lowerCAmelCase__			  =  num_channels
												lowerCAmelCase__			  =  hidden_size
												lowerCAmelCase__			  =  num_hidden_layers
												lowerCAmelCase__			  =  num_attention_heads
												lowerCAmelCase__			  =  intermediate_size
												lowerCAmelCase__			  =  hidden_act
												lowerCAmelCase__			  =  hidden_dropout_prob
												lowerCAmelCase__			  =  attention_probs_dropout_prob
												lowerCAmelCase__			  =  initializer_range
												lowerCAmelCase__			  =  layer_norm_eps
												lowerCAmelCase__			  =  qkv_bias
												lowerCAmelCase__			  =  scope

												lowerCAmelCase__			  =  (
												    (self.image_size // self.tubelet_size[2])
												    * (self.image_size // self.tubelet_size[1])
												    * (self.num_frames // self.tubelet_size[0])
												) + 1  # CLS token






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  floats_tensor(
												    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]      )

												lowerCAmelCase__			  =  None
												if self.use_labels:
																		lowerCAmelCase__			  =  ids_tensor([self.batch_size]   ,  self.num_labels      )

												lowerCAmelCase__			  =  self.get_config()

												return config, pixel_values, labels






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  VivitConfig(
												    num_frames=self.num_frames   ,  image_size=self.image_size   ,  tubelet_size=self.tubelet_size   ,  num_channels=self.num_channels   ,  hidden_size=self.hidden_size   ,  num_hidden_layers=self.num_hidden_layers   ,  num_attention_heads=self.num_attention_heads   ,  intermediate_size=self.intermediate_size   ,  hidden_act=self.hidden_act   ,  hidden_dropout_prob=self.hidden_dropout_prob   ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,  initializer_range=self.initializer_range   ,  layer_norm_eps=self.layer_norm_eps   ,  qkv_bias=self.qkv_bias   ,  )
												lowerCAmelCase__			  =  self.num_labels
												return config






						def 					UpperCamelCase__					(		self   ,  _UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  VivitModel(config=_UpperCamelCase      )
												model.to(_UpperCamelCase      )
												model.eval()
												lowerCAmelCase__			  =  model(_UpperCamelCase      )
												self.parent.assertEqual(result.last_hidden_state.shape   ,  (self.batch_size, self.seq_length, self.hidden_size)      )






						def 					UpperCamelCase__					(		self   ,  _UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  VivitForVideoClassification(_UpperCamelCase      )
												model.to(_UpperCamelCase      )
												model.eval()

												lowerCAmelCase__			  =  model(_UpperCamelCase      )

												# verify the logits shape
												lowerCAmelCase__			  =  torch.Size((self.batch_size, self.num_labels)      )
												self.parent.assertEqual(result.logits.shape   ,  _UpperCamelCase      )







						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  self.prepare_config_and_inputs()
												lowerCAmelCase__  ,				lowerCAmelCase__  ,				lowerCAmelCase__			  =  config_and_inputs
												lowerCAmelCase__			  =  {'pixel_values': pixel_values}
												return config, inputs_dict




@require_torch
class 			__SCREAMING_SNAKE_CASE    (      __lowercase						,    unittest.TestCase):
						_SCREAMING_SNAKE_CASE		:				Tuple            =    (VivitModel, VivitForVideoClassification) if is_torch_available() else ()

						_SCREAMING_SNAKE_CASE		:				str            =    False
						_SCREAMING_SNAKE_CASE		:				List[Any]            =    False
						_SCREAMING_SNAKE_CASE		:				Optional[Any]            =    False
						_SCREAMING_SNAKE_CASE		:				Dict            =    False






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  VivitModelTester(self      )
												lowerCAmelCase__			  =  ConfigTester(self   ,  config_class=_UpperCamelCase   ,  has_text_modality=_UpperCamelCase   ,  hidden_size=37      )






						def 					UpperCamelCase__					(		self   ,  _UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase=False      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  copy.deepcopy(_UpperCamelCase      )

												if return_labels:
																		if model_class in get_values(_UpperCamelCase      ):
																								lowerCAmelCase__			  =  torch.zeros(
																								    self.model_tester.batch_size   ,  dtype=torch.long   ,  device=_UpperCamelCase      )

												return inputs_dict






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												self.config_tester.run_common_tests()






						@unittest.skip(reason='Vivit does not use inputs_embeds'      )
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												pass






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__  ,				lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		lowerCAmelCase__			  =  model_class(_UpperCamelCase      )
																		self.assertIsInstance(model.get_input_embeddings()   ,  (nn.Module)      )
																		lowerCAmelCase__			  =  model.get_output_embeddings()
																		self.assertTrue(x is None or isinstance(_UpperCamelCase   ,  nn.Linear      )      )






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__  ,				lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		lowerCAmelCase__			  =  model_class(_UpperCamelCase      )
																		lowerCAmelCase__			  =  inspect.signature(model.forward      )
																		# signature.parameters is an OrderedDict => so arg_names order is deterministic
																		lowerCAmelCase__			  =  [*signature.parameters.keys()]

																		lowerCAmelCase__			  =  ['pixel_values', 'head_mask']
																		self.assertListEqual(arg_names[:2]   ,  _UpperCamelCase      )






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_UpperCamelCase      )






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_video_classification(*_UpperCamelCase      )






						@slow
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												for model_name in VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase__			  =  VivitModel.from_pretrained(_UpperCamelCase      )
																		self.assertIsNotNone(_UpperCamelCase      )






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__  ,				lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs_for_common()
												lowerCAmelCase__			  =  True

												for model_class in self.all_model_classes:
																		lowerCAmelCase__			  =  self.model_tester.seq_length

																		lowerCAmelCase__			  =  True
																		lowerCAmelCase__			  =  False
																		lowerCAmelCase__			  =  True
																		lowerCAmelCase__			  =  model_class(_UpperCamelCase      )
																		model.to(_UpperCamelCase      )
																		model.eval()
																		with torch.no_grad():
																								lowerCAmelCase__			  =  model(**self._prepare_for_class(_UpperCamelCase   ,  _UpperCamelCase      )      )
																		lowerCAmelCase__			  =  outputs.attentions
																		self.assertEqual(len(_UpperCamelCase      )   ,  self.model_tester.num_hidden_layers      )

																		# check that output_attentions also work using config
																		del inputs_dict["output_attentions"]
																		lowerCAmelCase__			  =  True
																		lowerCAmelCase__			  =  model_class(_UpperCamelCase      )
																		model.to(_UpperCamelCase      )
																		model.eval()
																		with torch.no_grad():
																								lowerCAmelCase__			  =  model(**self._prepare_for_class(_UpperCamelCase   ,  _UpperCamelCase      )      )
																		lowerCAmelCase__			  =  outputs.attentions
																		self.assertEqual(len(_UpperCamelCase      )   ,  self.model_tester.num_hidden_layers      )

																		self.assertListEqual(
																		    list(attentions[0].shape[-3:]      )   ,  [self.model_tester.num_attention_heads, seq_len, seq_len]   ,  )
																		lowerCAmelCase__			  =  len(_UpperCamelCase      )

																		# Check attention is always last and order is fine
																		lowerCAmelCase__			  =  True
																		lowerCAmelCase__			  =  True
																		lowerCAmelCase__			  =  model_class(_UpperCamelCase      )
																		model.to(_UpperCamelCase      )
																		model.eval()
																		with torch.no_grad():
																								lowerCAmelCase__			  =  model(**self._prepare_for_class(_UpperCamelCase   ,  _UpperCamelCase      )      )

																		self.assertEqual(out_len + 1   ,  len(_UpperCamelCase      )      )

																		lowerCAmelCase__			  =  outputs.attentions

																		self.assertEqual(len(_UpperCamelCase      )   ,  self.model_tester.num_hidden_layers      )

																		self.assertListEqual(
																		    list(self_attentions[0].shape[-3:]      )   ,  [self.model_tester.num_attention_heads, seq_len, seq_len]   ,  )






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												def check_hidden_states_output(_UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      ):
																		lowerCAmelCase__			  =  model_class(_UpperCamelCase      )
																		model.to(_UpperCamelCase      )
																		model.eval()

																		with torch.no_grad():
																								lowerCAmelCase__			  =  model(**self._prepare_for_class(_UpperCamelCase   ,  _UpperCamelCase      )      )

																		lowerCAmelCase__			  =  outputs.hidden_states
																		lowerCAmelCase__			  =  self.model_tester.num_hidden_layers + 1
																		self.assertEqual(len(_UpperCamelCase      )   ,  _UpperCamelCase      )

																		lowerCAmelCase__			  =  self.model_tester.seq_length

																		self.assertListEqual(
																		    list(hidden_states[0].shape[-2:]      )   ,  [seq_length, self.model_tester.hidden_size]   ,  )

												lowerCAmelCase__  ,				lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		lowerCAmelCase__			  =  True
																		check_hidden_states_output(_UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      )

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		lowerCAmelCase__			  =  True

																		check_hidden_states_output(_UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      )







						@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'      )
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												pass







def 		_UpperCamelCase      (			)     ->      List[str]:

						"""simple docstring"""



						lowerCAmelCase__			  =  hf_hub_download(
						    repo_id='hf-internal-testing/spaghetti-video'			,				filename='eating_spaghetti_32_frames.npy'			,				repo_type='dataset'						)
						lowerCAmelCase__			  =  np.load(UpperCamelCase_						)
						return list(UpperCamelCase_						)


@require_torch
@require_vision
class 			__SCREAMING_SNAKE_CASE    (      unittest.TestCase):






						@cached_property
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												return VivitImageProcessor() if is_vision_available() else None







						@slow
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  VivitForVideoClassification.from_pretrained('google/vivit-b-16x2-kinetics400'      ).to(_UpperCamelCase      )

												lowerCAmelCase__			  =  self.default_image_processor
												lowerCAmelCase__			  =  prepare_video()
												lowerCAmelCase__			  =  image_processor(_UpperCamelCase   ,  return_tensors='pt'      ).to(_UpperCamelCase      )

												# forward pass
												with torch.no_grad():
																		lowerCAmelCase__			  =  model(**_UpperCamelCase      )

												# verify the logits
												lowerCAmelCase__			  =  torch.Size((1, 4_00)      )
												self.assertEqual(outputs.logits.shape   ,  _UpperCamelCase      )

												# taken from original model
												lowerCAmelCase__			  =  torch.tensor([-1.05_43, 2.07_64, -0.21_04, 0.44_39, -0.96_58]      ).to(_UpperCamelCase      )

												self.assertTrue(torch.allclose(outputs.logits[0, :5]   ,  _UpperCamelCase   ,  atol=1E-4      )      )













import argparse
import collections

import jax
import jax.numpy as jnp
import torch
import torch.nn as nn
from clip.model import CLIP
from flax.training import checkpoints
from huggingface_hub import Repository

from transformers import (
    CLIPTokenizer,
    OwlViTConfig,
    OwlViTForObjectDetection,
    OwlViTImageProcessor,
    OwlViTModel,
    OwlViTProcessor,
)


__snake_case			:			int			   =   {
    """vit_b32""": {
        """embed_dim""": 5_12,
        """image_resolution""": 7_68,
        """context_length""": 16,
        """vocab_size""": 4_94_08,
        """vision_layers""": 12,
        """vision_width""": 7_68,
        """vision_patch_size""": 32,
        """transformer_width""": 5_12,
        """transformer_heads""": 8,
        """transformer_layers""": 12,
    },
    """vit_b16""": {
        """embed_dim""": 5_12,
        """image_resolution""": 7_68,
        """context_length""": 16,
        """vocab_size""": 4_94_08,
        """vision_layers""": 12,
        """vision_width""": 7_68,
        """vision_patch_size""": 16,
        """transformer_width""": 5_12,
        """transformer_heads""": 8,
        """transformer_layers""": 12,
    },
    """vit_l14""": {
        """embed_dim""": 7_68,
        """image_resolution""": 8_40,
        """context_length""": 16,
        """vocab_size""": 4_94_08,
        """vision_layers""": 24,
        """vision_width""": 10_24,
        """vision_patch_size""": 14,
        """transformer_width""": 7_68,
        """transformer_heads""": 12,
        """transformer_layers""": 12,
    },
}







def 		_UpperCamelCase      (			UpperCamelCase_				:    Dict			,				UpperCamelCase_				:    Any=""			,				UpperCamelCase_				:    List[str]="/"						)     ->      List[str]:

						"""simple docstring"""



						lowerCAmelCase__			  =  []

						for k, v in params.items():
												lowerCAmelCase__			  =  parent_key + sep + k if parent_key else k

												if isinstance(UpperCamelCase_			,				collections.MutableMapping						):
																		items.extend(flatten_nested_dict(UpperCamelCase_			,				UpperCamelCase_			,				sep=UpperCamelCase_						).items()						)
												else:
																		items.append((new_key, v)						)
						return dict(UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Tuple						)     ->      Optional[int]:

						"""simple docstring"""



						return jax.tree_util.tree_map(lambda UpperCamelCase_						: x.astype(jnp.floataa						) if x.dtype == jnp.bfloataa else x			,				UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Optional[int]			,				UpperCamelCase_				:    Union[str, Any]						)     ->      List[Any]:

						"""simple docstring"""



						lowerCAmelCase__  ,				lowerCAmelCase__  ,				lowerCAmelCase__			  =  pt_attn_layer.in_proj_weight.chunk(3			,				dim=0						)
						lowerCAmelCase__  ,				lowerCAmelCase__  ,				lowerCAmelCase__			  =  pt_attn_layer.in_proj_bias.chunk(3			,				dim=0						)

						lowerCAmelCase__			  =  pt_attn_layer.out_proj.weight
						lowerCAmelCase__			  =  pt_attn_layer.out_proj.bias

						lowerCAmelCase__			  =  q_proj
						lowerCAmelCase__			  =  q_proj_bias

						lowerCAmelCase__			  =  k_proj
						lowerCAmelCase__			  =  k_proj_bias

						lowerCAmelCase__			  =  v_proj
						lowerCAmelCase__			  =  v_proj_bias

						lowerCAmelCase__			  =  out_proj_weights
						lowerCAmelCase__			  =  out_proj_bias







def 		_UpperCamelCase      (			UpperCamelCase_				:    Tuple			,				UpperCamelCase_				:    Union[str, Any]						)     ->      Union[str, Any]:

						"""simple docstring"""



						copy_linear(hf_mlp.fca			,				pt_mlp.c_fc						)
						copy_linear(hf_mlp.fca			,				pt_mlp.c_proj						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Union[str, Any]			,				UpperCamelCase_				:    Tuple						)     ->      Optional[Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  pt_linear.weight
						lowerCAmelCase__			  =  pt_linear.bias







def 		_UpperCamelCase      (			UpperCamelCase_				:    Any			,				UpperCamelCase_				:    Optional[Any]						)     ->      Tuple:

						"""simple docstring"""



						copy_linear(hf_layer.layer_norma			,				pt_layer.ln_a						)
						copy_linear(hf_layer.layer_norma			,				pt_layer.ln_a						)

						# copy MLP
						copy_mlp(hf_layer.mlp			,				pt_layer.mlp						)

						# copy attn
						copy_attn_layer(hf_layer.self_attn			,				pt_layer.attn						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Optional[int]			,				UpperCamelCase_				:    List[str]						)     ->      Optional[int]:

						"""simple docstring"""



						for hf_layer, pt_layer in zip(UpperCamelCase_			,				UpperCamelCase_						):
												copy_layer(UpperCamelCase_			,				UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Dict			,				UpperCamelCase_				:    Union[str, Any]						)     ->      Optional[Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  pt_model.token_embedding.weight
						lowerCAmelCase__			  =  pt_model.positional_embedding

						# copy layer norm
						copy_linear(hf_encoder.final_layer_norm			,				pt_model.ln_final						)

						# copy hidden layers
						copy_layers(hf_encoder.encoder.layers			,				pt_model.transformer.resblocks						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Optional[int]			,				UpperCamelCase_				:    Dict						)     ->      Union[str, Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  pt_model.text_projection.data.T

						# copy text encoder
						copy_encoder(hf_model.text_model			,				UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Any			,				UpperCamelCase_				:    str						)     ->      Tuple:

						"""simple docstring"""



						lowerCAmelCase__			  =  pt_model.visual.proj.data.T

						# copy layer norms
						copy_linear(hf_model.vision_model.pre_layernorm			,				pt_model.visual.ln_pre						)
						copy_linear(hf_model.vision_model.post_layernorm			,				pt_model.visual.ln_post						)

						# copy embeds
						lowerCAmelCase__			  =  pt_model.visual.conva.weight.data
						lowerCAmelCase__			  =  pt_model.visual.class_embedding
						lowerCAmelCase__			  =  pt_model.visual.positional_embedding.data

						# copy encoder
						copy_layers(hf_model.vision_model.encoder.layers			,				pt_model.visual.transformer.resblocks						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    List[Any]			,				UpperCamelCase_				:    Any						)     ->      List[str]:

						"""simple docstring"""



						lowerCAmelCase__			  =  flatten_nested_dict(flax_params['backbone']['merged_class_token']						)

						lowerCAmelCase__			  =  torch.from_numpy(flax_class_token_params['scale']						)
						lowerCAmelCase__			  =  torch.from_numpy(flax_class_token_params['bias']						)
						lowerCAmelCase__			  =  nn.Parameter(UpperCamelCase_						)
						lowerCAmelCase__			  =  nn.Parameter(UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    str			,				UpperCamelCase_				:    Union[str, Any]						)     ->      Union[str, Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  hf_model.state_dict()
						lowerCAmelCase__			  =  {}

						# Rename class prediction head flax params to pytorch HF
						lowerCAmelCase__			  =  flatten_nested_dict(flax_params['class_head']						)

						for flax_key, v in flax_class_params.items():
												lowerCAmelCase__			  =  flax_key.replace('/'			,				'.'						)
												lowerCAmelCase__			  =  torch_key.replace('.kernel'			,				'.weight'						)
												lowerCAmelCase__			  =  torch_key.replace('Dense_0'			,				'dense0'						)
												lowerCAmelCase__			  =  'class_head.' + torch_key

												if "weight" in torch_key and v.ndim == 2:
																		lowerCAmelCase__			  =  v.T

												lowerCAmelCase__			  =  nn.Parameter(torch.from_numpy(UpperCamelCase_						)						)

						# Rename box prediction box flax params to pytorch HF
						lowerCAmelCase__			  =  flatten_nested_dict(flax_params['obj_box_head']						)

						for flax_key, v in flax_box_params.items():
												lowerCAmelCase__			  =  flax_key.replace('/'			,				'.'						)
												lowerCAmelCase__			  =  torch_key.replace('.kernel'			,				'.weight'						)
												lowerCAmelCase__			  =  torch_key.replace('_'			,				''						).lower()
												lowerCAmelCase__			  =  'box_head.' + torch_key

												if "weight" in torch_key and v.ndim == 2:
																		lowerCAmelCase__			  =  v.T

												lowerCAmelCase__			  =  nn.Parameter(torch.from_numpy(UpperCamelCase_						)						)

						# Copy flax params to PyTorch params
						for name, param in new_params.items():
												if name in pt_params.keys():
																		pt_params[name].copy_(UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Tuple			,				UpperCamelCase_				:    List[str]						)     ->      str:

						"""simple docstring"""



						for k, v in flax_attn_params.items():
												if k.startswith('transformer'						):
																		lowerCAmelCase__			  =  k.replace('transformer.resblocks'			,				'text_model.encoder.layers'						)
												else:
																		lowerCAmelCase__			  =  k.replace('visual.transformer.resblocks'			,				'vision_model.encoder.layers'						)

												lowerCAmelCase__			  =  torch_key.replace('attn'			,				'self_attn'						)
												lowerCAmelCase__			  =  torch_key.replace('key'			,				'k_proj'						)
												lowerCAmelCase__			  =  torch_key.replace('value'			,				'v_proj'						)
												lowerCAmelCase__			  =  torch_key.replace('query'			,				'q_proj'						)
												lowerCAmelCase__			  =  torch_key.replace('out'			,				'out_proj'						)

												if "bias" in torch_key and v.ndim == 2:
																		lowerCAmelCase__			  =  v.shape[0] * v.shape[1]
																		lowerCAmelCase__			  =  v.reshape(UpperCamelCase_						)

												if "weight" in torch_key and "out" in torch_key:
																		lowerCAmelCase__			  =  (v.shape[0] * v.shape[1], v.shape[2])
																		lowerCAmelCase__			  =  v.reshape(UpperCamelCase_						).T

												if "weight" in torch_key and "out" not in torch_key:
																		lowerCAmelCase__			  =  (v.shape[0], v.shape[1] * v.shape[2])
																		lowerCAmelCase__			  =  v.reshape(UpperCamelCase_						).T

												# Copy flax CLIP attn params to HF PyTorch params
												lowerCAmelCase__			  =  torch.from_numpy(UpperCamelCase_						)
												hf_backbone.state_dict()[torch_key].copy_(UpperCamelCase_						)







def 		_UpperCamelCase      (			UpperCamelCase_				:    Any						)     ->      Dict:

						"""simple docstring"""



						lowerCAmelCase__			  =  {}
						lowerCAmelCase__			  =  []

						for k, v in params.items():
												if "attn." in k:
																		lowerCAmelCase__			  =  k[: k.rindex('attn.'						) + 5]
																		if base in processed_attn_layers:
																								continue

																		processed_attn_layers.append(UpperCamelCase_						)
																		lowerCAmelCase__			  =  params[base + 'out.weight'].shape[-1]
																		lowerCAmelCase__			  =  params[base + 'out.weight'].reshape(UpperCamelCase_			,				UpperCamelCase_						).T
																		lowerCAmelCase__			  =  params[base + 'out.bias']
												else:
																		lowerCAmelCase__			  =  v
						return new_params







def 		_UpperCamelCase      (			UpperCamelCase_				:    List[Any]			,				UpperCamelCase_				:    int						)     ->      Optional[Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  CLIP(**UpperCamelCase_						)
						torch_model.eval()
						lowerCAmelCase__			  =  torch_model.state_dict()

						lowerCAmelCase__			  =  flatten_nested_dict(flax_params['backbone']['clip']						)
						lowerCAmelCase__			  =  {}

						for flax_key, v in flax_clip_params.items():
												lowerCAmelCase__			  =  flax_key.replace('/'			,				'.'						)
												lowerCAmelCase__			  =  torch_key.replace('text.token_embedding.embedding'			,				'token_embedding.kernel'						)

												if (
												    torch_key.startswith('text.transformer'						)
												    or torch_key.startswith('text.text_projection'						)
												    or torch_key.startswith('text.ln_final'						)
												    or torch_key.startswith('text.positional_embedding'						)
												):
																		lowerCAmelCase__			  =  torch_key[5:]

												lowerCAmelCase__			  =  torch_key.replace('text_projection.kernel'			,				'text_projection'						)
												lowerCAmelCase__			  =  torch_key.replace('visual.proj.kernel'			,				'visual.proj'						)
												lowerCAmelCase__			  =  torch_key.replace('.scale'			,				'.weight'						)
												lowerCAmelCase__			  =  torch_key.replace('.kernel'			,				'.weight'						)

												if "conv" in torch_key or "downsample.0.weight" in torch_key:
																		lowerCAmelCase__			  =  v.transpose(3			,				2			,				0			,				1						)

												elif "weight" in torch_key and v.ndim == 2 and "embedding" not in torch_key:
																		# Fully connected layers are transposed, embeddings are not
																		lowerCAmelCase__			  =  v.T

												lowerCAmelCase__			  =  v

						lowerCAmelCase__			  =  _convert_attn_layers(UpperCamelCase_						)
						new_torch_params.update(UpperCamelCase_						)
						lowerCAmelCase__			  =  {}

						# Copy flax CLIP backbone params to PyTorch params
						for name, param in new_torch_params.items():
												if name in torch_clip_params.keys():
																		lowerCAmelCase__			  =  torch.from_numpy(new_torch_params[name]						)
																		torch_clip_params[name].copy_(UpperCamelCase_						)
												else:
																		lowerCAmelCase__			  =  param

						return torch_clip_params, torch_model, attn_params







@torch.no_grad()
def 		_UpperCamelCase      (			UpperCamelCase_				:    Any			,				UpperCamelCase_				:    Union[str, Any]			,				UpperCamelCase_				:    Dict			,				UpperCamelCase_				:    List[Any]			,				UpperCamelCase_				:    List[Any]=None						)     ->      Any:

						"""simple docstring"""



						lowerCAmelCase__			  =  Repository(UpperCamelCase_			,				clone_from=F"google/{pytorch_dump_folder_path}"						)
						repo.git_pull()

						if config_path is not None:
												lowerCAmelCase__			  =  OwlViTConfig.from_pretrained(UpperCamelCase_						)
						else:
												lowerCAmelCase__			  =  OwlViTConfig()

						lowerCAmelCase__			  =  OwlViTModel(UpperCamelCase_						).eval()
						lowerCAmelCase__			  =  OwlViTForObjectDetection(UpperCamelCase_						).eval()

						copy_text_model_and_projection(UpperCamelCase_			,				UpperCamelCase_						)
						copy_vision_model_and_projection(UpperCamelCase_			,				UpperCamelCase_						)
						lowerCAmelCase__			  =  pt_backbone.logit_scale
						copy_flax_attn_params(UpperCamelCase_			,				UpperCamelCase_						)

						lowerCAmelCase__			  =  hf_backbone
						copy_class_merge_token(UpperCamelCase_			,				UpperCamelCase_						)
						copy_class_box_heads(UpperCamelCase_			,				UpperCamelCase_						)

						# Save HF model
						hf_model.save_pretrained(repo.local_dir						)

						# Initialize image processor
						lowerCAmelCase__			  =  OwlViTImageProcessor(
						    size=config.vision_config.image_size			,				crop_size=config.vision_config.image_size						)
						# Initialize tokenizer
						lowerCAmelCase__			  =  CLIPTokenizer.from_pretrained('openai/clip-vit-base-patch32'			,				pad_token='!'			,				model_max_length=16						)

						# Initialize processor
						lowerCAmelCase__			  =  OwlViTProcessor(image_processor=UpperCamelCase_			,				tokenizer=UpperCamelCase_						)
						image_processor.save_pretrained(repo.local_dir						)
						processor.save_pretrained(repo.local_dir						)

						repo.git_add()
						repo.git_commit('Upload model and processor'						)
						repo.git_push()


if __name__ == "__main__":
					__snake_case			:			Union[str, Any]			   =   argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    """--owlvit_version""",
					    default=None,
					    type=str,
					    required=True,
					    help="""OWL-ViT model name [clip_b16, clip_b32, clip_l14].""",
					)
					parser.add_argument(
					    """--owlvit_checkpoint""", default=None, type=str, required=True, help="""Path to flax model checkpoint."""
					)
					parser.add_argument("""--hf_config""", default=None, type=str, required=True, help="""Path to HF model config.""")
					parser.add_argument(
					    """--pytorch_dump_folder_path""", default="""hf_model""", type=str, help="""Path to the output PyTorch model."""
					)
					__snake_case			:			Any			   =   parser.parse_args()

					# Initialize PyToch clip model
					__snake_case			:			int			   =   args.owlvit_version
					if model_name == "clip_b16":
										__snake_case			:			Optional[Any]			   =   CONFIGS["""vit_b16"""]
					elif model_name == "clip_b32":
										__snake_case			:			Optional[int]			   =   CONFIGS["""vit_b32"""]
					elif model_name == "clip_l14":
										__snake_case			:			int			   =   CONFIGS["""vit_l14"""]

					# Load from checkpoint and convert params to float-32
					__snake_case			:			List[str]			   =   checkpoints.restore_checkpoint(args.owlvit_checkpoint, target=None)["""optimizer"""]["""target"""]
					__snake_case			:			List[str]			   =   jax.tree_util.tree_map(lambda x: x.astype(jnp.floataa) if x.dtype == jnp.bfloataa else x, variables)
					del variables

					# Convert CLIP backbone
					__snake_case   ,       __snake_case   ,       __snake_case			:			Tuple			   =   convert_clip_backbone(flax_params, torch_config)

					convert_owlvit_checkpoint(clip_pt, flax_params, attn_params, args.pytorch_dump_folder_path, args.hf_config)





