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 		_SCREAMING_SNAKE_CASE    :
  
  
       def __init__(     self       ,				A_       ,				A_ = 13       ,				A_ = 64       ,				A_ = 2       ,				A_ = 3       ,				A_ = 3       ,				A_ = True       ,				A_ = True       ,				A_ = 1_28       ,				A_=[16, 32, 64, 1_28]       ,				A_ = 7       ,				A_ = 4       ,				A_ = 37       ,				A_ = "gelu"       ,				A_ = 0.1       ,				A_ = 0.1       ,				A_ = 10       ,				A_ = 0.0_2       ,				A_ = 2       ,				A_ = 1       ,				A_ = 1_28       ,				A_ = [2, 2, 2, 2]       ,				A_ = 2       ,				A_ = 2       ,				):
         _UpperCAmelCase		:       Any       =    parent
         _UpperCAmelCase		:       Dict       =    batch_size
         _UpperCAmelCase		:       List[Any]       =    image_size
         _UpperCAmelCase		:       Optional[Any]       =    patch_size
         _UpperCAmelCase		:       Dict       =    num_channels
         _UpperCAmelCase		:       Optional[int]       =    is_training
         _UpperCAmelCase		:       Dict       =    use_labels
         _UpperCAmelCase		:       Any       =    hidden_size
         _UpperCAmelCase		:       str       =    num_hidden_layers
         _UpperCAmelCase		:       Union[str, Any]       =    num_attention_heads
         _UpperCAmelCase		:       Optional[int]       =    intermediate_size
         _UpperCAmelCase		:       List[Any]       =    hidden_act
         _UpperCAmelCase		:       Optional[int]       =    hidden_dropout_prob
         _UpperCAmelCase		:       int       =    attention_probs_dropout_prob
         _UpperCAmelCase		:       Dict       =    type_sequence_label_size
         _UpperCAmelCase		:       Union[str, Any]       =    initializer_range
         _UpperCAmelCase		:       Any       =    encoder_stride
         _UpperCAmelCase		:       Tuple       =    num_attention_outputs
         _UpperCAmelCase		:       Optional[int]       =    embed_dim
         _UpperCAmelCase		:       Optional[int]       =    embed_dim + 1
         _UpperCAmelCase		:       List[Any]       =    resolution
         _UpperCAmelCase		:       Union[str, Any]       =    depths
         _UpperCAmelCase		:       Tuple       =    hidden_sizes
         _UpperCAmelCase		:       List[str]       =    dim
         _UpperCAmelCase		:       str       =    mlp_expansion_ratio
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Any       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)
  
         _UpperCAmelCase		:       Dict       =    None
         if self.use_labels:
           _UpperCAmelCase		:       Optional[int]       =    ids_tensor([self.batch_size]       ,				self.type_sequence_label_size						)
  
         _UpperCAmelCase		:       Optional[Any]       =    self.get_config()
         return config, pixel_values, labels
  
  
       def 					__snake_case(     self						):
         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=A_       ,				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 					__snake_case(     self       ,				A_       ,				A_       ,				A_						):
         _UpperCAmelCase		:       List[str]       =    EfficientFormerModel(config=A_						)
         model.to(A_						)
         model.eval()
         _UpperCAmelCase		:       Optional[Any]       =    model(A_						)
         self.parent.assertEqual(result.last_hidden_state.shape       ,				(self.batch_size, self.seq_length, self.hidden_size)						)
  
  
       def 					__snake_case(     self       ,				A_       ,				A_       ,				A_						):
         _UpperCAmelCase		:       Dict       =    self.type_sequence_label_size
         _UpperCAmelCase		:       int       =    EfficientFormerForImageClassification(A_						)
         model.to(A_						)
         model.eval()
         _UpperCAmelCase		:       Tuple       =    model(A_       ,				labels=A_						)
         self.parent.assertEqual(result.logits.shape       ,				(self.batch_size, self.type_sequence_label_size)						)
  
         # test greyscale images
         _UpperCAmelCase		:       List[str]       =    1
         _UpperCAmelCase		:       Optional[Any]       =    EfficientFormerForImageClassification(A_						)
         model.to(A_						)
         model.eval()
  
         _UpperCAmelCase		:       Any       =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
         _UpperCAmelCase		:       str       =    model(A_						)
         self.parent.assertEqual(result.logits.shape       ,				(self.batch_size, self.type_sequence_label_size)						)
  
  
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       List[str]       =    self.prepare_config_and_inputs()
         (
             (
             _UpperCAmelCase
         ),(
             _UpperCAmelCase
         ),(
             _UpperCAmelCase
         ),
         )		:       Union[str, Any]       =    config_and_inputs
         _UpperCAmelCase		:       Optional[int]       =    {"""pixel_values""": pixel_values}
         return config, inputs_dict
  
  
  @require_torch
  class 		_SCREAMING_SNAKE_CASE    (	A       ,  A       ,  unittest.TestCase    ):
       __SCREAMING_SNAKE_CASE    				=						(
           (
               EfficientFormerModel,
               EfficientFormerForImageClassificationWithTeacher,
               EfficientFormerForImageClassification,
           )
           if is_torch_available()
           else ()
       )
       __SCREAMING_SNAKE_CASE    				=						(
           {
               '''feature-extraction''': EfficientFormerModel,
               '''image-classification''': (
                   EfficientFormerForImageClassification,
                   EfficientFormerForImageClassificationWithTeacher,
               ),
           }
           if is_torch_available()
           else {}
       )
       __SCREAMING_SNAKE_CASE    				=						False
  
       __SCREAMING_SNAKE_CASE    				=						False
       __SCREAMING_SNAKE_CASE    				=						False
       __SCREAMING_SNAKE_CASE    				=						False
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Optional[int]       =    EfficientFormerModelTester(self						)
         _UpperCAmelCase		:       Optional[Any]       =    ConfigTester(
             self       ,				config_class=A_       ,				has_text_modality=A_       ,				hidden_size=37						)
  
  
       def 					__snake_case(     self						):
         self.config_tester.run_common_tests()
  
  
       @unittest.skip(reason="""EfficientFormer does not use inputs_embeds"""						)
       def 					__snake_case(     self						):
         pass
  
  
       @unittest.skip(reason="""EfficientFormer does not support input and output embeddings"""						)
       def 					__snake_case(     self						):
         pass
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase,_UpperCAmelCase		:       List[str]       =    self.model_tester.prepare_config_and_inputs_for_common()
  
         for model_class in self.all_model_classes:
           _UpperCAmelCase		:       List[Any]       =    model_class(A_						)
           _UpperCAmelCase		:       int       =    inspect.signature(model.forward						)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           _UpperCAmelCase		:       int       =    [*signature.parameters.keys()]
  
           _UpperCAmelCase		:       Union[str, Any]       =    ["""pixel_values"""]
           self.assertListEqual(arg_names[:1]       ,				A_						)
  
  
       def 					__snake_case(     self						):
         def check_hidden_states_output(A_       ,				A_       ,				A_						):
           _UpperCAmelCase		:       Dict       =    model_class(A_						)
           model.to(A_						)
           model.eval()
  
           with torch.no_grad():
             _UpperCAmelCase		:       Optional[int]       =    model(**self._prepare_for_class(A_       ,				A_						)						)
  
           _UpperCAmelCase		:       Any       =    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
  
           _UpperCAmelCase		:       List[Any]       =    getattr(
               self.model_tester       ,				"""expected_num_hidden_layers"""       ,				self.model_tester.num_hidden_layers + 1						)
           self.assertEqual(len(A_						)       ,				A_						)
  
           if hasattr(self.model_tester       ,				"""encoder_seq_length"""						):
             _UpperCAmelCase		:       Any       =    self.model_tester.encoder_seq_length
             if hasattr(self.model_tester       ,				"""chunk_length"""						) and self.model_tester.chunk_length > 1:
               _UpperCAmelCase		:       List[str]       =    seq_length * self.model_tester.chunk_length
           else:
             _UpperCAmelCase		:       Any       =    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:
             _UpperCAmelCase		:       Optional[Any]       =    outputs.decoder_hidden_states
  
             self.assertIsInstance(A_       ,				(list, tuple)						)
             self.assertEqual(len(A_						)       ,				A_						)
             _UpperCAmelCase		:       int       =    getattr(self.model_tester       ,				"""seq_length"""       ,				A_						)
             _UpperCAmelCase		:       int       =    getattr(self.model_tester       ,				"""decoder_seq_length"""       ,				A_						)
  
             self.assertListEqual(
                 list(hidden_states[-1].shape[-2:]						)       ,				[decoder_seq_length, self.model_tester.hidden_size]       ,				)
  
         _UpperCAmelCase,_UpperCAmelCase		:       Optional[Any]       =    self.model_tester.prepare_config_and_inputs_for_common()
  
         for model_class in self.all_model_classes:
           _UpperCAmelCase		:       Optional[int]       =    True
           check_hidden_states_output(A_       ,				A_       ,				A_						)
  
           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           _UpperCAmelCase		:       str       =    True
  
           check_hidden_states_output(A_       ,				A_       ,				A_						)
  
  
       def 					__snake_case(     self       ,				A_       ,				A_       ,				A_=False						):
         _UpperCAmelCase		:       Union[str, Any]       =    super()._prepare_for_class(A_       ,				A_       ,				return_labels=A_						)
  
         if return_labels:
           if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
             del inputs_dict["labels"]
  
         return inputs_dict
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Any       =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A_						)
  
  
       @unittest.skip(reason="""EfficientFormer does not implement masked image modeling yet"""						)
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       int       =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*A_						)
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       int       =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*A_						)
  
  
       def 					__snake_case(     self						):
         if not self.model_tester.is_training:
           return
  
         _UpperCAmelCase,_UpperCAmelCase		:       Optional[int]       =    self.model_tester.prepare_config_and_inputs_for_common()
         _UpperCAmelCase		:       int       =    True
  
         for model_class in self.all_model_classes:
           # EfficientFormerForImageClassificationWithTeacher supports inference-only
           if (
               model_class in get_values(A_						)
               or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
           ):
             continue
           _UpperCAmelCase		:       str       =    model_class(A_						)
           model.to(A_						)
           model.train()
           _UpperCAmelCase		:       Tuple       =    self._prepare_for_class(A_       ,				A_       ,				return_labels=A_						)
           _UpperCAmelCase		:       str       =    model(**A_						).loss
           loss.backward()
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase,_UpperCAmelCase		:       str       =    self.model_tester.prepare_config_and_inputs_for_common()
  
         _UpperCAmelCase		:       List[Any]       =    [
             {"""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(A_						),
               ]
               or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
           ):
             continue
  
           for problem_type in problem_types:
             with self.subTest(msg=F'''Testing {model_class} with {problem_type["title"]}'''						):
               _UpperCAmelCase		:       List[Any]       =    problem_type["""title"""]
               _UpperCAmelCase		:       Optional[Any]       =    problem_type["""num_labels"""]
  
               _UpperCAmelCase		:       Tuple       =    model_class(A_						)
               model.to(A_						)
               model.train()
  
               _UpperCAmelCase		:       List[Any]       =    self._prepare_for_class(A_       ,				A_       ,				return_labels=A_						)
  
               if problem_type["num_labels"] > 1:
                 _UpperCAmelCase		:       Optional[Any]       =    inputs["""labels"""].unsqueeze(1						).repeat(1       ,				problem_type["""num_labels"""]						)
  
               _UpperCAmelCase		:       int       =    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=A_						) as warning_list:
                 _UpperCAmelCase		:       str       =    model(**A_						).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 					__snake_case(     self						):
         for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _UpperCAmelCase		:       str       =    EfficientFormerModel.from_pretrained(A_						)
           self.assertIsNotNone(A_						)
  
  
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase,_UpperCAmelCase		:       List[str]       =    self.model_tester.prepare_config_and_inputs_for_common()
         _UpperCAmelCase		:       List[Any]       =    True
  
         _UpperCAmelCase		:       Optional[Any]       =    getattr(self.model_tester       ,				"""seq_length"""       ,				A_						)
         _UpperCAmelCase		:       Dict       =    getattr(self.model_tester       ,				"""encoder_seq_length"""       ,				A_						)
         _UpperCAmelCase		:       Any       =    getattr(self.model_tester       ,				"""key_length"""       ,				A_						)
         _UpperCAmelCase		:       Any       =    getattr(self.model_tester       ,				"""chunk_length"""       ,				A_						)
  
         if chunk_length is not None and hasattr(self.model_tester       ,				"""num_hashes"""						):
           _UpperCAmelCase		:       Optional[Any]       =    encoder_seq_length * self.model_tester.num_hashes
  
         for model_class in self.all_model_classes:
           _UpperCAmelCase		:       Dict       =    True
           _UpperCAmelCase		:       List[str]       =    False
           _UpperCAmelCase		:       Dict       =    True
           _UpperCAmelCase		:       Any       =    model_class(A_						)
           model.to(A_						)
           model.eval()
           with torch.no_grad():
             _UpperCAmelCase		:       Dict       =    model(**self._prepare_for_class(A_       ,				A_						)						)
           _UpperCAmelCase		:       List[Any]       =    outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
           self.assertEqual(len(A_						)       ,				self.model_tester.num_attention_outputs						)
  
           # check that output_attentions also work using config
           del inputs_dict["output_attentions"]
           _UpperCAmelCase		:       int       =    True
           _UpperCAmelCase		:       Optional[int]       =    model_class(A_						)
           model.to(A_						)
           model.eval()
           with torch.no_grad():
             _UpperCAmelCase		:       List[Any]       =    model(**self._prepare_for_class(A_       ,				A_						)						)
           _UpperCAmelCase		:       List[Any]       =    outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
           self.assertEqual(len(A_						)       ,				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       a__						(		):
    _UpperCAmelCase		:       Any       =    Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
    return image
  
  
  
  
  
  @require_torch
  @require_vision
  class 		_SCREAMING_SNAKE_CASE    (	unittest.TestCase    ):
  
  
       @cached_property
       def 					__snake_case(     self						):
         return (
             EfficientFormerImageProcessor.from_pretrained("""snap-research/efficientformer-l1-300"""						)
             if is_vision_available()
             else None
         )
  
  
       @slow
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       List[str]       =    EfficientFormerForImageClassification.from_pretrained("""snap-research/efficientformer-l1-300"""						).to(
             A_						)
  
         _UpperCAmelCase		:       int       =    self.default_image_processor
         _UpperCAmelCase		:       Any       =    prepare_img()
         _UpperCAmelCase		:       List[Any]       =    image_processor(images=A_       ,				return_tensors="""pt"""						).to(A_						)
  
         # forward pass
         with torch.no_grad():
           _UpperCAmelCase		:       int       =    model(**A_						)
  
         # verify the logits
         _UpperCAmelCase		:       Tuple       =    (1, 10_00)
         self.assertEqual(outputs.logits.shape       ,				A_						)
  
         _UpperCAmelCase		:       str       =    torch.tensor([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]						).to(A_						)
         self.assertTrue(torch.allclose(outputs.logits[0][:3]       ,				A_       ,				atol=1e-4						)						)
  
  
  
  
       @slow
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Union[str, Any]       =    EfficientFormerForImageClassificationWithTeacher.from_pretrained(
             """snap-research/efficientformer-l1-300"""						).to(A_						)
  
         _UpperCAmelCase		:       List[str]       =    self.default_image_processor
         _UpperCAmelCase		:       int       =    prepare_img()
         _UpperCAmelCase		:       Any       =    image_processor(images=A_       ,				return_tensors="""pt"""						).to(A_						)
  
         # forward pass
         with torch.no_grad():
           _UpperCAmelCase		:       Any       =    model(**A_						)
  
         # verify the logits
         _UpperCAmelCase		:       str       =    (1, 10_00)
         self.assertEqual(outputs.logits.shape       ,				A_						)
  
         _UpperCAmelCase		:       Optional[int]       =    torch.tensor([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9]						).to(A_						)
         self.assertTrue(torch.allclose(outputs.logits[0][:3]       ,				A_       ,				atol=1e-4						)						)
  
  
  
  
  
  
style_context: 
  
  
  import os
  
  import requests
  from bsa import BeautifulSoup
  from fake_useragent import UserAgent
  
  SCREAMING_SNAKE_CASE__				:    int         =    {'UserAgent': UserAgent().random}
  SCREAMING_SNAKE_CASE__				:    Tuple         =    'https://www.mywaifulist.moe/random'
  
  
  
  
  def       a__						(		snake_case__				:       str	,      snake_case__				:       str    ):
    _UpperCAmelCase		:       Any       =    requests.get(snake_case__	,      headers=snake_case__    )
    with open(snake_case__	,      """wb"""    ) as file:
      file.write(image.content    )
  
  
  
  
  def       a__						(		):
    _UpperCAmelCase		:       List[Any]       =    BeautifulSoup(requests.get(snake_case__	,      headers=snake_case__    ).text	,      """html.parser"""    )
    _UpperCAmelCase		:       Optional[int]       =    soup.find("""meta"""	,      attrs={"""property""": """og:title"""}    ).attrs["""content"""]
    _UpperCAmelCase		:       int       =    soup.find("""meta"""	,      attrs={"""property""": """og:image"""}    ).attrs["""content"""]
    _UpperCAmelCase		:       Any       =    soup.find("""p"""	,      id="""description"""    ).get_text()
    _UpperCAmelCase,_UpperCAmelCase		:       Dict       =    os.path.splitext(os.path.basename(snake_case__    )    )
    _UpperCAmelCase		:       Tuple       =    title.strip().replace(""" """	,      """_"""    )
    _UpperCAmelCase		:       Optional[Any]       =    f'''{image_title}{image_extension}'''
    save_image(snake_case__	,      snake_case__    )
    return (title, description, image_title)
  
  
  if __name__ == "__main__":
   SCREAMING_SNAKE_CASE__     ,				SCREAMING_SNAKE_CASE__     ,				SCREAMING_SNAKE_CASE__				:    Optional[int]         =    random_anime_character()
   print(F'{title}\n\n{desc}\n\nImage saved : {image_title}')
  
  
  
  
  
  