import argparse
import gc
import os
import threading

import evaluate
import psutil
import torch
from datasets import load_dataset
from torch.distributed.fsdp.fully_sharded_data_parallel import FullOptimStateDictConfig, FullStateDictConfig
from torch.utils.data import DataLoader
from transformers import (
    AutoModelForSequenceClassification,
    AutoTokenizer,
    get_linear_schedule_with_warmup,
    set_seed,
)

from accelerate import Accelerator, DistributedType, FullyShardedDataParallelPlugin


########################################################################
# This is a fully working simple example to use Accelerate
#
# This example trains a Bert base model on GLUE MRPC
# in any of the following settings (with the same script):
#   - single CPU or single GPU
#   - multi GPUS (using PyTorch distributed mode)
#   - (multi) TPUs
#   - fp16 (mixed-precision) or fp32 (normal precision)
#   - FSDP
#
# This example also demonstrates the checkpointing and sharding capabilities
#
# To run it in each of these various modes, follow the instructions
# in the readme for examples:
# https://github.com/huggingface/accelerate/tree/main/examples
#
########################################################################


snake_case__						      =			16
snake_case__						      =			32
def    __magic_name__(	__UpperCAmelCase		)    ->     List[Any]:



      '''simple docstring'''

      return int(x / 2**20		)



class 			UpperCamelCase					:

     '''simple docstring'''

     def __enter__(       self    )			->					Tuple:






           """simple docstring"""
           gc.collect()
           torch.cuda.empty_cache()
           torch.cuda.reset_max_memory_allocated()  # reset the peak gauge to zero
           _lowerCamelCase           =					torch.cuda.memory_allocated()
           _lowerCamelCase           =					psutil.Process()

           _lowerCamelCase           =					self.cpu_mem_used()
           _lowerCamelCase           =					True
           _lowerCamelCase           =					threading.Thread(target=self.peak_monitor_func    )
           _lowerCamelCase           =					True
           peak_monitor_thread.start()
           return self



     def 		UpperCamelCase_    (       self    )			->					Any:






           """simple docstring"""
           return self.process.memory_info().rss



     def 		UpperCamelCase_    (       self    )			->					Optional[int]:






           """simple docstring"""
           _lowerCamelCase           =					-1

           while True:
                 _lowerCamelCase           =					max(self.cpu_mem_used()					,					self.cpu_peak    )

                 # can't sleep or will not catch the peak right (this comment is here on purpose)
                 # time.sleep(0.001) # 1msec

                 if not self.peak_monitoring:
                       break





     def __exit__(       self					,					*A_    )			->					Union[str, Any]:






           """simple docstring"""
           _lowerCamelCase           =					False

           gc.collect()
           torch.cuda.empty_cache()
           _lowerCamelCase           =					torch.cuda.memory_allocated()
           _lowerCamelCase           =					torch.cuda.max_memory_allocated()
           _lowerCamelCase           =					bamb(self.end - self.begin    )
           _lowerCamelCase           =					bamb(self.peak - self.begin    )

           _lowerCamelCase           =					self.cpu_mem_used()
           _lowerCamelCase           =					bamb(self.cpu_end - self.cpu_begin    )
           _lowerCamelCase           =					bamb(self.cpu_peak - self.cpu_begin    )
           # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")


# For testing only
if os.environ.get('TESTING_MOCKED_DATALOADERS', None) == "1":
     from accelerate.test_utils.training import mocked_dataloaders

     snake_case__						      =			mocked_dataloaders  # noqa: F811
