


import os
import sys
import tempfile

import torch

from .state import AcceleratorState
from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment
def      a_ (      _A      ,   _A=()      ,   _A=None      ,   _A="no"      ,   _A="29500"  )			->			Optional[int]:







				"""simple docstring"""
				snake_case__									=     False
				snake_case__									=     False
				if any(key.startswith('KAGGLE'  ) for key in os.environ.keys()  ):
								snake_case__									=     True
				elif "IPython" in sys.modules:
								snake_case__									=     'google.colab' in str(sys.modules['IPython'].get_ipython()  )

				try:
								snake_case__									=     PrecisionType(mixed_precision.lower()  )
				except ValueError:
								raise ValueError(
								    f'''Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.'''  )

				if (in_colab or in_kaggle) and (os.environ.get('TPU_NAME'      ,   _A  ) is not None):
								# TPU launch
								import torch_xla.distributed.xla_multiprocessing as xmp

								if len(AcceleratorState._shared_state  ) > 0:
												raise ValueError(
												    'To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside '
												    'your training function. Restart your notebook and make sure no cells initializes an '
												    '`Accelerator`.'  )
								if num_processes is None:
												snake_case__									=     8

								snake_case__									=     PrepareForLaunch(_A      ,   distributed_type='TPU'  )
								print(f'''Launching a training on {num_processes} TPU cores.'''  )
								xmp.spawn(_A      ,   args=_A      ,   nprocs=_A      ,   start_method='fork'  )
				elif in_colab:
								# No need for a distributed launch otherwise as it's either CPU or one GPU.
								if torch.cuda.is_available():
												print('Launching training on one GPU.'  )
								else:
												print('Launching training on one CPU.'  )
								function(*_A  )
				else:
								if num_processes is None:
												raise ValueError(
												    'You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call.'  )

								if num_processes > 1:
												# Multi-GPU launch
												from torch.multiprocessing import start_processes
												from torch.multiprocessing.spawn import ProcessRaisedException

												if len(AcceleratorState._shared_state  ) > 0:
																raise ValueError(
																    'To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized '
																    'inside your training function. Restart your notebook and make sure no cells initializes an '
																    '`Accelerator`.'  )

												if torch.cuda.is_initialized():
																raise ValueError(
																    'To launch a multi-GPU training from your notebook, you need to avoid running any instruction '
																    'using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA '
																    'function.'  )

												# torch.distributed will expect a few environment variable to be here. We set the ones common to each
												# process here (the other ones will be set be the launcher).
												with patch_environment(
												    world_size=_A      ,   master_addr='127.0.01'      ,   master_port=_A      ,   mixed_precision=_A  ):
																snake_case__									=     PrepareForLaunch(_A      ,   distributed_type='MULTI_GPU'  )
																print(f'''Launching training on {num_processes} GPUs.'''  )
																try:
																				start_processes(_A      ,   args=_A      ,   nprocs=_A      ,   start_method='fork'  )
																except ProcessRaisedException as e:
																				if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]:
																								raise RuntimeError(
																								    'CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. '
																								    'This likely stems from an outside import causing issues once the `notebook_launcher()` is called. '
																								    'Please review your imports and test them when running the `notebook_launcher()` to identify '
																								    'which one is problematic.'  ) from e

								else:
												# No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
												if is_mps_available():
																snake_case__									=     '1'
																print('Launching training on MPS.'  )
												elif torch.cuda.is_available():
																print('Launching training on one GPU.'  )
												else:
																print('Launching training on CPU.'  )
												function(*_A  )


def      a_ (      _A      ,   _A=()      ,   _A=2  )			->			Union[str, Any]:







				"""simple docstring"""
				from torch.multiprocessing import start_processes

				with tempfile.NamedTemporaryFile() as tmp_file:
								# torch.distributed will expect a few environment variable to be here. We set the ones common to each
								# process here (the other ones will be set be the launcher).
								with patch_environment(
								    world_size=_A      ,   master_addr='127.0.01'      ,   master_port='29500'      ,   accelerate_mixed_precision='no'      ,   accelerate_debug_rdv_file=tmp_file.name      ,   accelerate_use_cpu='yes'      ,   ):
												snake_case__									=     PrepareForLaunch(_A      ,   debug=_A  )
												start_processes(_A      ,   args=_A      ,   nprocs=_A      ,   start_method='fork'  )












import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all image processors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_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,
)


__UpperCamelCase					:		List[Any]	  =						logging.get_logger(__name__)

