


import logging
import pathlib
import re
import sys
from dataclasses import dataclass, field
from typing import Any, Callable, Dict, List, Optional, Set, Union

import datasets
import librosa
import numpy as np
import torch
from lang_trans import arabic
from packaging import version
from torch import nn

from transformers import (
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaForCTC,
    WavaVecaProcessor,
    is_apex_available,
    trainer_utils,
)


if is_apex_available():
      from apex import amp

if version.parse(version.parse(torch.__version__).base_version) >= version.parse("1.6"):
      _snake_case				=			True
      from torch.cuda.amp import autocast


_snake_case				=			logging.getLogger(__name__)




@dataclass
class  A_ :







 """simple docstring"""





 _UpperCamelCase					:			str     	=       field(
     metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''}  )
 _UpperCamelCase					:			Optional[str]     	=       field(
     default=lowerCamelCase_   ,    metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''}   ,    )
 _UpperCamelCase					:			Optional[bool]     	=       field(
     default=lowerCamelCase_   ,    metadata={'''help''': '''Whether to freeze the feature extractor layers of the model.'''}  )
 _UpperCamelCase					:			Optional[bool]     	=       field(
     default=lowerCamelCase_   ,    metadata={'''help''': '''Whether to log verbose messages or not.'''}   ,    )