def    __magic_name__(	__UpperCAmelCase			,    __UpperCAmelCase		)    ->     Tuple:



      '''simple docstring'''

      if os.environ.get('''TESTING_MOCKED_DATALOADERS'''			,    __UpperCAmelCase		) == "1":
            _lowerCamelCase           =					2

      # New Code #
      # Pass the advanced FSDP settings not part of the accelerate config by creating fsdp_plugin
      _lowerCamelCase           =					FullyShardedDataParallelPlugin(
          state_dict_config=FullStateDictConfig(offload_to_cpu=__UpperCAmelCase			,    ranka_only=__UpperCAmelCase		)			,    optim_state_dict_config=FullOptimStateDictConfig(offload_to_cpu=__UpperCAmelCase			,    ranka_only=__UpperCAmelCase		)			,    )

      # Initialize accelerator
      if args.with_tracking:
            _lowerCamelCase           =					Accelerator(
                cpu=args.cpu			,    mixed_precision=args.mixed_precision			,    log_with='''wandb'''			,    project_dir=args.logging_dir			,    fsdp_plugin=__UpperCAmelCase			,    )
      else:
            _lowerCamelCase           =					Accelerator(fsdp_plugin=__UpperCAmelCase		)
      accelerator.print(accelerator.distributed_type		)

      if hasattr(args.checkpointing_steps			,    '''isdigit'''		):
            if args.checkpointing_steps == "epoch":
                  _lowerCamelCase           =					args.checkpointing_steps
            elif args.checkpointing_steps.isdigit():
                  _lowerCamelCase           =					int(args.checkpointing_steps		)
            else:
                  raise ValueError(
                      F'Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.'		)
      else:
            _lowerCamelCase           =					None
      # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
      _lowerCamelCase           =					config['''lr''']
      _lowerCamelCase           =					int(config['''num_epochs''']		)
      _lowerCamelCase           =					int(config['''seed''']		)
      _lowerCamelCase           =					int(config['''batch_size''']		)

      # We need to initialize the trackers we use, and also store our configuration
      if args.with_tracking:
            _lowerCamelCase           =					vars(__UpperCAmelCase		)
            accelerator.init_trackers('''fsdp_glue_no_trainer'''			,    __UpperCAmelCase		)

      _lowerCamelCase           =					AutoTokenizer.from_pretrained(args.model_name_or_path		)
      _lowerCamelCase           =					load_dataset('''glue'''			,    '''mrpc'''		)
      _lowerCamelCase           =					evaluate.load('''glue'''			,    '''mrpc'''		)

      def tokenize_function(__UpperCAmelCase		):
            # max_length=None => use the model max length (it's actually the default)
            _lowerCamelCase           =					tokenizer(examples['''sentence1''']			,    examples['''sentence2''']			,    truncation=__UpperCAmelCase			,    max_length=__UpperCAmelCase		)
            return outputs

      # Apply the method we just defined to all the examples in all the splits of the dataset
      # starting with the main process first:
      with accelerator.main_process_first():
            _lowerCamelCase           =					datasets.map(
                __UpperCAmelCase			,    batched=__UpperCAmelCase			,    remove_columns=['''idx''', '''sentence1''', '''sentence2''']			,    )

      # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
      # transformers library
      _lowerCamelCase           =					tokenized_datasets.rename_column('''label'''			,    '''labels'''		)

      # If the batch size is too big we use gradient accumulation
      _lowerCamelCase           =					1
      if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU:
            _lowerCamelCase           =					batch_size // MAX_GPU_BATCH_SIZE
            _lowerCamelCase           =					MAX_GPU_BATCH_SIZE

      def collate_fn(__UpperCAmelCase		):
            # On TPU it's best to pad everything to the same length or training will be very slow.
            _lowerCamelCase           =					128 if accelerator.distributed_type == DistributedType.TPU else None
            # When using mixed precision we want round multiples of 8/16
            if accelerator.mixed_precision == "fp8":
                  _lowerCamelCase           =					16
            elif accelerator.mixed_precision != "no":
                  _lowerCamelCase           =					8
            else:
                  _lowerCamelCase           =					None

            return tokenizer.pad(
                __UpperCAmelCase			,    padding='''longest'''			,    max_length=__UpperCAmelCase			,    pad_to_multiple_of=__UpperCAmelCase			,    return_tensors='''pt'''			,    )

      # Instantiate dataloaders.
      _lowerCamelCase           =					DataLoader(
          tokenized_datasets['''train''']			,    shuffle=__UpperCAmelCase			,    collate_fn=__UpperCAmelCase			,    batch_size=__UpperCAmelCase		)
      _lowerCamelCase           =					DataLoader(
          tokenized_datasets['''validation''']			,    shuffle=__UpperCAmelCase			,    collate_fn=__UpperCAmelCase			,    batch_size=__UpperCAmelCase		)

      set_seed(__UpperCAmelCase		)

      # Instantiate the model (we build the model here so that the seed also control new weights initialization)
      _lowerCamelCase           =					AutoModelForSequenceClassification.from_pretrained(
          args.model_name_or_path			,    return_dict=__UpperCAmelCase			,    low_cpu_mem_usage=__UpperCAmelCase		)

      # New Code #
      # For FSDP feature, it is highly recommended and efficient to prepare the model before creating optimizer
      _lowerCamelCase           =					accelerator.prepare(__UpperCAmelCase		)
      accelerator.print(__UpperCAmelCase		)

      # Instantiate optimizer
      # New Code #
      # For FSDP feature, at present it doesn't support multiple parameter groups,
      # so we need to create a single parameter group for the whole model
      _lowerCamelCase           =					torch.optim.AdamW(params=model.parameters()			,    lr=__UpperCAmelCase			,    weight_decay=2E-4		)

      # Instantiate scheduler
      _lowerCamelCase           =					get_linear_schedule_with_warmup(
          optimizer=__UpperCAmelCase			,    num_warmup_steps=10			,    num_training_steps=(len(__UpperCAmelCase		) * num_epochs) // gradient_accumulation_steps			,    )

      # New Code #
      # For FSDP feature, prepare everything except the model as we have already prepared the model
      # before creating the optimizer
      # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
      # prepare method.
      _lowerCamelCase     ,       _lowerCamelCase     ,       _lowerCamelCase     ,       _lowerCamelCase           =					accelerator.prepare(
          __UpperCAmelCase			,    __UpperCAmelCase			,    __UpperCAmelCase			,    __UpperCAmelCase		)

      _lowerCamelCase           =					0

      # Potentially load in the weights and states from a previous save
      if args.resume_from_checkpoint:
            if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
                  accelerator.print(F'Resumed from checkpoint: {args.resume_from_checkpoint}'		)
                  accelerator.load_state(args.resume_from_checkpoint		)
                  _lowerCamelCase           =					os.path.basename(args.resume_from_checkpoint		)
            else:
                  # Get the most recent checkpoint
                  _lowerCamelCase           =					[f.name for f in os.scandir(os.getcwd()		) if f.is_dir()]
                  dirs.sort(key=os.path.getctime		)
                  _lowerCamelCase           =					dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
            # Extract `epoch_{i}` or `step_{i}`
            _lowerCamelCase           =					os.path.splitext(__UpperCAmelCase		)[0]

            if "epoch" in training_difference:
                  num_epochs -= int(training_difference.replace('''epoch_'''			,    ''''''		)		)
                  _lowerCamelCase           =					None
            else:
                  _lowerCamelCase           =					int(training_difference.replace('''step_'''			,    ''''''		)		)
                  num_epochs -= resume_step // len(__UpperCAmelCase		)
                  # If resuming by step, we also need to know exactly how far into the DataLoader we went
                  _lowerCamelCase           =					(num_epochs * len(__UpperCAmelCase		)) - resume_step

    # Now we train the model
      for epoch in range(__UpperCAmelCase		):
            # New Code #
            # context manager to track the peak memory usage during the training epoch
            with TorchTracemalloc() as tracemalloc:
                  model.train()
                  if args.with_tracking:
                        _lowerCamelCase           =					0
                  for step, batch in enumerate(__UpperCAmelCase		):
                        # We need to skip steps until we reach the resumed step
                        if args.resume_from_checkpoint and epoch == 0:
                              if resume_step is not None and step < resume_step:
                                    pass
                # We could avoid this line since we set the accelerator with `device_placement=True`.
                        batch.to(accelerator.device		)
                        _lowerCamelCase           =					model(**__UpperCAmelCase		)
                        _lowerCamelCase           =					outputs.loss
                        _lowerCamelCase           =					loss / gradient_accumulation_steps
                        # We keep track of the loss at each epoch
                        if args.with_tracking:
                              total_loss += loss.detach().float()
                        accelerator.backward(__UpperCAmelCase		)
                        if step % gradient_accumulation_steps == 0:
                              optimizer.step()
                              lr_scheduler.step()
                              optimizer.zero_grad()
                              # accelerator.print(lr_scheduler.get_lr())

                        overall_step += 1

                        if isinstance(__UpperCAmelCase			,    __UpperCAmelCase		):
                              _lowerCamelCase           =					F'step_{overall_step}'
                              if overall_step % checkpointing_steps == 0:
                                    if args.output_dir is not None:
                                          _lowerCamelCase           =					os.path.join(args.output_dir			,    __UpperCAmelCase		)
                                    accelerator.save_state(__UpperCAmelCase		)
        # New Code #
        # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage
            accelerator.print('''Memory before entering the train : {}'''.format(bamb(tracemalloc.begin		)		)		)
            accelerator.print('''Memory consumed at the end of the train (end-begin): {}'''.format(tracemalloc.used		)		)
            accelerator.print('''Peak Memory consumed during the train (max-begin): {}'''.format(tracemalloc.peaked		)		)
            accelerator.print(
                '''Total Peak Memory consumed during the train (max): {}'''.format(
                    tracemalloc.peaked + bamb(tracemalloc.begin		)		)		)
            # Logging the peak memory usage of the GPU to the tracker
            if args.with_tracking:
                  accelerator.log(
                      {
                          '''train_total_peak_memory''': tracemalloc.peaked + bamb(tracemalloc.begin		),
                      }			,    step=__UpperCAmelCase			,    )

            # New Code #
            # context manager to track the peak memory usage during the evaluation
            with TorchTracemalloc() as tracemalloc:
                  model.eval()
                  for step, batch in enumerate(__UpperCAmelCase		):
                        # We could avoid this line since we set the accelerator with `device_placement=True`.
                        batch.to(accelerator.device		)
                        with torch.no_grad():
                              _lowerCamelCase           =					model(**__UpperCAmelCase		)
                        _lowerCamelCase           =					outputs.logits.argmax(dim=-1		)
                        _lowerCamelCase     ,       _lowerCamelCase           =					accelerator.gather_for_metrics((predictions, batch['''labels'''])		)
                        metric.add_batch(
                            predictions=__UpperCAmelCase			,    references=__UpperCAmelCase			,    )

                  _lowerCamelCase           =					metric.compute()
                  # Use accelerator.print to print only on the main process.
                  accelerator.print(F'epoch {epoch}:'			,    __UpperCAmelCase		)
                  if args.with_tracking:
                        accelerator.log(
                            {
                                '''accuracy''': eval_metric['''accuracy'''],
                                '''f1''': eval_metric['''f1'''],
                                '''train_loss''': total_loss.item() / len(__UpperCAmelCase		),
                            }			,    step=__UpperCAmelCase			,    )

                  if checkpointing_steps == "epoch":
                        _lowerCamelCase           =					F'epoch_{epoch}'
                        if args.output_dir is not None:
                              _lowerCamelCase           =					os.path.join(args.output_dir			,    __UpperCAmelCase		)
                        accelerator.save_state(__UpperCAmelCase		)
        # New Code #
        # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage
            accelerator.print('''Memory before entering the eval : {}'''.format(bamb(tracemalloc.begin		)		)		)
            accelerator.print('''Memory consumed at the end of the eval (end-begin): {}'''.format(tracemalloc.used		)		)
            accelerator.print('''Peak Memory consumed during the eval (max-begin): {}'''.format(tracemalloc.peaked		)		)
            accelerator.print(
                '''Total Peak Memory consumed during the eval (max): {}'''.format(tracemalloc.peaked + bamb(tracemalloc.begin		)		)		)
            # Logging the peak memory usage of the GPU to the tracker
            if args.with_tracking:
                  accelerator.log(
                      {
                          '''eval_total_peak_memory''': tracemalloc.peaked + bamb(tracemalloc.begin		),
                      }			,    step=__UpperCAmelCase			,    )

      if args.with_tracking:
            accelerator.end_training()
def    __magic_name__(	)    ->     Dict:



      '''simple docstring'''

      _lowerCamelCase           =					argparse.ArgumentParser(description='''Simple example of training script.'''		)
      parser.add_argument(
          '''--mixed_precision'''			,    type=__UpperCAmelCase			,    default=__UpperCAmelCase			,    choices=['''no''', '''fp16''', '''bf16''', '''fp8''']			,    help='''Whether to use mixed precision. Choose'''
          '''between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.'''
          '''and an Nvidia Ampere GPU.'''			,    )
      parser.add_argument('''--cpu'''			,    action='''store_true'''			,    help='''If passed, will train on the CPU.'''		)
      parser.add_argument(
          '''--checkpointing_steps'''			,    type=__UpperCAmelCase			,    default=__UpperCAmelCase			,    help='''Whether the various states should be saved at the end of every n steps, or \'epoch\' for each epoch.'''			,    )
      parser.add_argument(
          '''--resume_from_checkpoint'''			,    type=__UpperCAmelCase			,    default=__UpperCAmelCase			,    help='''If the training should continue from a checkpoint folder.'''			,    )
      parser.add_argument(
          '''--with_tracking'''			,    action='''store_true'''			,    help='''Whether to load in all available experiment trackers from the environment and use them for logging.'''			,    )
      parser.add_argument(
          '''--output_dir'''			,    type=__UpperCAmelCase			,    default='''.'''			,    help='''Optional save directory where all checkpoint folders will be stored. Default is the current working directory.'''			,    )
      parser.add_argument(
          '''--logging_dir'''			,    type=__UpperCAmelCase			,    default='''logs'''			,    help='''Location on where to store experiment tracking logs`'''			,    )
      parser.add_argument(
          '''--model_name_or_path'''			,    type=__UpperCAmelCase			,    help='''Path to pretrained model or model identifier from huggingface.co/models.'''			,    required=__UpperCAmelCase			,    )
      _lowerCamelCase           =					parser.parse_args()
      _lowerCamelCase           =					{'''lr''': 2E-5, '''num_epochs''': 3, '''seed''': 42, '''batch_size''': 16}
      training_function(__UpperCAmelCase			,    __UpperCAmelCase		)


if __name__ == "__main__":
     main()
import importlib
import inspect
import json
import os
from collections import OrderedDict

# Build the list of all feature extractors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...feature_extraction_utils import FeatureExtractionMixin
from ...image_processing_utils import ImageProcessingMixin
from ...tokenization_utils import TOKENIZER_CONFIG_FILE
from ...utils import FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)
from .feature_extraction_auto import AutoFeatureExtractor
from .image_processing_auto import AutoImageProcessor
from .tokenization_auto import AutoTokenizer


