



'''simple docstring'''



import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel


def 							__UpperCAmelCase				(				UpperCamelCase__				:Dict   ,				UpperCamelCase__				:Any			)		->						Optional[int]:
				snake_case__  ,      snake_case__  ,      snake_case__      :   Dict      =    pt_attn_layer.in_proj_weight.chunk(3   ,				dim=0			)
				snake_case__  ,      snake_case__  ,      snake_case__      :   List[str]      =    pt_attn_layer.in_proj_bias.chunk(3   ,				dim=0			)

				snake_case__      :   List[Any]      =    pt_attn_layer.out_proj.weight
				snake_case__      :   int      =    pt_attn_layer.out_proj.bias

				snake_case__      :   str      =    q_proj
				snake_case__      :   List[Any]      =    q_proj_bias

				snake_case__      :   Dict      =    k_proj
				snake_case__      :   Dict      =    k_proj_bias

				snake_case__      :   List[str]      =    v_proj
				snake_case__      :   List[str]      =    v_proj_bias

				snake_case__      :   List[Any]      =    out_proj_weights
				snake_case__      :   List[Any]      =    out_proj_bias


def 							__UpperCAmelCase				(				UpperCamelCase__				:int   ,				UpperCamelCase__				:Any			)		->						List[str]:
				copy_linear(hf_mlp.fca   ,				pt_mlp.c_fc			)
				copy_linear(hf_mlp.fca   ,				pt_mlp.c_proj			)


def 							__UpperCAmelCase				(				UpperCamelCase__				:Tuple   ,				UpperCamelCase__				:Tuple			)		->						Union[str, Any]:
				snake_case__      :   str      =    pt_linear.weight
				snake_case__      :   Optional[int]      =    pt_linear.bias


def 							__UpperCAmelCase				(				UpperCamelCase__				:Optional[int]   ,				UpperCamelCase__				:Optional[Any]			)		->						Optional[int]:
				# copy layer norms
				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__				:str   ,				UpperCamelCase__				:Any			)		->						Optional[int]:
				for hf_layer, pt_layer in zip(UpperCamelCase__   ,				UpperCamelCase__			):
								copy_layer(UpperCamelCase__   ,				UpperCamelCase__			)


def 							__UpperCAmelCase				(				UpperCamelCase__				:Optional[Any]   ,				UpperCamelCase__				:List[str]			)		->						Dict:
				# copy  embeds
				snake_case__      :   Any      =    pt_model.token_embedding.weight
				snake_case__      :   Optional[int]      =    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__				:int   ,				UpperCamelCase__				:Optional[Any]			)		->						str:
				# copy projection
				snake_case__      :   Optional[Any]      =    pt_model.text_projection.data.T

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


def 							__UpperCAmelCase				(				UpperCamelCase__				:str   ,				UpperCamelCase__				:Optional[int]			)		->						Any:
				# copy projection
				snake_case__      :   int      =    pt_model.visual.proj.data.T

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

				# copy embeds
				snake_case__      :   Union[str, Any]      =    pt_model.visual.conva.weight.data
				snake_case__      :   List[str]      =    pt_model.visual.class_embedding
				snake_case__      :   Any      =    pt_model.visual.positional_embedding.data

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


@torch.no_grad()
def 							__UpperCAmelCase				(				UpperCamelCase__				:List[Any]   ,				UpperCamelCase__				:Optional[int]   ,				UpperCamelCase__				:int=None			)		->						Tuple:
				if config_path is not None:
								snake_case__      :   Tuple      =    CLIPConfig.from_pretrained(UpperCamelCase__			)
				else:
								snake_case__      :   List[str]      =    CLIPConfig(projection_dim=512   ,				text_config={}   ,				vision_config={}			)

				snake_case__      :   Any      =    CLIPModel(UpperCamelCase__			).eval()

				snake_case__  ,      snake_case__      :   Optional[int]      =    load(UpperCamelCase__   ,				device='''cpu'''   ,				jit=UpperCamelCase__			)
				snake_case__      :   str      =    pt_model.eval()

				copy_text_model_and_projection(UpperCamelCase__   ,				UpperCamelCase__			)
				copy_vison_model_and_projection(UpperCamelCase__   ,				UpperCamelCase__			)
				snake_case__      :   Any      =    pt_model.logit_scale

				snake_case__      :   str      =    torch.arange(0   ,				77			).unsqueeze(0			)
				snake_case__      :   Dict      =    torch.randn(1   ,				3   ,				224   ,				224			)

				snake_case__      :   Any      =    hf_model(input_ids=UpperCamelCase__   ,				pixel_values=UpperCamelCase__   ,				return_dict=UpperCamelCase__			)
				snake_case__      :   Tuple      =    hf_outputs.logits_per_image
				snake_case__      :   Optional[int]      =    hf_outputs.logits_per_text
				snake_case__  ,      snake_case__      :   Dict      =    pt_model(UpperCamelCase__   ,				UpperCamelCase__			)

				assert torch.allclose(UpperCamelCase__   ,				UpperCamelCase__   ,				atol=1e-3			)
				assert torch.allclose(UpperCamelCase__   ,				UpperCamelCase__   ,				atol=1e-3			)

				hf_model.save_pretrained(UpperCamelCase__			)


