





"""simple docstring"""


import argparse
import logging
import os
from pathlib import Path
from typing import Any, Dict

import pytorch_lightning as pl
from pytorch_lightning.utilities import rank_zero_info

from transformers import (
    AdamW,
    AutoConfig,
    AutoModel,
    AutoModelForPreTraining,
    AutoModelForQuestionAnswering,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelWithLMHead,
    AutoTokenizer,
    PretrainedConfig,
    PreTrainedTokenizer,
)
from transformers.optimization import (
    Adafactor,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.utils.versions import require_version


a__   :       Tuple   						=			logging.getLogger(__name__)

require_version("""pytorch_lightning>=1.0.4""")

a__   :       int   						=			{
    """base""": AutoModel,
    """sequence-classification""": AutoModelForSequenceClassification,
    """question-answering""": AutoModelForQuestionAnswering,
    """pretraining""": AutoModelForPreTraining,
    """token-classification""": AutoModelForTokenClassification,
    """language-modeling""": AutoModelWithLMHead,
    """summarization""": AutoModelForSeqaSeqLM,
    """translation""": AutoModelForSeqaSeqLM,
}


# update this and the import above to support new schedulers from transformers.optimization
a__   :       List[Any]   						=			{
    """linear""": get_linear_schedule_with_warmup,
    """cosine""": get_cosine_schedule_with_warmup,
    """cosine_w_restarts""": get_cosine_with_hard_restarts_schedule_with_warmup,
    """polynomial""": get_polynomial_decay_schedule_with_warmup,
    # '': get_constant_schedule,             # not supported for now
    # '': get_constant_schedule_with_warmup, # not supported for now
}
a__   :       Tuple   						=			sorted(arg_to_scheduler.keys())
a__   :       Optional[Any]   						=			"""{""" + """, """.join(arg_to_scheduler_choices) + """}"""



class        lowercase_			(       pl.LightningModule							):

       def __init__(     self				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE=None				,   __SCREAMING_SNAKE_CASE="base"				,   __SCREAMING_SNAKE_CASE=None				,   __SCREAMING_SNAKE_CASE=None				,   __SCREAMING_SNAKE_CASE=None				,   **__SCREAMING_SNAKE_CASE				,   ):






        '''simple docstring'''

        super().__init__()
        # TODO: move to self.save_hyperparameters()
        # self.save_hyperparameters()
        # can also expand arguments into trainer signature for easier reading

        self.save_hyperparameters(__SCREAMING_SNAKE_CASE       )
        snake_case__      							=			0
        snake_case__      							=			Path(self.hparams.output_dir       )
        snake_case__      							=			self.hparams.cache_dir if self.hparams.cache_dir else None
        if config is None:
         snake_case__      							=			AutoConfig.from_pretrained(
             self.hparams.config_name if self.hparams.config_name else self.hparams.model_name_or_path				,   **({"num_labels": num_labels} if num_labels is not None else {})				,   cache_dir=__SCREAMING_SNAKE_CASE				,   **__SCREAMING_SNAKE_CASE				,   )
        else:
         snake_case__      							=			config

        snake_case__      							=			("encoder_layerdrop", "decoder_layerdrop", "dropout", "attention_dropout")
        for p in extra_model_params:
         if getattr(self.hparams				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       ):
          assert hasattr(self.config				,   __SCREAMING_SNAKE_CASE       ), F"model config doesn't have a `{p}` attribute"
          setattr(self.config				,   __SCREAMING_SNAKE_CASE				,   getattr(self.hparams				,   __SCREAMING_SNAKE_CASE       )       )

        if tokenizer is None:
         snake_case__      							=			AutoTokenizer.from_pretrained(
             self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path				,   cache_dir=__SCREAMING_SNAKE_CASE				,   )
        else:
         snake_case__      							=			tokenizer
        snake_case__      							=			MODEL_MODES[mode]
        if model is None:
         snake_case__      							=			self.model_type.from_pretrained(
             self.hparams.model_name_or_path				,   from_tf=bool(".ckpt" in self.hparams.model_name_or_path       )				,   config=self.config				,   cache_dir=__SCREAMING_SNAKE_CASE				,   )
        else:
         snake_case__      							=			model

       def 						_SCREAMING_SNAKE_CASE(     self				,   *__SCREAMING_SNAKE_CASE				,   **__SCREAMING_SNAKE_CASE       ):






        '''simple docstring'''

        snake_case__      							=			self.model_type.from_pretrained(*__SCREAMING_SNAKE_CASE				,   **__SCREAMING_SNAKE_CASE       )

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        snake_case__      							=			arg_to_scheduler[self.hparams.lr_scheduler]
        snake_case__      							=			get_schedule_func(
            self.opt				,   num_warmup_steps=self.hparams.warmup_steps				,   num_training_steps=self.total_steps()       )
        snake_case__      							=			{"scheduler": scheduler, "interval": "step", "frequency": 1}
        return scheduler

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        snake_case__      							=			self.model
        snake_case__      							=			["bias", "LayerNorm.weight"]
        snake_case__      							=			[
            {
                "params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay       )],
                "weight_decay": self.hparams.weight_decay,
            },
            {
                "params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay       )],
                "weight_decay": 0.0,
            },
        ]
        if self.hparams.adafactor:
         snake_case__      							=			Adafactor(
             __SCREAMING_SNAKE_CASE				,   lr=self.hparams.learning_rate				,   scale_parameter=__SCREAMING_SNAKE_CASE				,   relative_step=__SCREAMING_SNAKE_CASE       )

        else:
         snake_case__      							=			AdamW(
             __SCREAMING_SNAKE_CASE				,   lr=self.hparams.learning_rate				,   eps=self.hparams.adam_epsilon       )
        snake_case__      							=			optimizer

        snake_case__      							=			self.get_lr_scheduler()

        return [optimizer], [scheduler]

       def 						_SCREAMING_SNAKE_CASE(     self				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       ):






        '''simple docstring'''

        return self.validation_step(__SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       )

       def 						_SCREAMING_SNAKE_CASE(     self				,   __SCREAMING_SNAKE_CASE       ):






        '''simple docstring'''

        return self.validation_end(__SCREAMING_SNAKE_CASE       )

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        snake_case__      							=			max(1				,   self.hparams.gpus       )  # TODO: consider num_tpu_cores
        snake_case__      							=			self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
        return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs

       def 						_SCREAMING_SNAKE_CASE(     self				,   __SCREAMING_SNAKE_CASE       ):






        '''simple docstring'''

        if mode == "test":
         snake_case__      							=			len(self.test_dataloader().dataset       )
        else:
         snake_case__      							=			self.get_dataloader("train"				,   self.hparams.train_batch_size				,   shuffle=__SCREAMING_SNAKE_CASE       )
         snake_case__      							=			len(self.train_dataloader().dataset       )

       def 						_SCREAMING_SNAKE_CASE(     self				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE = False       ):






        '''simple docstring'''

        raise NotImplementedError("You must implement this for your task"       )

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        return self.train_loader

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        return self.get_dataloader("dev"				,   self.hparams.eval_batch_size				,   shuffle=__SCREAMING_SNAKE_CASE       )

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        return self.get_dataloader("test"				,   self.hparams.eval_batch_size				,   shuffle=__SCREAMING_SNAKE_CASE       )

       def 						_SCREAMING_SNAKE_CASE(     self				,   __SCREAMING_SNAKE_CASE       ):






        '''simple docstring'''

        return os.path.join(
            self.hparams.data_dir				,   "cached_{}_{}_{}".format(
                __SCREAMING_SNAKE_CASE				,   list(filter(__SCREAMING_SNAKE_CASE				,   self.hparams.model_name_or_path.split("/"       )       )       ).pop()				,   str(self.hparams.max_seq_length       )				,   )				,   )

       @pl.utilities.rank_zero_only
       def 						_SCREAMING_SNAKE_CASE(     self				,   __SCREAMING_SNAKE_CASE       ):






        '''simple docstring'''

        snake_case__      							=			self.output_dir.joinpath("best_tfmr"       )
        snake_case__      							=			self.step_count
        self.model.save_pretrained(__SCREAMING_SNAKE_CASE       )
        self.tokenizer.save_pretrained(__SCREAMING_SNAKE_CASE       )

       @staticmethod
       def 						_SCREAMING_SNAKE_CASE(     __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       ):






        '''simple docstring'''

        parser.add_argument(
            "--model_name_or_path"				,   default=__SCREAMING_SNAKE_CASE				,   type=__SCREAMING_SNAKE_CASE				,   required=__SCREAMING_SNAKE_CASE				,   help="Path to pretrained model or model identifier from huggingface.co/models"				,   )
        parser.add_argument(
            "--config_name"				,   default=""				,   type=__SCREAMING_SNAKE_CASE				,   help="Pretrained config name or path if not the same as model_name"       )
        parser.add_argument(
            "--tokenizer_name"				,   default=__SCREAMING_SNAKE_CASE				,   type=__SCREAMING_SNAKE_CASE				,   help="Pretrained tokenizer name or path if not the same as model_name"				,   )
        parser.add_argument(
            "--cache_dir"				,   default=""				,   type=__SCREAMING_SNAKE_CASE				,   help="Where do you want to store the pre-trained models downloaded from huggingface.co"				,   )
        parser.add_argument(
            "--encoder_layerdrop"				,   type=__SCREAMING_SNAKE_CASE				,   help="Encoder layer dropout probability (Optional). Goes into model.config"				,   )
        parser.add_argument(
            "--decoder_layerdrop"				,   type=__SCREAMING_SNAKE_CASE				,   help="Decoder layer dropout probability (Optional). Goes into model.config"				,   )
        parser.add_argument(
            "--dropout"				,   type=__SCREAMING_SNAKE_CASE				,   help="Dropout probability (Optional). Goes into model.config"				,   )
        parser.add_argument(
            "--attention_dropout"				,   type=__SCREAMING_SNAKE_CASE				,   help="Attention dropout probability (Optional). Goes into model.config"				,   )
        parser.add_argument("--learning_rate"				,   default=5e-5				,   type=__SCREAMING_SNAKE_CASE				,   help="The initial learning rate for Adam."       )
        parser.add_argument(
            "--lr_scheduler"				,   default="linear"				,   choices=__SCREAMING_SNAKE_CASE				,   metavar=__SCREAMING_SNAKE_CASE				,   type=__SCREAMING_SNAKE_CASE				,   help="Learning rate scheduler"				,   )
        parser.add_argument("--weight_decay"				,   default=0.0				,   type=__SCREAMING_SNAKE_CASE				,   help="Weight decay if we apply some."       )
        parser.add_argument("--adam_epsilon"				,   default=1e-8				,   type=__SCREAMING_SNAKE_CASE				,   help="Epsilon for Adam optimizer."       )
        parser.add_argument("--warmup_steps"				,   default=0				,   type=__SCREAMING_SNAKE_CASE				,   help="Linear warmup over warmup_steps."       )
        parser.add_argument("--num_workers"				,   default=4				,   type=__SCREAMING_SNAKE_CASE				,   help="kwarg passed to DataLoader"       )
        parser.add_argument("--num_train_epochs"				,   dest="max_epochs"				,   default=3				,   type=__SCREAMING_SNAKE_CASE       )
        parser.add_argument("--train_batch_size"				,   default=32				,   type=__SCREAMING_SNAKE_CASE       )
        parser.add_argument("--eval_batch_size"				,   default=32				,   type=__SCREAMING_SNAKE_CASE       )
        parser.add_argument("--adafactor"				,   action="store_true"       )



class        lowercase_			(       pl.Callback							):

       def 						_SCREAMING_SNAKE_CASE(     self				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       ):






        '''simple docstring'''

        snake_case__      							=			trainer.lr_schedulers[0]["scheduler"]
        snake_case__      							=			{F"lr_group_{i}": lr for i, lr in enumerate(lr_scheduler.get_lr()       )}
        pl_module.logger.log_metrics(__SCREAMING_SNAKE_CASE       )

       def 						_SCREAMING_SNAKE_CASE(     self				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       ):






        '''simple docstring'''

        rank_zero_info("***** Validation results *****"       )
        snake_case__      							=			trainer.callback_metrics
        # Log results
        for key in sorted(__SCREAMING_SNAKE_CASE       ):
         if key not in ["log", "progress_bar"]:
          rank_zero_info("{} = {}\n".format(__SCREAMING_SNAKE_CASE				,   str(metrics[key]       )       )       )

       def 						_SCREAMING_SNAKE_CASE(     self				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       ):






        '''simple docstring'''

        rank_zero_info("***** Test results *****"       )
        snake_case__      							=			trainer.callback_metrics
        # Log and save results to file
        snake_case__      							=			os.path.join(pl_module.hparams.output_dir				,   "test_results.txt"       )
        with open(__SCREAMING_SNAKE_CASE				,   "w"       ) as writer:
         for key in sorted(__SCREAMING_SNAKE_CASE       ):
          if key not in ["log", "progress_bar"]:
           rank_zero_info("{} = {}\n".format(__SCREAMING_SNAKE_CASE				,   str(metrics[key]       )       )       )
           writer.write("{} = {}\n".format(__SCREAMING_SNAKE_CASE				,   str(metrics[key]       )       )       )





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					None:

 '''simple docstring'''






 parser.add_argument(
     "--output_dir"		,       default=_UpperCAmelCase		,       type=_UpperCAmelCase		,       required=_UpperCAmelCase		,       help="The output directory where the model predictions and checkpoints will be written."		,       )
 parser.add_argument(
     "--fp16"		,       action="store_true"		,       help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit"		,       )

 parser.add_argument(
     "--fp16_opt_level"		,       type=_UpperCAmelCase		,       default="O2"		,       help=(
         "For fp16: Apex AMP optimization level selected in ['O0', 'O1', 'O2', and 'O3']."
         "See details at https://nvidia.github.io/apex/amp.html"
     )		,       )
 parser.add_argument("--n_tpu_cores"		,       dest="tpu_cores"		,       type=_UpperCAmelCase		)
 parser.add_argument("--max_grad_norm"		,       dest="gradient_clip_val"		,       default=1.0		,       type=_UpperCAmelCase		,       help="Max gradient norm"		)
 parser.add_argument("--do_train"		,       action="store_true"		,       help="Whether to run training."		)
 parser.add_argument("--do_predict"		,       action="store_true"		,       help="Whether to run predictions on the test set."		)
 parser.add_argument(
     "--gradient_accumulation_steps"		,       dest="accumulate_grad_batches"		,       type=_UpperCAmelCase		,       default=1		,       help="Number of updates steps to accumulate before performing a backward/update pass."		,       )
 parser.add_argument("--seed"		,       type=_UpperCAmelCase		,       default=4_2		,       help="random seed for initialization"		)
 parser.add_argument(
     "--data_dir"		,       default=_UpperCAmelCase		,       type=_UpperCAmelCase		,       required=_UpperCAmelCase		,       help="The input data dir. Should contain the training files for the CoNLL-2003 NER task."		,       )





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase=None		,       _UpperCAmelCase=True		,       _UpperCAmelCase=[]		,       _UpperCAmelCase=None		,       _UpperCAmelCase=None		,       **_UpperCAmelCase		,       )      ->					List[Any]:

 '''simple docstring'''






 pl.seed_everything(args.seed		)

 # init model
 snake_case__      							=			Path(model.hparams.output_dir		)
 odir.mkdir(exist_ok=_UpperCAmelCase		)

 # add custom checkpoints
 if checkpoint_callback is None:
  snake_case__      							=			pl.callbacks.ModelCheckpoint(
      filepath=args.output_dir		,       prefix="checkpoint"		,       monitor="val_loss"		,       mode="min"		,       save_top_k=1		)
 if early_stopping_callback:
  extra_callbacks.append(_UpperCAmelCase		)
 if logging_callback is None:
  snake_case__      							=			LoggingCallback()

 snake_case__      							=			{}

 # TODO: remove with PyTorch 1.6 since pl uses native amp
 if args.fpaa:
  snake_case__      							=			1_6
  snake_case__      							=			args.fpaa_opt_level

 if args.gpus > 1:
  snake_case__      							=			"ddp"

 snake_case__      							=			args.accumulate_grad_batches
 snake_case__      							=			extra_train_kwargs.get("accelerator"		,       _UpperCAmelCase		)
 snake_case__      							=			extra_train_kwargs.get("profiler"		,       _UpperCAmelCase		)

 snake_case__      							=			pl.Trainer.from_argparse_args(
     _UpperCAmelCase		,       weights_summary=_UpperCAmelCase		,       callbacks=[logging_callback] + extra_callbacks		,       logger=_UpperCAmelCase		,       checkpoint_callback=_UpperCAmelCase		,       **_UpperCAmelCase		,       )

 if args.do_train:
  trainer.fit(_UpperCAmelCase		)

 return trainer








"""simple docstring"""


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_			:

       def __init__(     self				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE = 13				,   __SCREAMING_SNAKE_CASE = 64				,   __SCREAMING_SNAKE_CASE = 2				,   __SCREAMING_SNAKE_CASE = 3				,   __SCREAMING_SNAKE_CASE = 3				,   __SCREAMING_SNAKE_CASE = True				,   __SCREAMING_SNAKE_CASE = True				,   __SCREAMING_SNAKE_CASE = 128				,   __SCREAMING_SNAKE_CASE=[16, 32, 64, 128]				,   __SCREAMING_SNAKE_CASE = 7				,   __SCREAMING_SNAKE_CASE = 4				,   __SCREAMING_SNAKE_CASE = 37				,   __SCREAMING_SNAKE_CASE = "gelu"				,   __SCREAMING_SNAKE_CASE = 0.1				,   __SCREAMING_SNAKE_CASE = 0.1				,   __SCREAMING_SNAKE_CASE = 10				,   __SCREAMING_SNAKE_CASE = 0.02				,   __SCREAMING_SNAKE_CASE = 2				,   __SCREAMING_SNAKE_CASE = 1				,   __SCREAMING_SNAKE_CASE = 128				,   __SCREAMING_SNAKE_CASE = [2, 2, 2, 2]				,   __SCREAMING_SNAKE_CASE = 2				,   __SCREAMING_SNAKE_CASE = 2				,   ):






        '''simple docstring'''

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

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

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

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

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

       def 						_SCREAMING_SNAKE_CASE(     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=__SCREAMING_SNAKE_CASE				,   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 						_SCREAMING_SNAKE_CASE(     self				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       ):






        '''simple docstring'''

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

       def 						_SCREAMING_SNAKE_CASE(     self				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       ):






        '''simple docstring'''

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

        # test greyscale images
        snake_case__      							=			1
        snake_case__      							=			EfficientFormerForImageClassification(__SCREAMING_SNAKE_CASE       )
        model.to(__SCREAMING_SNAKE_CASE       )
        model.eval()

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

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

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



@require_torch
class        lowercase_			(       __lowerCAmelCase			,__lowerCAmelCase			,unittest.TestCase							):
       snake_case__			:							str										=       (
           (
               EfficientFormerModel,
               EfficientFormerForImageClassificationWithTeacher,
               EfficientFormerForImageClassification,
           )
           if is_torch_available()
           else ()
       )
       snake_case__			:							Optional[Any]										=       (
           {
               """feature-extraction""": EfficientFormerModel,
               """image-classification""": (
                   EfficientFormerForImageClassification,
                   EfficientFormerForImageClassificationWithTeacher,
               ),
           }
           if is_torch_available()
           else {}
       )
       snake_case__			:							Tuple										=       False

       snake_case__			:							List[Any]										=       False
       snake_case__			:							Union[str, Any]										=       False
       snake_case__			:							Optional[Any]										=       False

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        snake_case__      							=			EfficientFormerModelTester(self       )
        snake_case__      							=			ConfigTester(
            self				,   config_class=__SCREAMING_SNAKE_CASE				,   has_text_modality=__SCREAMING_SNAKE_CASE				,   hidden_size=37       )

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        self.config_tester.run_common_tests()

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






        '''simple docstring'''

        pass

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






        '''simple docstring'''

        pass

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        snake_case__							,				snake_case__      							=			self.model_tester.prepare_config_and_inputs_for_common()

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

         snake_case__      							=			["pixel_values"]
         self.assertListEqual(arg_names[:1]				,   __SCREAMING_SNAKE_CASE       )

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        def check_hidden_states_output(__SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       ):
         snake_case__      							=			model_class(__SCREAMING_SNAKE_CASE       )
         model.to(__SCREAMING_SNAKE_CASE       )
         model.eval()

         with torch.no_grad():
          snake_case__      							=			model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       )       )

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

         snake_case__      							=			getattr(
             self.model_tester				,   "expected_num_hidden_layers"				,   self.model_tester.num_hidden_layers + 1       )
         self.assertEqual(len(__SCREAMING_SNAKE_CASE       )				,   __SCREAMING_SNAKE_CASE       )

         if hasattr(self.model_tester				,   "encoder_seq_length"       ):
          snake_case__      							=			self.model_tester.encoder_seq_length
          if hasattr(self.model_tester				,   "chunk_length"       ) and self.model_tester.chunk_length > 1:
           snake_case__      							=			seq_length * self.model_tester.chunk_length
         else:
          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:
          snake_case__      							=			outputs.decoder_hidden_states

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

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

        snake_case__							,				snake_case__      							=			self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
         snake_case__      							=			True
         check_hidden_states_output(__SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       )

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

         check_hidden_states_output(__SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       )

       def 						_SCREAMING_SNAKE_CASE(     self				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE=False       ):






        '''simple docstring'''

        snake_case__      							=			super()._prepare_for_class(__SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE				,   return_labels=__SCREAMING_SNAKE_CASE       )

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

        return inputs_dict

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        snake_case__      							=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE       )

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






        '''simple docstring'''

        snake_case__      							=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*__SCREAMING_SNAKE_CASE       )

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        snake_case__      							=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE       )

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        if not self.model_tester.is_training:
         return

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

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

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        snake_case__							,				snake_case__      							=			self.model_tester.prepare_config_and_inputs_for_common()

        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(__SCREAMING_SNAKE_CASE       ),
             ]
             or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
         ):
          continue

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

           snake_case__      							=			model_class(__SCREAMING_SNAKE_CASE       )
           model.to(__SCREAMING_SNAKE_CASE       )
           model.train()

           snake_case__      							=			self._prepare_for_class(__SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE				,   return_labels=__SCREAMING_SNAKE_CASE       )

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

           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=__SCREAMING_SNAKE_CASE       ) as warning_list:
            snake_case__      							=			model(**__SCREAMING_SNAKE_CASE       ).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 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

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

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

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

        snake_case__      							=			getattr(self.model_tester				,   "seq_length"				,   __SCREAMING_SNAKE_CASE       )
        snake_case__      							=			getattr(self.model_tester				,   "encoder_seq_length"				,   __SCREAMING_SNAKE_CASE       )
        snake_case__      							=			getattr(self.model_tester				,   "key_length"				,   __SCREAMING_SNAKE_CASE       )
        snake_case__      							=			getattr(self.model_tester				,   "chunk_length"				,   __SCREAMING_SNAKE_CASE       )

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

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

         # check that output_attentions also work using config
         del inputs_dict["output_attentions"]
         snake_case__      							=			True
         snake_case__      							=			model_class(__SCREAMING_SNAKE_CASE       )
         model.to(__SCREAMING_SNAKE_CASE       )
         model.eval()
         with torch.no_grad():
          snake_case__      							=			model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE				,   __SCREAMING_SNAKE_CASE       )       )
         snake_case__      							=			outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
         self.assertEqual(len(__SCREAMING_SNAKE_CASE       )				,   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__     (					)      ->					Dict:

 '''simple docstring'''






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



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

       @cached_property
       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

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

       @slow
       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        snake_case__      							=			EfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"       ).to(
            __SCREAMING_SNAKE_CASE       )

        snake_case__      							=			self.default_image_processor
        snake_case__      							=			prepare_img()
        snake_case__      							=			image_processor(images=__SCREAMING_SNAKE_CASE				,   return_tensors="pt"       ).to(__SCREAMING_SNAKE_CASE       )

        # forward pass
        with torch.no_grad():
         snake_case__      							=			model(**__SCREAMING_SNAKE_CASE       )

        # verify the logits
        snake_case__      							=			(1, 1000)
        self.assertEqual(outputs.logits.shape				,   __SCREAMING_SNAKE_CASE       )

        snake_case__      							=			torch.tensor([-0.0555, 0.4825, -0.0852]       ).to(__SCREAMING_SNAKE_CASE       )
        self.assertTrue(torch.allclose(outputs.logits[0][:3]				,   __SCREAMING_SNAKE_CASE				,   atol=1e-4       )       )

       @slow
       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        snake_case__      							=			EfficientFormerForImageClassificationWithTeacher.from_pretrained(
            "snap-research/efficientformer-l1-300"       ).to(__SCREAMING_SNAKE_CASE       )

        snake_case__      							=			self.default_image_processor
        snake_case__      							=			prepare_img()
        snake_case__      							=			image_processor(images=__SCREAMING_SNAKE_CASE				,   return_tensors="pt"       ).to(__SCREAMING_SNAKE_CASE       )

        # forward pass
        with torch.no_grad():
         snake_case__      							=			model(**__SCREAMING_SNAKE_CASE       )

        # verify the logits
        snake_case__      							=			(1, 1000)
        self.assertEqual(outputs.logits.shape				,   __SCREAMING_SNAKE_CASE       )

        snake_case__      							=			torch.tensor([-0.1312, 0.4353, -1.0499]       ).to(__SCREAMING_SNAKE_CASE       )
        self.assertTrue(torch.allclose(outputs.logits[0][:3]				,   __SCREAMING_SNAKE_CASE				,   atol=1e-4       )       )