snake_case__						      =			logging.get_logger(__name__)

snake_case__						      =			OrderedDict(
    [
        ('align', 'AlignProcessor'),
        ('altclip', 'AltCLIPProcessor'),
        ('bark', 'BarkProcessor'),
        ('blip', 'BlipProcessor'),
        ('blip-2', 'Blip2Processor'),
        ('bridgetower', 'BridgeTowerProcessor'),
        ('chinese_clip', 'ChineseCLIPProcessor'),
        ('clap', 'ClapProcessor'),
        ('clip', 'CLIPProcessor'),
        ('clipseg', 'CLIPSegProcessor'),
        ('flava', 'FlavaProcessor'),
        ('git', 'GitProcessor'),
        ('groupvit', 'CLIPProcessor'),
        ('hubert', 'Wav2Vec2Processor'),
        ('instructblip', 'InstructBlipProcessor'),
        ('layoutlmv2', 'LayoutLMv2Processor'),
        ('layoutlmv3', 'LayoutLMv3Processor'),
        ('markuplm', 'MarkupLMProcessor'),
        ('mctct', 'MCTCTProcessor'),
        ('mgp-str', 'MgpstrProcessor'),
        ('oneformer', 'OneFormerProcessor'),
        ('owlvit', 'OwlViTProcessor'),
        ('pix2struct', 'Pix2StructProcessor'),
        ('sam', 'SamProcessor'),
        ('sew', 'Wav2Vec2Processor'),
        ('sew-d', 'Wav2Vec2Processor'),
        ('speech_to_text', 'Speech2TextProcessor'),
        ('speech_to_text_2', 'Speech2Text2Processor'),
        ('speecht5', 'SpeechT5Processor'),
        ('trocr', 'TrOCRProcessor'),
        ('tvlt', 'TvltProcessor'),
        ('unispeech', 'Wav2Vec2Processor'),
        ('unispeech-sat', 'Wav2Vec2Processor'),
        ('vilt', 'ViltProcessor'),
        ('vision-text-dual-encoder', 'VisionTextDualEncoderProcessor'),
        ('wav2vec2', 'Wav2Vec2Processor'),
        ('wav2vec2-conformer', 'Wav2Vec2Processor'),
        ('wavlm', 'Wav2Vec2Processor'),
        ('whisper', 'WhisperProcessor'),
        ('xclip', 'XCLIPProcessor'),
    ]
)