def 	A (		A__		,		A__			):
     logging.basicConfig(
         format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"		,		datefmt="%m/%d/%Y %H:%M:%S"		,		handlers=[logging.StreamHandler(sys.stdout			)]		,		)
     UpperCAmelCase    :					Dict			=      logging.WARNING
     if model_args.verbose_logging:
          UpperCAmelCase    :					Union[str, Any]			=      logging.DEBUG
     elif trainer_utils.is_main_process(training_args.local_rank			):
          UpperCAmelCase    :					Tuple			=      logging.INFO
     logger.setLevel(lowerCamelCase_			)




@dataclass
class  A_ :







 """simple docstring"""





 _UpperCamelCase					:			str     	=       field(
     default=lowerCamelCase_   ,    metadata={'''help''': '''The name of the dataset to use (via the datasets library).'''}  )
 _UpperCamelCase					:			Optional[str]     	=       field(
     default=lowerCamelCase_   ,    metadata={'''help''': '''The configuration name of the dataset to use (via the datasets library).'''}  )
 _UpperCamelCase					:			Optional[str]     	=       field(
     default='''train'''   ,    metadata={
         '''help''': '''The name of the training data set split to use (via the datasets library). Defaults to \'train\''''
     }   ,    )
 _UpperCamelCase					:			Optional[str]     	=       field(
     default='''validation'''   ,    metadata={
         '''help''': (
             '''The name of the validation data set split to use (via the datasets library). Defaults to \'validation\''''
         )
     }   ,    )
 _UpperCamelCase					:			Optional[str]     	=       field(
     default='''text'''   ,    metadata={'''help''': '''Column in the dataset that contains label (target text). Defaults to \'text\''''}   ,    )
 _UpperCamelCase					:			Optional[str]     	=       field(
     default='''file'''   ,    metadata={'''help''': '''Column in the dataset that contains speech file path. Defaults to \'file\''''}   ,    )
 _UpperCamelCase					:			Optional[bool]     	=       field(
     default=lowerCamelCase_   ,    metadata={'''help''': '''Resample loaded audio to target feature extractor\'s sampling rate or not.'''}   ,    )
 _UpperCamelCase					:			Optional[float]     	=       field(
     default=lowerCamelCase_   ,    metadata={'''help''': '''Filters out examples longer than specified. Defaults to no filtering.'''}   ,    )
 _UpperCamelCase					:			Optional[str]     	=       field(
     default='''librispeech'''   ,    metadata={
         '''help''': (
             '''Orthography used for normalization and tokenization: \'librispeech\' (default), \'timit\', or'''
             ''' \'buckwalter\'.'''
         )
     }   ,    )
 _UpperCamelCase					:			bool     	=       field(
     default=lowerCamelCase_   ,    metadata={'''help''': '''Overwrite the cached preprocessed datasets or not.'''}  )
 _UpperCamelCase					:			Optional[int]     	=       field(
     default=lowerCamelCase_   ,    metadata={'''help''': '''The number of processes to use for the preprocessing.'''}   ,    )




@dataclass
class  A_ :







 """simple docstring"""





 _UpperCamelCase					:			bool     	=       False
 _UpperCamelCase					:			Optional[str]     	=       None
 _UpperCamelCase					:			Optional[str]     	=       "|"
 _UpperCamelCase					:			Optional[Dict[str, str]]     	=       field(default_factory=lowerCamelCase_  )
 _UpperCamelCase					:			Optional[Set[str]]     	=       field(default_factory=lowerCamelCase_  )
 _UpperCamelCase					:			Optional[Callable[[str], str]]     	=       None
 @classmethod
 def 	_UpperCamelCase     (      cls       :			List[str]							,     _a       :			str					)     ->      int:

      if name == "librispeech":
           return cls()
      if name == "timit":
           return cls(
               do_lower_case=snake_case_							,     translation_table=str.maketrans({"-": " "}					)							,     )
      if name == "buckwalter":
           UpperCAmelCase    :					Tuple			=      {
               '-': ' ',  # sometimes used to represent pauses
               '^': 'v',  # fixing "tha" in arabic_speech_corpus dataset
           }
           return cls(
               vocab_file=pathlib.Path(snake_case_					).parent.joinpath("vocab/buckwalter.json"					)							,     word_delimiter_token="/"							,     translation_table=str.maketrans(snake_case_					)							,     words_to_remove={"sil"}							,     untransliterator=arabic.buckwalter.untransliterate							,     )
      raise ValueError(f'Unsupported orthography: \'{name}\'.'					)
 def 	_UpperCamelCase     (      self       :			str							,     _a       :			Dict					)     ->      int:

      if len(self.translation_table					) > 0:
           UpperCAmelCase    :					str			=      text.translate(self.translation_table					)
      if len(self.words_to_remove					) == 0:
           UpperCAmelCase    :					List[Any]			=      ' '.join(text.split()					)  # clean up whitespaces
      else:
           UpperCAmelCase    :					str			=      ' '.join(w for w in text.split() if w not in self.words_to_remove					)  # and clean up whilespaces
      return text

 def 	_UpperCamelCase     (      self       :			List[str]							,     _a       :			Optional[int]					)     ->      Optional[int]:
      UpperCAmelCase    :					Optional[Any]			=      WavaVecaFeatureExtractor.from_pretrained(
          model_args.model_name_or_path							,     cache_dir=model_args.cache_dir					)
      if self.vocab_file:
           UpperCAmelCase    :					str			=      WavaVecaCTCTokenizer(
               self.vocab_file							,     cache_dir=model_args.cache_dir							,     do_lower_case=self.do_lower_case							,     word_delimiter_token=self.word_delimiter_token							,     )
      else:
           UpperCAmelCase    :					Tuple			=      WavaVecaCTCTokenizer.from_pretrained(
               model_args.model_name_or_path							,     cache_dir=model_args.cache_dir							,     do_lower_case=self.do_lower_case							,     word_delimiter_token=self.word_delimiter_token							,     )
      return WavaVecaProcessor(snake_case_							,     snake_case_					)




@dataclass
class  A_ :







 """simple docstring"""





 _UpperCamelCase					:			WavaVecaProcessor
 _UpperCamelCase					:			Union[bool, str]     	=       True
 _UpperCamelCase					:			Optional[int]     	=       None
 _UpperCamelCase					:			Optional[int]     	=       None
 _UpperCamelCase					:			Optional[int]     	=       None
 _UpperCamelCase					:			Optional[int]     	=       None
 def __call__(      self       :			Union[str, Any]							,     _a       :			str					)     ->      List[Any]:
      UpperCAmelCase    :					List[str]			=      [{'input_values': feature['input_values']} for feature in features]
      UpperCAmelCase    :					Optional[Any]			=      [{'input_ids': feature['labels']} for feature in features]

      UpperCAmelCase    :					Tuple			=      self.processor.pad(
          snake_case_							,     padding=self.padding							,     max_length=self.max_length							,     pad_to_multiple_of=self.pad_to_multiple_of							,     return_tensors="pt"							,     )
      UpperCAmelCase    :					Optional[int]			=      self.processor.pad(
          labels=snake_case_							,     padding=self.padding							,     max_length=self.max_length_labels							,     pad_to_multiple_of=self.pad_to_multiple_of_labels							,     return_tensors="pt"							,     )

      # replace padding with -100 to ignore loss correctly
      UpperCAmelCase    :					int			=      labels_batch['input_ids'].masked_fill(labels_batch.attention_mask.ne(1					)							,     -1_0_0					)

      UpperCAmelCase    :					List[str]			=      labels

      return batch




class  A_ (			lowerCamelCase_  ):







 """simple docstring"""





 def 	_UpperCamelCase     (      self       :			Any							,     _a       :			Tuple							,     _a       :			int					)     ->      Optional[int]:
      model.train()
      UpperCAmelCase    :					str			=      self._prepare_inputs(snake_case_					)

      if self.use_amp:
           with autocast():
                UpperCAmelCase    :					List[Any]			=      self.compute_loss(snake_case_							,     snake_case_					)
      else:
           UpperCAmelCase    :					Tuple			=      self.compute_loss(snake_case_							,     snake_case_					)

      if self.args.n_gpu > 1:
           if model.module.config.ctc_loss_reduction == "mean":
                UpperCAmelCase    :					List[Any]			=      loss.mean()
           elif model.module.config.ctc_loss_reduction == "sum":
                UpperCAmelCase    :					Dict			=      loss.sum() / (inputs['labels'] >= 0).sum()
           else:
                raise ValueError(f'{model.config.ctc_loss_reduction} is not valid. Choose one of [\'mean\', \'sum\']'					)

      if self.args.gradient_accumulation_steps > 1:
           UpperCAmelCase    :					Union[str, Any]			=      loss / self.args.gradient_accumulation_steps

      if self.use_amp:
           self.scaler.scale(snake_case_					).backward()
      elif self.use_apex:
           with amp.scale_loss(snake_case_							,     self.optimizer					) as scaled_loss:
                scaled_loss.backward()
      elif self.deepspeed:
           self.deepspeed.backward(snake_case_					)
      else:
           loss.backward()

      return loss.detach()







def 	A (		):
     UpperCAmelCase    :					List[Any]			=      HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)			)

     UpperCAmelCase    :					Dict			=      parser.parse_args_into_dataclasses()
     configure_logger(lowerCamelCase_		,		lowerCamelCase_			)

     UpperCAmelCase    :					Optional[Any]			=      Orthography.from_name(data_args.orthography.lower()			)
     UpperCAmelCase    :					Tuple			=      orthography.create_processor(lowerCamelCase_			)
     UpperCAmelCase    :					List[Any]			=      WavaVecaForCTC.from_pretrained(
         model_args.model_name_or_path		,		cache_dir=model_args.cache_dir		,		gradient_checkpointing=training_args.gradient_checkpointing		,		vocab_size=len(processor.tokenizer			)		,		)

     UpperCAmelCase    :					Optional[Any]			=      datasets.load_dataset(
         data_args.dataset_name		,		data_args.dataset_config_name		,		split=data_args.train_split_name			)
     UpperCAmelCase    :					List[str]			=      datasets.load_dataset(
         data_args.dataset_name		,		data_args.dataset_config_name		,		split=data_args.validation_split_name			)

     UpperCAmelCase    :					str			=      datasets.load_metric("wer"			)
     UpperCAmelCase    :					List[Any]			=      processor.feature_extractor.sampling_rate if data_args.target_feature_extractor_sampling_rate else None
     UpperCAmelCase    :					Dict			=      ''.join(t for t in processor.tokenizer.get_vocab().keys() if len(lowerCamelCase_			) == 1			)
     UpperCAmelCase    :					Dict			=      re.compile(  # remove characters not in vocabulary
         Rf'[^\s{re.escape(lowerCamelCase_			)}]'		,		flags=re.IGNORECASE if processor.tokenizer.do_lower_case else 0		,		)
     UpperCAmelCase    :					Union[str, Any]			=      []

     def prepare_example(A__			):  # TODO(elgeish) make use of multiprocessing?
          UpperCAmelCase    :					int			=      librosa.load(example[data_args.speech_file_column]		,		sr=lowerCamelCase_			)
          if data_args.max_duration_in_seconds is not None:
               UpperCAmelCase    :					str			=      len(example["speech"]			) / example['sampling_rate']
          # Normalize and clean up text; order matters!
          UpperCAmelCase    :					Optional[Any]			=      orthography.preprocess_for_training(example[data_args.target_text_column]			)
          UpperCAmelCase    :					List[str]			=      vocabulary_text_cleaner.sub(""		,		lowerCamelCase_			)
          if updated_text != example[data_args.target_text_column]:
               text_updates.append((example[data_args.target_text_column], updated_text)			)
               UpperCAmelCase    :					List[str]			=      updated_text
          return example

     UpperCAmelCase    :					List[str]			=      train_dataset.map(lowerCamelCase_		,		remove_columns=[data_args.speech_file_column]			)
     UpperCAmelCase    :					Optional[Any]			=      val_dataset.map(lowerCamelCase_		,		remove_columns=[data_args.speech_file_column]			)

     if data_args.max_duration_in_seconds is not None:

          def filter_by_max_duration(A__			):
               return example["duration_in_seconds"] <= data_args.max_duration_in_seconds

          UpperCAmelCase    :					List[Any]			=      len(lowerCamelCase_			)
          UpperCAmelCase    :					Union[str, Any]			=      len(lowerCamelCase_			)
          UpperCAmelCase    :					Union[str, Any]			=      train_dataset.filter(lowerCamelCase_		,		remove_columns=["duration_in_seconds"]			)
          UpperCAmelCase    :					Dict			=      val_dataset.filter(lowerCamelCase_		,		remove_columns=["duration_in_seconds"]			)
          if len(lowerCamelCase_			) > old_train_size:
               logger.warning(
                   f'Filtered out {len(lowerCamelCase_			) - old_train_size} train example(s) longer than'
                   f' {data_args.max_duration_in_seconds} second(s).'			)
          if len(lowerCamelCase_			) > old_val_size:
               logger.warning(
                   f'Filtered out {len(lowerCamelCase_			) - old_val_size} validation example(s) longer than'
                   f' {data_args.max_duration_in_seconds} second(s).'			)
     logger.info(f'Split sizes: {len(lowerCamelCase_			)} train and {len(lowerCamelCase_			)} validation.'			)

     logger.warning(f'Updated {len(lowerCamelCase_			)} transcript(s) using \'{data_args.orthography}\' orthography rules.'			)
     if logger.isEnabledFor(logging.DEBUG			):
          for original_text, updated_text in text_updates:
               logger.debug(f'Updated text: "{original_text}" -> "{updated_text}"'			)
     UpperCAmelCase    :					Optional[Any]			=      None

     def prepare_dataset(A__			):
          # check that all files have the correct sampling rate
          assert (
              len(set(batch["sampling_rate"]			)			) == 1
          ), f'Make sure all inputs have the same sampling rate of {processor.feature_extractor.sampling_rate}.'

          UpperCAmelCase    :					Union[str, Any]			=      processor(
              audio=batch["speech"]		,		text=batch[data_args.target_text_column]		,		sampling_rate=batch["sampling_rate"][0]			)
          batch.update(lowerCamelCase_			)
          return batch

     UpperCAmelCase    :					List[str]			=      train_dataset.map(
         lowerCamelCase_		,		batch_size=training_args.per_device_train_batch_size		,		batched=lowerCamelCase_		,		num_proc=data_args.preprocessing_num_workers		,		)
     UpperCAmelCase    :					Union[str, Any]			=      val_dataset.map(
         lowerCamelCase_		,		batch_size=training_args.per_device_train_batch_size		,		batched=lowerCamelCase_		,		num_proc=data_args.preprocessing_num_workers		,		)

     UpperCAmelCase    :					List[str]			=      DataCollatorCTCWithPadding(processor=lowerCamelCase_		,		padding=lowerCamelCase_			)

     def compute_metrics(A__			):
          UpperCAmelCase    :					int			=      pred.predictions
          UpperCAmelCase    :					Union[str, Any]			=      np.argmax(lowerCamelCase_		,		axis=-1			)

          UpperCAmelCase    :					Dict			=      processor.tokenizer.pad_token_id

          UpperCAmelCase    :					Optional[int]			=      processor.batch_decode(lowerCamelCase_			)
          # we do not want to group tokens when computing the metrics
          UpperCAmelCase    :					Optional[int]			=      processor.batch_decode(pred.label_ids		,		group_tokens=lowerCamelCase_			)
          if logger.isEnabledFor(logging.DEBUG			):
               for reference, predicted in zip(lowerCamelCase_		,		lowerCamelCase_			):
                    logger.debug(f'reference: "{reference}"'			)
                    logger.debug(f'predicted: "{predicted}"'			)
                    if orthography.untransliterator is not None:
                         logger.debug(f'reference (untransliterated): "{orthography.untransliterator(lowerCamelCase_			)}"'			)
                         logger.debug(f'predicted (untransliterated): "{orthography.untransliterator(lowerCamelCase_			)}"'			)

          UpperCAmelCase    :					int			=      wer_metric.compute(predictions=lowerCamelCase_		,		references=lowerCamelCase_			)

          return {"wer": wer}

     if model_args.freeze_feature_extractor:
          model.freeze_feature_extractor()

     UpperCAmelCase    :					str			=      CTCTrainer(
         model=lowerCamelCase_		,		data_collator=lowerCamelCase_		,		args=lowerCamelCase_		,		compute_metrics=lowerCamelCase_		,		train_dataset=lowerCamelCase_		,		eval_dataset=lowerCamelCase_		,		tokenizer=processor.feature_extractor		,		)

     trainer.train()