__UpperCamelCase					:		str	  =						OrderedDict(
    [
        ("""align""", """EfficientNetImageProcessor"""),
        ("""beit""", """BeitImageProcessor"""),
        ("""bit""", """BitImageProcessor"""),
        ("""blip""", """BlipImageProcessor"""),
        ("""blip-2""", """BlipImageProcessor"""),
        ("""bridgetower""", """BridgeTowerImageProcessor"""),
        ("""chinese_clip""", """ChineseCLIPImageProcessor"""),
        ("""clip""", """CLIPImageProcessor"""),
        ("""clipseg""", """ViTImageProcessor"""),
        ("""conditional_detr""", """ConditionalDetrImageProcessor"""),
        ("""convnext""", """ConvNextImageProcessor"""),
        ("""convnextv2""", """ConvNextImageProcessor"""),
        ("""cvt""", """ConvNextImageProcessor"""),
        ("""data2vec-vision""", """BeitImageProcessor"""),
        ("""deformable_detr""", """DeformableDetrImageProcessor"""),
        ("""deit""", """DeiTImageProcessor"""),
        ("""deta""", """DetaImageProcessor"""),
        ("""detr""", """DetrImageProcessor"""),
        ("""dinat""", """ViTImageProcessor"""),
        ("""donut-swin""", """DonutImageProcessor"""),
        ("""dpt""", """DPTImageProcessor"""),
        ("""efficientformer""", """EfficientFormerImageProcessor"""),
        ("""efficientnet""", """EfficientNetImageProcessor"""),
        ("""flava""", """FlavaImageProcessor"""),
        ("""focalnet""", """BitImageProcessor"""),
        ("""git""", """CLIPImageProcessor"""),
        ("""glpn""", """GLPNImageProcessor"""),
        ("""groupvit""", """CLIPImageProcessor"""),
        ("""imagegpt""", """ImageGPTImageProcessor"""),
        ("""instructblip""", """BlipImageProcessor"""),
        ("""layoutlmv2""", """LayoutLMv2ImageProcessor"""),
        ("""layoutlmv3""", """LayoutLMv3ImageProcessor"""),
        ("""levit""", """LevitImageProcessor"""),
        ("""mask2former""", """Mask2FormerImageProcessor"""),
        ("""maskformer""", """MaskFormerImageProcessor"""),
        ("""mgp-str""", """ViTImageProcessor"""),
        ("""mobilenet_v1""", """MobileNetV1ImageProcessor"""),
        ("""mobilenet_v2""", """MobileNetV2ImageProcessor"""),
        ("""mobilevit""", """MobileViTImageProcessor"""),
        ("""mobilevit""", """MobileViTImageProcessor"""),
        ("""mobilevitv2""", """MobileViTImageProcessor"""),
        ("""nat""", """ViTImageProcessor"""),
        ("""oneformer""", """OneFormerImageProcessor"""),
        ("""owlvit""", """OwlViTImageProcessor"""),
        ("""perceiver""", """PerceiverImageProcessor"""),
        ("""pix2struct""", """Pix2StructImageProcessor"""),
        ("""poolformer""", """PoolFormerImageProcessor"""),
        ("""regnet""", """ConvNextImageProcessor"""),
        ("""resnet""", """ConvNextImageProcessor"""),
        ("""sam""", """SamImageProcessor"""),
        ("""segformer""", """SegformerImageProcessor"""),
        ("""swiftformer""", """ViTImageProcessor"""),
        ("""swin""", """ViTImageProcessor"""),
        ("""swin2sr""", """Swin2SRImageProcessor"""),
        ("""swinv2""", """ViTImageProcessor"""),
        ("""table-transformer""", """DetrImageProcessor"""),
        ("""timesformer""", """VideoMAEImageProcessor"""),
        ("""tvlt""", """TvltImageProcessor"""),
        ("""upernet""", """SegformerImageProcessor"""),
        ("""van""", """ConvNextImageProcessor"""),
        ("""videomae""", """VideoMAEImageProcessor"""),
        ("""vilt""", """ViltImageProcessor"""),
        ("""vit""", """ViTImageProcessor"""),
        ("""vit_hybrid""", """ViTHybridImageProcessor"""),
        ("""vit_mae""", """ViTImageProcessor"""),
        ("""vit_msn""", """ViTImageProcessor"""),
        ("""xclip""", """CLIPImageProcessor"""),
        ("""yolos""", """YolosImageProcessor"""),
    ]
)

__UpperCamelCase					:		Union[str, Any]	  =						_LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)
def      a_ (      _A  )			->			Optional[int]:







				"""simple docstring"""
				for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
								if class_name in extractors:
												snake_case__									=     model_type_to_module_name(_A  )

												snake_case__									=     importlib.import_module(f'''.{module_name}'''      ,   'transformers.models'  )
												try:
																return getattr(_A      ,   _A  )
												except AttributeError:
																continue

				for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
								if getattr(_A      ,   '__name__'      ,   _A  ) == class_name:
												return extractor

    # 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.
				snake_case__									=     importlib.import_module('transformers'  )
				if hasattr(_A      ,   _A  ):
								return getattr(_A      ,   _A  )

				return None
def      a_ (      _A      ,   _A = None      ,   _A = False      ,   _A = False      ,   _A = None      ,   _A = None      ,   _A = None      ,   _A = False      ,   **_A      ,   )			->			Optional[Any]:







				"""simple docstring"""
				snake_case__									=     get_file_from_repo(
				    _A      ,   _A      ,   cache_dir=_A      ,   force_download=_A      ,   resume_download=_A      ,   proxies=_A      ,   use_auth_token=_A      ,   revision=_A      ,   local_files_only=_A      ,   )
				if resolved_config_file is None:
								logger.info(
								    'Could not locate the image processor configuration file, will try to use the model config instead.'  )
								return {}

				with open(_A      ,   encoding='utf-8'  ) as reader:
								return json.load(_A  )