snake_case__						      =			_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)
def    __magic_name__(	__UpperCAmelCase		)    ->     List[str]:



      '''simple docstring'''

      for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
            if class_name in processors:
                  _lowerCamelCase           =					model_type_to_module_name(__UpperCAmelCase		)

                  _lowerCamelCase           =					importlib.import_module(F'.{module_name}'			,    '''transformers.models'''		)
                  try:
                        return getattr(__UpperCAmelCase			,    __UpperCAmelCase		)
                  except AttributeError:
                        continue

      for processor in PROCESSOR_MAPPING._extra_content.values():
            if getattr(__UpperCAmelCase			,    '''__name__'''			,    __UpperCAmelCase		) == class_name:
                  return processor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
      _lowerCamelCase           =					importlib.import_module('''transformers'''		)
      if hasattr(__UpperCAmelCase			,    __UpperCAmelCase		):
            return getattr(__UpperCAmelCase			,    __UpperCAmelCase		)

      return None




class 			UpperCamelCase					:

     '''simple docstring'''

     def __init__(       self    )			->					List[str]:






           """simple docstring"""
           raise EnvironmentError(
               '''AutoProcessor is designed to be instantiated '''
               '''using the `AutoProcessor.from_pretrained(pretrained_model_name_or_path)` method.'''    )



     @classmethod
     @replace_list_option_in_docstrings(A_    )
     def 		UpperCamelCase_    (       cls					,					A_					,					**A_    )			->					List[Any]:






           """simple docstring"""
           _lowerCamelCase           =					kwargs.pop('''config'''					,					A_    )
           _lowerCamelCase           =					kwargs.pop('''trust_remote_code'''					,					A_    )
           _lowerCamelCase           =					True

           _lowerCamelCase           =					None
           _lowerCamelCase           =					None

           # First, let's see if we have a preprocessor config.
           # Filter the kwargs for `get_file_from_repo`.
           _lowerCamelCase           =					{
               key: kwargs[key] for key in inspect.signature(A_    ).parameters.keys() if key in kwargs
           }
           # Let's start by checking whether the processor class is saved in an image processor
           _lowerCamelCase           =					get_file_from_repo(
               A_					,					A_					,					**A_    )
           if preprocessor_config_file is not None:
                 _lowerCamelCase     ,       _lowerCamelCase           =					ImageProcessingMixin.get_image_processor_dict(A_					,					**A_    )
                 _lowerCamelCase           =					config_dict.get('''processor_class'''					,					A_    )
                 if "AutoProcessor" in config_dict.get('''auto_map'''					,					{}    ):
                       _lowerCamelCase           =					config_dict['''auto_map''']['''AutoProcessor''']

        # If not found, let's check whether the processor class is saved in a feature extractor config
           if preprocessor_config_file is not None and processor_class is None:
                 _lowerCamelCase     ,       _lowerCamelCase           =					FeatureExtractionMixin.get_feature_extractor_dict(A_					,					**A_    )
                 _lowerCamelCase           =					config_dict.get('''processor_class'''					,					A_    )
                 if "AutoProcessor" in config_dict.get('''auto_map'''					,					{}    ):
                       _lowerCamelCase           =					config_dict['''auto_map''']['''AutoProcessor''']

           if processor_class is None:
                 # Next, let's check whether the processor class is saved in a tokenizer
                 _lowerCamelCase           =					get_file_from_repo(
                     A_					,					A_					,					**A_    )
                 if tokenizer_config_file is not None:
                       with open(A_					,					encoding='''utf-8'''    ) as reader:
                             _lowerCamelCase           =					json.load(A_    )

                       _lowerCamelCase           =					config_dict.get('''processor_class'''					,					A_    )
                       if "AutoProcessor" in config_dict.get('''auto_map'''					,					{}    ):
                             _lowerCamelCase           =					config_dict['''auto_map''']['''AutoProcessor''']

           if processor_class is None:
                 # Otherwise, load config, if it can be loaded.
                 if not isinstance(A_					,					A_    ):
                       _lowerCamelCase           =					AutoConfig.from_pretrained(
                           A_					,					trust_remote_code=A_					,					**A_    )

                 # And check if the config contains the processor class.
                 _lowerCamelCase           =					getattr(A_					,					'''processor_class'''					,					A_    )
                 if hasattr(A_					,					'''auto_map'''    ) and "AutoProcessor" in config.auto_map:
                       _lowerCamelCase           =					config.auto_map['''AutoProcessor''']

           if processor_class is not None:
                 _lowerCamelCase           =					processor_class_from_name(A_    )

           _lowerCamelCase           =					processor_auto_map is not None
           _lowerCamelCase           =					processor_class is not None or type(A_    ) in PROCESSOR_MAPPING
           _lowerCamelCase           =					resolve_trust_remote_code(
               A_					,					A_					,					A_					,					A_    )

           if has_remote_code and trust_remote_code:
                 _lowerCamelCase           =					get_class_from_dynamic_module(
                     A_					,					A_					,					**A_    )
                 _lowerCamelCase           =					kwargs.pop('''code_revision'''					,					A_    )
                 if os.path.isdir(A_    ):
                       processor_class.register_for_auto_class()
                 return processor_class.from_pretrained(
                     A_					,					trust_remote_code=A_					,					**A_    )
           elif processor_class is not None:
                 return processor_class.from_pretrained(
                     A_					,					trust_remote_code=A_					,					**A_    )
           # Last try: we use the PROCESSOR_MAPPING.
           elif type(A_    ) in PROCESSOR_MAPPING:
                 return PROCESSOR_MAPPING[type(A_    )].from_pretrained(A_					,					**A_    )

           # At this stage, there doesn't seem to be a `Processor` class available for this model, so let's try a
           # tokenizer.
           try:
                 return AutoTokenizer.from_pretrained(
                     A_					,					trust_remote_code=A_					,					**A_    )
           except Exception:
                 try:
                       return AutoImageProcessor.from_pretrained(
                           A_					,					trust_remote_code=A_					,					**A_    )
                 except Exception:
                       pass

                 try:
                       return AutoFeatureExtractor.from_pretrained(
                           A_					,					trust_remote_code=A_					,					**A_    )
                 except Exception:
                       pass

           raise ValueError(
               F'Unrecognized processing class in {pretrained_model_name_or_path}. Can\'t instantiate a processor, a '
               '''tokenizer, an image processor or a feature extractor for this model. Make sure the repository contains'''
               '''the files of at least one of those processing classes.'''    )





     @staticmethod
     def 		UpperCamelCase_    (       A_					,					A_    )			->					List[Any]:






           """simple docstring"""
           PROCESSOR_MAPPING.register(A_					,					A_    )