if __name__ == "__main__":
      main()




'''simple docstring'''


import inspect
import unittest

from transformers import ResNetConfig
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_backbone_common import BackboneTesterMixin
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 torch import nn

 from transformers import ResNetBackbone, ResNetForImageClassification, ResNetModel
 from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor






class 	__SCREAMING_SNAKE_CASE		:







  '''simple docstring'''






  def __init__(					self ,						snake_case_ ,						snake_case_=3 ,						snake_case_=3_2 ,						snake_case_=3 ,						snake_case_=1_0 ,						snake_case_=[1_0, 2_0, 3_0, 4_0] ,						snake_case_=[1, 1, 2, 1] ,						snake_case_=True ,						snake_case_=True ,						snake_case_="relu" ,						snake_case_=3 ,						snake_case_=None ,						snake_case_=["stage2", "stage3", "stage4"] ,						snake_case_=[2, 3, 4] ,						):




       '''simple docstring'''

       UpperCAmelCase_				:  Tuple  = parent
       UpperCAmelCase_				:  int  = batch_size
       UpperCAmelCase_				:  Optional[int]  = image_size
       UpperCAmelCase_				:  List[str]  = num_channels
       UpperCAmelCase_				:  Dict  = embeddings_size
       UpperCAmelCase_				:  List[str]  = hidden_sizes
       UpperCAmelCase_				:  int  = depths
       UpperCAmelCase_				:  Dict  = is_training
       UpperCAmelCase_				:  Optional[int]  = use_labels
       UpperCAmelCase_				:  Union[str, Any]  = hidden_act
       UpperCAmelCase_				:  Optional[Any]  = num_labels
       UpperCAmelCase_				:  List[Any]  = scope
       UpperCAmelCase_				:  Tuple  = len(snake_case_		)
       UpperCAmelCase_				:  Dict  = out_features
       UpperCAmelCase_				:  Dict  = out_indices


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  Optional[Any]  = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

       UpperCAmelCase_				:  List[str]  = None
       if self.use_labels:
            UpperCAmelCase_				:  str  = ids_tensor([self.batch_size] ,						self.num_labels		)

       UpperCAmelCase_				:  List[str]  = self.get_config()

       return config, pixel_values, labels


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       return ResNetConfig(
           num_channels=self.num_channels ,						embeddings_size=self.embeddings_size ,						hidden_sizes=self.hidden_sizes ,						depths=self.depths ,						hidden_act=self.hidden_act ,						num_labels=self.num_labels ,						out_features=self.out_features ,						out_indices=self.out_indices ,						)


  def _UpperCamelCase	(					self ,						snake_case_ ,						snake_case_ ,						snake_case_		):




       '''simple docstring'''

       UpperCAmelCase_				:  Dict  = ResNetModel(config=snake_case_		)
       model.to(snake_case_		)
       model.eval()
       UpperCAmelCase_				:  List[Any]  = model(snake_case_		)
       # expected last hidden states: B, C, H // 32, W // 32
       self.parent.assertEqual(
           result.last_hidden_state.shape ,						(self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2) ,						)


  def _UpperCamelCase	(					self ,						snake_case_ ,						snake_case_ ,						snake_case_		):




       '''simple docstring'''

       UpperCAmelCase_				:  Any  = self.num_labels
       UpperCAmelCase_				:  Optional[Any]  = ResNetForImageClassification(snake_case_		)
       model.to(snake_case_		)
       model.eval()
       UpperCAmelCase_				:  Optional[int]  = model(snake_case_ ,						labels=snake_case_		)
       self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.num_labels)		)


  def _UpperCamelCase	(					self ,						snake_case_ ,						snake_case_ ,						snake_case_		):




       '''simple docstring'''

       UpperCAmelCase_				:  List[Any]  = ResNetBackbone(config=snake_case_		)
       model.to(snake_case_		)
       model.eval()
       UpperCAmelCase_				:  Dict  = model(snake_case_		)

       # verify feature maps
       self.parent.assertEqual(len(result.feature_maps		) ,						len(config.out_features		)		)
       self.parent.assertListEqual(list(result.feature_maps[0].shape		) ,						[self.batch_size, self.hidden_sizes[1], 4, 4]		)

       # verify channels
       self.parent.assertEqual(len(model.channels		) ,						len(config.out_features		)		)
       self.parent.assertListEqual(model.channels ,						config.hidden_sizes[1:]		)

       # verify backbone works with out_features=None
       UpperCAmelCase_				:  Tuple  = None
       UpperCAmelCase_				:  Tuple  = ResNetBackbone(config=snake_case_		)
       model.to(snake_case_		)
       model.eval()
       UpperCAmelCase_				:  List[Any]  = model(snake_case_		)

       # verify feature maps
       self.parent.assertEqual(len(result.feature_maps		) ,						1		)
       self.parent.assertListEqual(list(result.feature_maps[0].shape		) ,						[self.batch_size, self.hidden_sizes[-1], 1, 1]		)

       # verify channels
       self.parent.assertEqual(len(model.channels		) ,						1		)
       self.parent.assertListEqual(model.channels ,						[config.hidden_sizes[-1]]		)






  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  List[Any]  = self.prepare_config_and_inputs()
       UpperCAmelCase_  ,     UpperCAmelCase_  ,     UpperCAmelCase_				:  List[Any]  = config_and_inputs
       UpperCAmelCase_				:  str  = {'pixel_values': pixel_values}
       return config, inputs_dict