if __name__ == "__main__":
				_lowercase       :						str						=argparse.ArgumentParser()
				parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
				parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
				parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
				_lowercase       :						Any						=parser.parse_args()

				convert_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)












import inspect
import unittest
import warnings
from typing import List

from transformers import EfficientFormerConfig
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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
		    MODEL_MAPPING,
		    EfficientFormerForImageClassification,
		    EfficientFormerForImageClassificationWithTeacher,
		    EfficientFormerModel,
		)
		from transformers.models.efficientformer.modeling_efficientformer import (
		    EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
		)


if is_vision_available():
		from PIL import Image

		from transformers import EfficientFormerImageProcessor



class  __UpperCAmelCase						:







			def __init__(      self:    Tuple ,      UpperCAmelCase_:    List[Any] ,      UpperCAmelCase_:    int = 13 ,      UpperCAmelCase_:    int = 64 ,      UpperCAmelCase_:    int = 2 ,      UpperCAmelCase_:    int = 3 ,      UpperCAmelCase_:    int = 3 ,      UpperCAmelCase_:    bool = True ,      UpperCAmelCase_:    bool = True ,      UpperCAmelCase_:    int = 128 ,      UpperCAmelCase_:    Dict=[16, 32, 64, 128] ,      UpperCAmelCase_:    int = 7 ,      UpperCAmelCase_:    int = 4 ,      UpperCAmelCase_:    int = 37 ,      UpperCAmelCase_:    str = "gelu" ,      UpperCAmelCase_:    float = 0.1 ,      UpperCAmelCase_:    float = 0.1 ,      UpperCAmelCase_:    int = 10 ,      UpperCAmelCase_:    float = 0.02 ,      UpperCAmelCase_:    int = 2 ,      UpperCAmelCase_:    int = 1 ,      UpperCAmelCase_:    int = 128 ,      UpperCAmelCase_:    List[int] = [2, 2, 2, 2] ,      UpperCAmelCase_:    int = 2 ,      UpperCAmelCase_:    int = 2 ,      ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    parent
									_SCREAMING_SNAKE_CASE       =    batch_size
									_SCREAMING_SNAKE_CASE       =    image_size
									_SCREAMING_SNAKE_CASE       =    patch_size
									_SCREAMING_SNAKE_CASE       =    num_channels
									_SCREAMING_SNAKE_CASE       =    is_training
									_SCREAMING_SNAKE_CASE       =    use_labels
									_SCREAMING_SNAKE_CASE       =    hidden_size
									_SCREAMING_SNAKE_CASE       =    num_hidden_layers
									_SCREAMING_SNAKE_CASE       =    num_attention_heads
									_SCREAMING_SNAKE_CASE       =    intermediate_size
									_SCREAMING_SNAKE_CASE       =    hidden_act
									_SCREAMING_SNAKE_CASE       =    hidden_dropout_prob
									_SCREAMING_SNAKE_CASE       =    attention_probs_dropout_prob
									_SCREAMING_SNAKE_CASE       =    type_sequence_label_size
									_SCREAMING_SNAKE_CASE       =    initializer_range
									_SCREAMING_SNAKE_CASE       =    encoder_stride
									_SCREAMING_SNAKE_CASE       =    num_attention_outputs
									_SCREAMING_SNAKE_CASE       =    embed_dim
									_SCREAMING_SNAKE_CASE       =    embed_dim + 1
									_SCREAMING_SNAKE_CASE       =    resolution
									_SCREAMING_SNAKE_CASE       =    depths
									_SCREAMING_SNAKE_CASE       =    hidden_sizes
									_SCREAMING_SNAKE_CASE       =    dim
									_SCREAMING_SNAKE_CASE       =    mlp_expansion_ratio







			def 				UpperCamelCase (      self:    Union[str, Any]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

									_SCREAMING_SNAKE_CASE       =    None
									if self.use_labels:
															_SCREAMING_SNAKE_CASE       =    ids_tensor([self.batch_size] ,      self.type_sequence_label_size	)

									_SCREAMING_SNAKE_CASE       =    self.get_config()
									return config, pixel_values, labels







			def 				UpperCamelCase (      self:    List[Any]	):







									'''simple docstring'''




									return EfficientFormerConfig(
									    image_size=self.image_size ,      patch_size=self.patch_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 ,      is_decoder=UpperCAmelCase_ ,      initializer_range=self.initializer_range ,      encoder_stride=self.encoder_stride ,      resolution=self.resolution ,      depths=self.depths ,      hidden_sizes=self.hidden_sizes ,      dim=self.dim ,      mlp_expansion_ratio=self.mlp_expansion_ratio ,      )







			def 				UpperCamelCase (      self:    List[Any] ,      UpperCAmelCase_:    int ,      UpperCAmelCase_:    str ,      UpperCAmelCase_:    Dict	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    EfficientFormerModel(config=UpperCAmelCase_	)
									model.to(UpperCAmelCase_	)
									model.eval()
									_SCREAMING_SNAKE_CASE       =    model(UpperCAmelCase_	)
									self.parent.assertEqual(result.last_hidden_state.shape ,      (self.batch_size, self.seq_length, self.hidden_size)	)







			def 				UpperCamelCase (      self:    str ,      UpperCAmelCase_:    str ,      UpperCAmelCase_:    Optional[Any] ,      UpperCAmelCase_:    str	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.type_sequence_label_size
									_SCREAMING_SNAKE_CASE       =    EfficientFormerForImageClassification(UpperCAmelCase_	)
									model.to(UpperCAmelCase_	)
									model.eval()
									_SCREAMING_SNAKE_CASE       =    model(UpperCAmelCase_ ,      labels=UpperCAmelCase_	)
									self.parent.assertEqual(result.logits.shape ,      (self.batch_size, self.type_sequence_label_size)	)

									# test greyscale images
									_SCREAMING_SNAKE_CASE       =    1
									_SCREAMING_SNAKE_CASE       =    EfficientFormerForImageClassification(UpperCAmelCase_	)
									model.to(UpperCAmelCase_	)
									model.eval()

									_SCREAMING_SNAKE_CASE       =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
									_SCREAMING_SNAKE_CASE       =    model(UpperCAmelCase_	)
									self.parent.assertEqual(result.logits.shape ,      (self.batch_size, self.type_sequence_label_size)	)







			def 				UpperCamelCase (      self:    Optional[int]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.prepare_config_and_inputs()
									(
									    (
									    _SCREAMING_SNAKE_CASE
									) ,	(
									    _SCREAMING_SNAKE_CASE
									) ,	(
									    _SCREAMING_SNAKE_CASE
									) ,	
									)       =    config_and_inputs
									_SCREAMING_SNAKE_CASE       =    {"""pixel_values""": pixel_values}
									return config, inputs_dict



@require_torch
class  __UpperCAmelCase						(_UpperCAmelCase			,_UpperCAmelCase			,unittest.TestCase       ):
			__snake_case							: List[str]							=				(
			    (
			        EfficientFormerModel,
			        EfficientFormerForImageClassificationWithTeacher,
			        EfficientFormerForImageClassification,
			    )
			    if is_torch_available()
			    else ()
			)
			__snake_case							: Dict							=				(
			    {
			        "feature-extraction": EfficientFormerModel,
			        "image-classification": (
			            EfficientFormerForImageClassification,
			            EfficientFormerForImageClassificationWithTeacher,
			        ),
			    }
			    if is_torch_available()
			    else {}
			)
			__snake_case							: Any							=				False

			__snake_case							: Tuple							=				False
			__snake_case							: Union[str, Any]							=				False
			__snake_case							: Tuple							=				False







			def 				UpperCamelCase (      self:    List[Any]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    EfficientFormerModelTester(self	)
									_SCREAMING_SNAKE_CASE       =    ConfigTester(
									    self ,      config_class=UpperCAmelCase_ ,      has_text_modality=UpperCAmelCase_ ,      hidden_size=37	)







			def 				UpperCamelCase (      self:    List[Any]	):







									'''simple docstring'''




									self.config_tester.run_common_tests()







			@unittest.skip(reason="""EfficientFormer does not use inputs_embeds"""	)
			def 				UpperCamelCase (      self:    Tuple	):







									'''simple docstring'''




									pass







			@unittest.skip(reason="""EfficientFormer does not support input and output embeddings"""	)
			def 				UpperCamelCase (      self:    str	):







									'''simple docstring'''




									pass







			def 				UpperCamelCase (      self:    List[str]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs_for_common()

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

															_SCREAMING_SNAKE_CASE       =    ["""pixel_values"""]
															self.assertListEqual(arg_names[:1] ,      UpperCAmelCase_	)







			def 				UpperCamelCase (      self:    Optional[Any]	):







									'''simple docstring'''




									def check_hidden_states_output(UpperCAmelCase_:    List[str] ,      UpperCAmelCase_:    Any ,      UpperCAmelCase_:    Optional[int]	):
															_SCREAMING_SNAKE_CASE       =    model_class(UpperCAmelCase_	)
															model.to(UpperCAmelCase_	)
															model.eval()

															with torch.no_grad():
																					_SCREAMING_SNAKE_CASE       =    model(**self._prepare_for_class(UpperCAmelCase_ ,      UpperCAmelCase_	)	)

															_SCREAMING_SNAKE_CASE       =    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

															_SCREAMING_SNAKE_CASE       =    getattr(
															    self.model_tester ,      """expected_num_hidden_layers""" ,      self.model_tester.num_hidden_layers + 1	)
															self.assertEqual(len(UpperCAmelCase_	) ,      UpperCAmelCase_	)

															if hasattr(self.model_tester ,      """encoder_seq_length"""	):
																					_SCREAMING_SNAKE_CASE       =    self.model_tester.encoder_seq_length
																					if hasattr(self.model_tester ,      """chunk_length"""	) and self.model_tester.chunk_length > 1:
																											_SCREAMING_SNAKE_CASE       =    seq_length * self.model_tester.chunk_length
															else:
																					_SCREAMING_SNAKE_CASE       =    self.model_tester.seq_length

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

															if config.is_encoder_decoder:
																					_SCREAMING_SNAKE_CASE       =    outputs.decoder_hidden_states

																					self.assertIsInstance(UpperCAmelCase_ ,      (list, tuple)	)
																					self.assertEqual(len(UpperCAmelCase_	) ,      UpperCAmelCase_	)
																					_SCREAMING_SNAKE_CASE       =    getattr(self.model_tester ,      """seq_length""" ,      UpperCAmelCase_	)
																					_SCREAMING_SNAKE_CASE       =    getattr(self.model_tester ,      """decoder_seq_length""" ,      UpperCAmelCase_	)

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

									_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE       =    True
															check_hidden_states_output(UpperCAmelCase_ ,      UpperCAmelCase_ ,      UpperCAmelCase_	)

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

															check_hidden_states_output(UpperCAmelCase_ ,      UpperCAmelCase_ ,      UpperCAmelCase_	)







			def 				UpperCamelCase (      self:    Optional[Any] ,      UpperCAmelCase_:    Any ,      UpperCAmelCase_:    int ,      UpperCAmelCase_:    List[str]=False	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    super()._prepare_for_class(UpperCAmelCase_ ,      UpperCAmelCase_ ,      return_labels=UpperCAmelCase_	)

									if return_labels:
															if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
																					del inputs_dict["labels"]

									return inputs_dict







			def 				UpperCamelCase (      self:    List[Any]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*UpperCAmelCase_	)







			@unittest.skip(reason="""EfficientFormer does not implement masked image modeling yet"""	)
			def 				UpperCamelCase (      self:    int	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*UpperCAmelCase_	)







			def 				UpperCamelCase (      self:    Optional[int]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase_	)







			def 				UpperCamelCase (      self:    Any	):







									'''simple docstring'''




									if not self.model_tester.is_training:
															return

									_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs_for_common()
									_SCREAMING_SNAKE_CASE       =    True

									for model_class in self.all_model_classes:
															# EfficientFormerForImageClassificationWithTeacher supports inference-only
															if (
															    model_class in get_values(UpperCAmelCase_	)
															    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
															):
																					continue
															_SCREAMING_SNAKE_CASE       =    model_class(UpperCAmelCase_	)
															model.to(UpperCAmelCase_	)
															model.train()
															_SCREAMING_SNAKE_CASE       =    self._prepare_for_class(UpperCAmelCase_ ,      UpperCAmelCase_ ,      return_labels=UpperCAmelCase_	)
															_SCREAMING_SNAKE_CASE       =    model(**UpperCAmelCase_	).loss
															loss.backward()







			def 				UpperCamelCase (      self:    int	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs_for_common()

									_SCREAMING_SNAKE_CASE       =    [
									    {"""title""": """multi_label_classification""", """num_labels""": 2, """dtype""": torch.float},
									    {"""title""": """single_label_classification""", """num_labels""": 1, """dtype""": torch.long},
									    {"""title""": """regression""", """num_labels""": 1, """dtype""": torch.float},
									]

									for model_class in self.all_model_classes:
															if (
															    model_class
															    not in [
															        *get_values(UpperCAmelCase_	),
															    ]
															    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
															):
																					continue

															for problem_type in problem_types:
																					with self.subTest(msg=F'Testing {model_class} with {problem_type["title"]}'	):
																											_SCREAMING_SNAKE_CASE       =    problem_type["""title"""]
																											_SCREAMING_SNAKE_CASE       =    problem_type["""num_labels"""]

																											_SCREAMING_SNAKE_CASE       =    model_class(UpperCAmelCase_	)
																											model.to(UpperCAmelCase_	)
																											model.train()

																											_SCREAMING_SNAKE_CASE       =    self._prepare_for_class(UpperCAmelCase_ ,      UpperCAmelCase_ ,      return_labels=UpperCAmelCase_	)

																											if problem_type["num_labels"] > 1:
																																	_SCREAMING_SNAKE_CASE       =    inputs["""labels"""].unsqueeze(1	).repeat(1 ,      problem_type["""num_labels"""]	)

																											_SCREAMING_SNAKE_CASE       =    inputs["""labels"""].to(problem_type["""dtype"""]	)

																											# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																											# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																											# they have the same size." which is a symptom something in wrong for the regression problem.
																											# See https://github.com/huggingface/transformers/issues/11780
																											with warnings.catch_warnings(record=UpperCAmelCase_	) as warning_list:
																																	_SCREAMING_SNAKE_CASE       =    model(**UpperCAmelCase_	).loss
																											for w in warning_list:
																																	if "Using a target size that is different to the input size" in str(w.message	):
																																							raise ValueError(
																																							    F'Something is going wrong in the regression problem: intercepted {w.message}'	)

																											loss.backward()







			@slow
			def 				UpperCamelCase (      self:    Tuple	):







									'''simple docstring'''




									for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_SCREAMING_SNAKE_CASE       =    EfficientFormerModel.from_pretrained(UpperCAmelCase_	)
															self.assertIsNotNone(UpperCAmelCase_	)







			def 				UpperCamelCase (      self:    int	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs_for_common()
									_SCREAMING_SNAKE_CASE       =    True

									_SCREAMING_SNAKE_CASE       =    getattr(self.model_tester ,      """seq_length""" ,      UpperCAmelCase_	)
									_SCREAMING_SNAKE_CASE       =    getattr(self.model_tester ,      """encoder_seq_length""" ,      UpperCAmelCase_	)
									_SCREAMING_SNAKE_CASE       =    getattr(self.model_tester ,      """key_length""" ,      UpperCAmelCase_	)
									_SCREAMING_SNAKE_CASE       =    getattr(self.model_tester ,      """chunk_length""" ,      UpperCAmelCase_	)

									if chunk_length is not None and hasattr(self.model_tester ,      """num_hashes"""	):
															_SCREAMING_SNAKE_CASE       =    encoder_seq_length * self.model_tester.num_hashes

									for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE       =    True
															_SCREAMING_SNAKE_CASE       =    False
															_SCREAMING_SNAKE_CASE       =    True
															_SCREAMING_SNAKE_CASE       =    model_class(UpperCAmelCase_	)
															model.to(UpperCAmelCase_	)
															model.eval()
															with torch.no_grad():
																					_SCREAMING_SNAKE_CASE       =    model(**self._prepare_for_class(UpperCAmelCase_ ,      UpperCAmelCase_	)	)
															_SCREAMING_SNAKE_CASE       =    outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
															self.assertEqual(len(UpperCAmelCase_	) ,      self.model_tester.num_attention_outputs	)

															# check that output_attentions also work using config
															del inputs_dict["output_attentions"]
															_SCREAMING_SNAKE_CASE       =    True
															_SCREAMING_SNAKE_CASE       =    model_class(UpperCAmelCase_	)
															model.to(UpperCAmelCase_	)
															model.eval()
															with torch.no_grad():
																					_SCREAMING_SNAKE_CASE       =    model(**self._prepare_for_class(UpperCAmelCase_ ,      UpperCAmelCase_	)	)
															_SCREAMING_SNAKE_CASE       =    outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
															self.assertEqual(len(UpperCAmelCase_	) ,      self.model_tester.num_attention_outputs	)

															if chunk_length is not None:
																					self.assertListEqual(
																					    list(attentions[0].shape[-4:]	) ,      [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length] ,      )
															else:
																					self.assertListEqual(
																					    list(attentions[0].shape[-3:]	) ,      [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length] ,      )

def 			__lowerCamelCase     (						)				->    Tuple:






						"""simple docstring"""





						_SCREAMING_SNAKE_CASE       =    Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
						return image




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







			@cached_property
			def 				UpperCamelCase (      self:    Union[str, Any]	):







									'''simple docstring'''




									return (
									    EfficientFormerImageProcessor.from_pretrained("""snap-research/efficientformer-l1-300"""	)
									    if is_vision_available()
									    else None
									)







			@slow
			def 				UpperCamelCase (      self:    int	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    EfficientFormerForImageClassification.from_pretrained("""snap-research/efficientformer-l1-300"""	).to(
									    UpperCAmelCase_	)

									_SCREAMING_SNAKE_CASE       =    self.default_image_processor
									_SCREAMING_SNAKE_CASE       =    prepare_img()
									_SCREAMING_SNAKE_CASE       =    image_processor(images=UpperCAmelCase_ ,      return_tensors="""pt"""	).to(UpperCAmelCase_	)

									# forward pass
									with torch.no_grad():
															_SCREAMING_SNAKE_CASE       =    model(**UpperCAmelCase_	)

									# verify the logits
									_SCREAMING_SNAKE_CASE       =    (1, 1_000)
									self.assertEqual(outputs.logits.shape ,      UpperCAmelCase_	)

									_SCREAMING_SNAKE_CASE       =    torch.tensor([-0.05_55, 0.48_25, -0.08_52]	).to(UpperCAmelCase_	)
									self.assertTrue(torch.allclose(outputs.logits[0][:3] ,      UpperCAmelCase_ ,      atol=1E-4	)	)







			@slow
			def 				UpperCamelCase (      self:    Dict	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    EfficientFormerForImageClassificationWithTeacher.from_pretrained(
									    """snap-research/efficientformer-l1-300"""	).to(UpperCAmelCase_	)

									_SCREAMING_SNAKE_CASE       =    self.default_image_processor
									_SCREAMING_SNAKE_CASE       =    prepare_img()
									_SCREAMING_SNAKE_CASE       =    image_processor(images=UpperCAmelCase_ ,      return_tensors="""pt"""	).to(UpperCAmelCase_	)

									# forward pass
									with torch.no_grad():
															_SCREAMING_SNAKE_CASE       =    model(**UpperCAmelCase_	)

									# verify the logits
									_SCREAMING_SNAKE_CASE       =    (1, 1_000)
									self.assertEqual(outputs.logits.shape ,      UpperCAmelCase_	)

									_SCREAMING_SNAKE_CASE       =    torch.tensor([-0.13_12, 0.43_53, -1.04_99]	).to(UpperCAmelCase_	)
									self.assertTrue(torch.allclose(outputs.logits[0][:3] ,      UpperCAmelCase_ ,      atol=1E-4	)	)