class   __SCREAMING_SNAKE_CASE:
							def __init__(     self:      Optional[int]						)		->		Union[str, Any]:
											raise EnvironmentError(
											    'AutoImageProcessor is designed to be instantiated '
											    'using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.'						)
							@classmethod
							@replace_list_option_in_docstrings(UpperCamelCase						)
							def lowerCAmelCase_ (     cls:      int       ,	UpperCamelCase:      int       ,	**UpperCamelCase:      str						)		->		Optional[Any]:
											snake_case__									=     kwargs.pop('config'       ,	UpperCamelCase						)
											snake_case__									=     kwargs.pop('trust_remote_code'       ,	UpperCamelCase						)
											snake_case__									=     True

											snake_case__							,						snake_case__									=     ImageProcessingMixin.get_image_processor_dict(UpperCamelCase       ,	**UpperCamelCase						)
											snake_case__									=     config_dict.get('image_processor_type'       ,	UpperCamelCase						)
											snake_case__									=     None
											if "AutoImageProcessor" in config_dict.get('auto_map'       ,	{}						):
															snake_case__									=     config_dict['auto_map']['AutoImageProcessor']

											# If we still don't have the image processor class, check if we're loading from a previous feature extractor config
											# and if so, infer the image processor class from there.
											if image_processor_class is None and image_processor_auto_map is None:
															snake_case__									=     config_dict.pop('feature_extractor_type'       ,	UpperCamelCase						)
															if feature_extractor_class is not None:
																			logger.warning(
																			    'Could not find image processor class in the image processor config or the model config. Loading'
																			    ' based on pattern matching with the model\'s feature extractor configuration.'						)
																			snake_case__									=     feature_extractor_class.replace('FeatureExtractor'       ,	'ImageProcessor'						)
															if "AutoFeatureExtractor" in config_dict.get('auto_map'       ,	{}						):
																			snake_case__									=     config_dict['auto_map']['AutoFeatureExtractor']
																			snake_case__									=     feature_extractor_auto_map.replace('FeatureExtractor'       ,	'ImageProcessor'						)
																			logger.warning(
																			    'Could not find image processor auto map in the image processor config or the model config.'
																			    ' Loading based on pattern matching with the model\'s feature extractor configuration.'						)

        # If we don't find the image processor class in the image processor config, let's try the model config.
											if image_processor_class is None and image_processor_auto_map is None:
															if not isinstance(UpperCamelCase       ,	UpperCamelCase						):
																			snake_case__									=     AutoConfig.from_pretrained(UpperCamelCase       ,	**UpperCamelCase						)
															# It could be in `config.image_processor_type``
															snake_case__									=     getattr(UpperCamelCase       ,	'image_processor_type'       ,	UpperCamelCase						)
															if hasattr(UpperCamelCase       ,	'auto_map'						) and "AutoImageProcessor" in config.auto_map:
																			snake_case__									=     config.auto_map['AutoImageProcessor']

											if image_processor_class is not None:
															snake_case__									=     image_processor_class_from_name(UpperCamelCase						)

											snake_case__									=     image_processor_auto_map is not None
											snake_case__									=     image_processor_class is not None or type(UpperCamelCase						) in IMAGE_PROCESSOR_MAPPING
											snake_case__									=     resolve_trust_remote_code(
											    UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase						)

											if has_remote_code and trust_remote_code:
															snake_case__									=     get_class_from_dynamic_module(
															    UpperCamelCase       ,	UpperCamelCase       ,	**UpperCamelCase						)
															snake_case__									=     kwargs.pop('code_revision'       ,	UpperCamelCase						)
															if os.path.isdir(UpperCamelCase						):
																			image_processor_class.register_for_auto_class()
															return image_processor_class.from_dict(UpperCamelCase       ,	**UpperCamelCase						)
											elif image_processor_class is not None:
															return image_processor_class.from_dict(UpperCamelCase       ,	**UpperCamelCase						)
											# Last try: we use the IMAGE_PROCESSOR_MAPPING.
											elif type(UpperCamelCase						) in IMAGE_PROCESSOR_MAPPING:
															snake_case__									=     IMAGE_PROCESSOR_MAPPING[type(UpperCamelCase						)]
															return image_processor_class.from_dict(UpperCamelCase       ,	**UpperCamelCase						)

											raise ValueError(
											    F'''Unrecognized image processor in {pretrained_model_name_or_path}. Should have a '''
											    F'''`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following '''
											    F'''`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys()						)}'''						)


							@staticmethod
							def lowerCAmelCase_ (     UpperCamelCase:      Optional[Any]       ,	UpperCamelCase:      int						)		->		Optional[Any]:
											IMAGE_PROCESSOR_MAPPING.register(UpperCamelCase       ,	UpperCamelCase						)




