code: 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 _lowercase					:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							def __init__(    self     ,   UpperCAmelCase     ,   UpperCAmelCase = 13     ,   UpperCAmelCase = 64     ,   UpperCAmelCase = 2     ,   UpperCAmelCase = 3     ,   UpperCAmelCase = 3     ,   UpperCAmelCase = True     ,   UpperCAmelCase = True     ,   UpperCAmelCase = 128     ,   UpperCAmelCase=[16, 32, 64, 128]     ,   UpperCAmelCase = 7     ,   UpperCAmelCase = 4     ,   UpperCAmelCase = 37     ,   UpperCAmelCase = "gelu"     ,   UpperCAmelCase = 0.1     ,   UpperCAmelCase = 0.1     ,   UpperCAmelCase = 10     ,   UpperCAmelCase = 0.02     ,   UpperCAmelCase = 2     ,   UpperCAmelCase = 1     ,   UpperCAmelCase = 128     ,   UpperCAmelCase = [2, 2, 2, 2]     ,   UpperCAmelCase = 2     ,   UpperCAmelCase = 2     ,   ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	parent
  														_lowercase				=	batch_size
  														_lowercase				=	image_size
  														_lowercase				=	patch_size
  														_lowercase				=	num_channels
  														_lowercase				=	is_training
  														_lowercase				=	use_labels
  														_lowercase				=	hidden_size
  														_lowercase				=	num_hidden_layers
  														_lowercase				=	num_attention_heads
  														_lowercase				=	intermediate_size
  														_lowercase				=	hidden_act
  														_lowercase				=	hidden_dropout_prob
  														_lowercase				=	attention_probs_dropout_prob
  														_lowercase				=	type_sequence_label_size
  														_lowercase				=	initializer_range
  														_lowercase				=	encoder_stride
  														_lowercase				=	num_attention_outputs
  														_lowercase				=	embed_dim
  														_lowercase				=	embed_dim + 1
  														_lowercase				=	resolution
  														_lowercase				=	depths
  														_lowercase				=	hidden_sizes
  														_lowercase				=	dim
  														_lowercase				=	mlp_expansion_ratio
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )
  
  														_lowercase				=	None
  														if self.use_labels:
  																					_lowercase				=	ids_tensor([self.batch_size]     ,   self.type_sequence_label_size  )
  
  														_lowercase				=	self.get_config()
  														return config, pixel_values, labels
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''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     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	EfficientFormerModel(config=UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  														model.eval()
  														_lowercase				=	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'''
  
  
  
  
  
  
  														_lowercase				=	self.type_sequence_label_size
  														_lowercase				=	EfficientFormerForImageClassification(UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  														model.eval()
  														_lowercase				=	model(UpperCAmelCase     ,   labels=UpperCAmelCase  )
  														self.parent.assertEqual(result.logits.shape     ,   (self.batch_size, self.type_sequence_label_size)  )
  
  														# test greyscale images
  														_lowercase				=	1
  														_lowercase				=	EfficientFormerForImageClassification(UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  														model.eval()
  
  														_lowercase				=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
  														_lowercase				=	model(UpperCAmelCase  )
  														self.parent.assertEqual(result.logits.shape     ,   (self.batch_size, self.type_sequence_label_size)  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.prepare_config_and_inputs()
  														(
  														    (
  														    _lowercase
  														)				,       (
  														    _lowercase
  														)				,       (
  														    _lowercase
  														)				,       
  														)				=	config_and_inputs
  														_lowercase				=	{"""pixel_values""": pixel_values}
  														return config, inputs_dict
  
  
  
  
  
  
  @require_torch
  class _lowercase					(       _UpperCAmelCase   ,				_UpperCAmelCase   ,				unittest.TestCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							lowerCAmelCase__       =					(
  							    (
  							        EfficientFormerModel,
  							        EfficientFormerForImageClassificationWithTeacher,
  							        EfficientFormerForImageClassification,
  							    )
  							    if is_torch_available()
  							    else ()
  							)
  							lowerCAmelCase__       =					(
  							    {
  							        'feature-extraction': EfficientFormerModel,
  							        'image-classification': (
  							            EfficientFormerForImageClassification,
  							            EfficientFormerForImageClassificationWithTeacher,
  							        ),
  							    }
  							    if is_torch_available()
  							    else {}
  							)
  							lowerCAmelCase__       =					False
  
  							lowerCAmelCase__       =					False
  							lowerCAmelCase__       =					False
  							lowerCAmelCase__       =					False
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	EfficientFormerModelTester(self  )
  														_lowercase				=	ConfigTester(
  														    self     ,   config_class=UpperCAmelCase     ,   has_text_modality=UpperCAmelCase     ,   hidden_size=37  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														self.config_tester.run_common_tests()
  
  
  
  							@unittest.skip(reason="""EfficientFormer does not use inputs_embeds"""  )
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														pass
  
  
  
  							@unittest.skip(reason="""EfficientFormer does not support input and output embeddings"""  )
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														pass
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.model_tester.prepare_config_and_inputs_for_common()
  
  														for model_class in self.all_model_classes:
  																					_lowercase				=	model_class(UpperCAmelCase  )
  																					_lowercase				=	inspect.signature(model.forward  )
  																					# signature.parameters is an OrderedDict => so arg_names order is deterministic
  																					_lowercase				=	[*signature.parameters.keys()]
  
  																					_lowercase				=	["""pixel_values"""]
  																					self.assertListEqual(arg_names[:1]     ,   UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														def check_hidden_states_output(UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase  ):
  																					_lowercase				=	model_class(UpperCAmelCase  )
  																					model.to(UpperCAmelCase  )
  																					model.eval()
  
  																					with torch.no_grad():
  																												_lowercase				=	model(**self._prepare_for_class(UpperCAmelCase     ,   UpperCAmelCase  )  )
  
  																					_lowercase				=	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
  
  																					_lowercase				=	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"""  ):
  																												_lowercase				=	self.model_tester.encoder_seq_length
  																												if hasattr(self.model_tester     ,   """chunk_length"""  ) and self.model_tester.chunk_length > 1:
  																																			_lowercase				=	seq_length * self.model_tester.chunk_length
  																					else:
  																												_lowercase				=	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:
  																												_lowercase				=	outputs.decoder_hidden_states
  
  																												self.assertIsInstance(UpperCAmelCase     ,   (list, tuple)  )
  																												self.assertEqual(len(UpperCAmelCase  )     ,   UpperCAmelCase  )
  																												_lowercase				=	getattr(self.model_tester     ,   """seq_length"""     ,   UpperCAmelCase  )
  																												_lowercase				=	getattr(self.model_tester     ,   """decoder_seq_length"""     ,   UpperCAmelCase  )
  
  																												self.assertListEqual(
  																												    list(hidden_states[-1].shape[-2:]  )     ,   [decoder_seq_length, self.model_tester.hidden_size]     ,   )
  
  														_lowercase				,       _lowercase				=	self.model_tester.prepare_config_and_inputs_for_common()
  
  														for model_class in self.all_model_classes:
  																					_lowercase				=	True
  																					check_hidden_states_output(UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase  )
  
  																					# check that output_hidden_states also work using config
  																					del inputs_dict["output_hidden_states"]
  																					_lowercase				=	True
  
  																					check_hidden_states_output(UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase=False  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	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  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	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  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.model_tester.prepare_config_and_inputs()
  														self.model_tester.create_and_check_for_masked_image_modeling(*UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.model_tester.prepare_config_and_inputs()
  														self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														if not self.model_tester.is_training:
  																					return
  
  														_lowercase				,       _lowercase				=	self.model_tester.prepare_config_and_inputs_for_common()
  														_lowercase				=	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
  																					_lowercase				=	model_class(UpperCAmelCase  )
  																					model.to(UpperCAmelCase  )
  																					model.train()
  																					_lowercase				=	self._prepare_for_class(UpperCAmelCase     ,   UpperCAmelCase     ,   return_labels=UpperCAmelCase  )
  																					_lowercase				=	model(**UpperCAmelCase  ).loss
  																					loss.backward()
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.model_tester.prepare_config_and_inputs_for_common()
  
  														_lowercase				=	[
  														    {"""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"]}'''  ):
  																																			_lowercase				=	problem_type["""title"""]
  																																			_lowercase				=	problem_type["""num_labels"""]
  
  																																			_lowercase				=	model_class(UpperCAmelCase  )
  																																			model.to(UpperCAmelCase  )
  																																			model.train()
  
  																																			_lowercase				=	self._prepare_for_class(UpperCAmelCase     ,   UpperCAmelCase     ,   return_labels=UpperCAmelCase  )
  
  																																			if problem_type["num_labels"] > 1:
  																																										_lowercase				=	inputs["""labels"""].unsqueeze(1  ).repeat(1     ,   problem_type["""num_labels"""]  )
  
  																																			_lowercase				=	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:
  																																										_lowercase				=	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  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  																					_lowercase				=	EfficientFormerModel.from_pretrained(UpperCAmelCase  )
  																					self.assertIsNotNone(UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				,       _lowercase				=	self.model_tester.prepare_config_and_inputs_for_common()
  														_lowercase				=	True
  
  														_lowercase				=	getattr(self.model_tester     ,   """seq_length"""     ,   UpperCAmelCase  )
  														_lowercase				=	getattr(self.model_tester     ,   """encoder_seq_length"""     ,   UpperCAmelCase  )
  														_lowercase				=	getattr(self.model_tester     ,   """key_length"""     ,   UpperCAmelCase  )
  														_lowercase				=	getattr(self.model_tester     ,   """chunk_length"""     ,   UpperCAmelCase  )
  
  														if chunk_length is not None and hasattr(self.model_tester     ,   """num_hashes"""  ):
  																					_lowercase				=	encoder_seq_length * self.model_tester.num_hashes
  
  														for model_class in self.all_model_classes:
  																					_lowercase				=	True
  																					_lowercase				=	False
  																					_lowercase				=	True
  																					_lowercase				=	model_class(UpperCAmelCase  )
  																					model.to(UpperCAmelCase  )
  																					model.eval()
  																					with torch.no_grad():
  																												_lowercase				=	model(**self._prepare_for_class(UpperCAmelCase     ,   UpperCAmelCase  )  )
  																					_lowercase				=	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"]
  																					_lowercase				=	True
  																					_lowercase				=	model_class(UpperCAmelCase  )
  																					model.to(UpperCAmelCase  )
  																					model.eval()
  																					with torch.no_grad():
  																												_lowercase				=	model(**self._prepare_for_class(UpperCAmelCase     ,   UpperCAmelCase  )  )
  																					_lowercase				=	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			(  ):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
  							return image
  
  
  
  
  
  
  
  @require_torch
  @require_vision
  class _lowercase					(       unittest.TestCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							@cached_property
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														return (
  														    EfficientFormerImageProcessor.from_pretrained("""snap-research/efficientformer-l1-300"""  )
  														    if is_vision_available()
  														    else None
  														)
  
  
  
  							@slow
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	EfficientFormerForImageClassification.from_pretrained("""snap-research/efficientformer-l1-300"""  ).to(
  														    UpperCAmelCase  )
  
  														_lowercase				=	self.default_image_processor
  														_lowercase				=	prepare_img()
  														_lowercase				=	image_processor(images=UpperCAmelCase     ,   return_tensors="""pt"""  ).to(UpperCAmelCase  )
  
  														# forward pass
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  )
  
  														# verify the logits
  														_lowercase				=	(1, 1000)
  														self.assertEqual(outputs.logits.shape     ,   UpperCAmelCase  )
  
  														_lowercase				=	torch.tensor([-0.0_555, 0.4_825, -0.0_852]  ).to(UpperCAmelCase  )
  														self.assertTrue(torch.allclose(outputs.logits[0][:3]     ,   UpperCAmelCase     ,   atol=1e-4  )  )
  
  
  
  							@slow
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	EfficientFormerForImageClassificationWithTeacher.from_pretrained(
  														    """snap-research/efficientformer-l1-300"""  ).to(UpperCAmelCase  )
  
  														_lowercase				=	self.default_image_processor
  														_lowercase				=	prepare_img()
  														_lowercase				=	image_processor(images=UpperCAmelCase     ,   return_tensors="""pt"""  ).to(UpperCAmelCase  )
  
  														# forward pass
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  )
  
  														# verify the logits
  														_lowercase				=	(1, 1000)
  														self.assertEqual(outputs.logits.shape     ,   UpperCAmelCase  )
  
  														_lowercase				=	torch.tensor([-0.1_312, 0.4_353, -1.0_499]  ).to(UpperCAmelCase  )
  														self.assertTrue(torch.allclose(outputs.logits[0][:3]     ,   UpperCAmelCase     ,   atol=1e-4  )  )
  
  
  