@require_torch
class 	__SCREAMING_SNAKE_CASE		(			lowerCamelCase_		,      lowerCamelCase_		,      unittest.TestCase			):







  '''simple docstring'''






  lowerCamelCase_						:str		       =						(
      (
          ResNetModel,
          ResNetForImageClassification,
          ResNetBackbone,
      )
      if is_torch_available()
      else ()
  )
  lowerCamelCase_						:List[str]		       =						(
      {'''feature-extraction''': ResNetModel, '''image-classification''': ResNetForImageClassification}
      if is_torch_available()
      else {}
  )

  lowerCamelCase_						:int		       =						True
  lowerCamelCase_						:Optional[Any]		       =						False
  lowerCamelCase_						:Union[str, Any]		       =						False
  lowerCamelCase_						:int		       =						False
  lowerCamelCase_						:str		       =						False


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  Dict  = ResNetModelTester(self		)
       UpperCAmelCase_				:  int  = ConfigTester(self ,						config_class=snake_case_ ,						has_text_modality=snake_case_		)


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       self.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       return


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




       '''simple docstring'''

       pass


  @unittest.skip(reason='ResNet does not support input and output embeddings'		)
  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       pass


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_  ,     UpperCAmelCase_				:  List[Any]  = self.model_tester.prepare_config_and_inputs_for_common()

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

            UpperCAmelCase_				:  List[str]  = ['pixel_values']
            self.assertListEqual(arg_names[:1] ,						snake_case_		)


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  Optional[int]  = self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*snake_case_		)


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  Any  = self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*snake_case_		)


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       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(config=snake_case_		)
            for name, module in model.named_modules():
                 if isinstance(snake_case_ ,						(nn.BatchNormad, nn.GroupNorm)		):
                      self.assertTrue(
                          torch.all(module.weight == 1		) ,						msg=F'''Parameter {name} of model {model_class} seems not properly initialized''' ,						)
                      self.assertTrue(
                          torch.all(module.bias == 0		) ,						msg=F'''Parameter {name} of model {model_class} seems not properly initialized''' ,						)


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       def check_hidden_states_output(snake_case_ ,						snake_case_ ,						snake_case_		):
            UpperCAmelCase_				:  int  = model_class(snake_case_		)
            model.to(snake_case_		)
            model.eval()

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

            UpperCAmelCase_				:  Union[str, Any]  = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

            UpperCAmelCase_				:  str  = self.model_tester.num_stages
            self.assertEqual(len(snake_case_		) ,						expected_num_stages + 1		)

            # ResNet's feature maps are of shape (batch_size, num_channels, height, width)
            self.assertListEqual(
                list(hidden_states[0].shape[-2:]		) ,						[self.model_tester.image_size // 4, self.model_tester.image_size // 4] ,						)

       UpperCAmelCase_  ,     UpperCAmelCase_				:  Any  = self.model_tester.prepare_config_and_inputs_for_common()
       UpperCAmelCase_				:  Optional[Any]  = ['basic', 'bottleneck']
       for model_class in self.all_model_classes:
            for layer_type in layers_type:
                 UpperCAmelCase_				:  Any  = layer_type
                 UpperCAmelCase_				:  str  = True
                 check_hidden_states_output(snake_case_ ,						snake_case_ ,						snake_case_		)

                 # check that output_hidden_states also work using config
                 del inputs_dict["output_hidden_states"]
                 UpperCAmelCase_				:  List[Any]  = True

                 check_hidden_states_output(snake_case_ ,						snake_case_ ,						snake_case_		)


  @unittest.skip(reason='ResNet does not use feedforward chunking'		)
  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       pass


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  Dict  = self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*snake_case_		)






  @slow
  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            UpperCAmelCase_				:  str  = ResNetModel.from_pretrained(snake_case_		)
            self.assertIsNotNone(snake_case_		)







def    _lowerCamelCase       ( ):



     """simple docstring"""





     UpperCAmelCase_				:  Union[str, Any]  = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
     return image






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







  '''simple docstring'''






  @cached_property
  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       return (
           AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)
           if is_vision_available()
           else None
       )






  @slow
  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  str  = ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(snake_case_		)

       UpperCAmelCase_				:  str  = self.default_image_processor
       UpperCAmelCase_				:  Union[str, Any]  = prepare_img()
       UpperCAmelCase_				:  Union[str, Any]  = image_processor(images=snake_case_ ,						return_tensors='pt'		).to(snake_case_		)

       # forward pass
       with torch.no_grad():
            UpperCAmelCase_				:  Union[str, Any]  = model(**snake_case_		)

       # verify the logits
       UpperCAmelCase_				:  Union[str, Any]  = torch.Size((1, 1_0_0_0)		)
       self.assertEqual(outputs.logits.shape ,						snake_case_		)

       UpperCAmelCase_				:  Optional[int]  = torch.tensor([-11.10_69, -9.78_77, -8.37_77]		).to(snake_case_		)

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







@require_torch
class 	__SCREAMING_SNAKE_CASE		(			lowerCamelCase_		,      unittest.TestCase			):







  '''simple docstring'''






  lowerCamelCase_						:Any		       =						(ResNetBackbone,) if is_torch_available() else ()
  lowerCamelCase_						:List[str]		       =						False
  lowerCamelCase_						:Optional[Any]		       =						ResNetConfig


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  List[Any]  = ResNetModelTester(self		)