style_context: import shutil
  import tempfile
  import unittest
  
  import numpy as np
  import pytest
  
  from transformers.testing_utils import require_vision
  from transformers.utils import is_vision_available
  
  
  if is_vision_available():
  				from PIL import Image
  
  				from transformers import AutoProcessor, BertTokenizer, CLIPImageProcessor, GitProcessor, PreTrainedTokenizerFast
  
  
  @require_vision
  class _lowercase					(       unittest.TestCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	tempfile.mkdtemp()
  
  														_lowercase				=	CLIPImageProcessor()
  														_lowercase				=	BertTokenizer.from_pretrained(
  														    """hf-internal-testing/tiny-random-BertModel"""     ,   model_input_names=["""input_ids""", """attention_mask"""]  )
  
  														_lowercase				=	GitProcessor(UpperCAmelCase     ,   UpperCAmelCase  )
  
  														processor.save_pretrained(self.tmpdirname  )
  
  
  
  							def     _UpperCAmelCase       (    self     ,   **UpperCAmelCase  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														return AutoProcessor.from_pretrained(self.tmpdirname     ,   **UpperCAmelCase  ).tokenizer
  
  
  
  							def     _UpperCAmelCase       (    self     ,   **UpperCAmelCase  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														return AutoProcessor.from_pretrained(self.tmpdirname     ,   **UpperCAmelCase  ).image_processor
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														shutil.rmtree(self.tmpdirname  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	[np.random.randint(255     ,   size=(3, 30, 400)     ,   dtype=np.uinta  )]
  
  														_lowercase				=	[Image.fromarray(np.moveaxis(UpperCAmelCase     ,   0     ,   -1  )  ) for x in image_inputs]
  
  														return image_inputs
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	GitProcessor(tokenizer=self.get_tokenizer()     ,   image_processor=self.get_image_processor()  )
  														processor.save_pretrained(self.tmpdirname  )
  
  														_lowercase				=	self.get_tokenizer(bos_token="""(BOS)"""     ,   eos_token="""(EOS)"""  )
  														_lowercase				=	self.get_image_processor(do_normalize=UpperCAmelCase     ,   padding_value=1.0  )
  
  														_lowercase				=	GitProcessor.from_pretrained(
  														    self.tmpdirname     ,   bos_token="""(BOS)"""     ,   eos_token="""(EOS)"""     ,   do_normalize=UpperCAmelCase     ,   padding_value=1.0  )
  
  														self.assertEqual(processor.tokenizer.get_vocab()     ,   tokenizer_add_kwargs.get_vocab()  )
  														self.assertIsInstance(processor.tokenizer     ,   UpperCAmelCase  )
  
  														self.assertEqual(processor.image_processor.to_json_string()     ,   image_processor_add_kwargs.to_json_string()  )
  														self.assertIsInstance(processor.image_processor     ,   UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.get_image_processor()
  														_lowercase				=	self.get_tokenizer()
  
  														_lowercase				=	GitProcessor(tokenizer=UpperCAmelCase     ,   image_processor=UpperCAmelCase  )
  
  														_lowercase				=	self.prepare_image_inputs()
  
  														_lowercase				=	image_processor(UpperCAmelCase     ,   return_tensors="""np"""  )
  														_lowercase				=	processor(images=UpperCAmelCase     ,   return_tensors="""np"""  )
  
  														for key in input_feat_extract.keys():
  																					self.assertAlmostEqual(input_feat_extract[key].sum()     ,   input_processor[key].sum()     ,   delta=1e-2  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.get_image_processor()
  														_lowercase				=	self.get_tokenizer()
  
  														_lowercase				=	GitProcessor(tokenizer=UpperCAmelCase     ,   image_processor=UpperCAmelCase  )
  
  														_lowercase				=	"""lower newer"""
  
  														_lowercase				=	processor(text=UpperCAmelCase  )
  
  														_lowercase				=	tokenizer(UpperCAmelCase     ,   return_token_type_ids=UpperCAmelCase  )
  
  														for key in encoded_tok.keys():
  																					self.assertListEqual(encoded_tok[key]     ,   encoded_processor[key]  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.get_image_processor()
  														_lowercase				=	self.get_tokenizer()
  
  														_lowercase				=	GitProcessor(tokenizer=UpperCAmelCase     ,   image_processor=UpperCAmelCase  )
  
  														_lowercase				=	"""lower newer"""
  														_lowercase				=	self.prepare_image_inputs()
  
  														_lowercase				=	processor(text=UpperCAmelCase     ,   images=UpperCAmelCase  )
  
  														self.assertListEqual(list(inputs.keys()  )     ,   ["""input_ids""", """attention_mask""", """pixel_values"""]  )
  
  														# test if it raises when no input is passed
  														with pytest.raises(UpperCAmelCase  ):
  																					processor()
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.get_image_processor()
  														_lowercase				=	self.get_tokenizer()
  
  														_lowercase				=	GitProcessor(tokenizer=UpperCAmelCase     ,   image_processor=UpperCAmelCase  )
  
  														_lowercase				=	[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
  														_lowercase				=	processor.batch_decode(UpperCAmelCase  )
  														_lowercase				=	tokenizer.batch_decode(UpperCAmelCase  )
  
  														self.assertListEqual(UpperCAmelCase     ,   UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.get_image_processor()
  														_lowercase				=	self.get_tokenizer()
  
  														_lowercase				=	GitProcessor(tokenizer=UpperCAmelCase     ,   image_processor=UpperCAmelCase  )
  
  														_lowercase				=	"""lower newer"""
  														_lowercase				=	self.prepare_image_inputs()
  
  														_lowercase				=	processor(text=UpperCAmelCase     ,   images=UpperCAmelCase  )
  
  														# For now the processor supports only ['input_ids', 'attention_mask', 'pixel_values']
  														self.assertListEqual(list(inputs.keys()  )     ,   ["""input_ids""", """attention_mask""", """pixel_values"""]  )
  
  
  