






import logging
import os

import quant_trainer
import torch
from torch.utils.data import DataLoader

from transformers import Trainer, is_torch_tpu_available
from transformers.trainer_utils import PredictionOutput


__UpperCamelCase					:		Any	  =						logging.getLogger(__name__)

if is_torch_tpu_available(check_device=False):
							import torch_xla.core.xla_model as xm
							import torch_xla.debug.metrics as met


class   __SCREAMING_SNAKE_CASE(	a_	):
							def __init__(     self:      Optional[Any]       ,	*UpperCamelCase:      Dict       ,	UpperCamelCase:      List[Any]=None       ,	UpperCamelCase:      List[str]=None       ,	UpperCamelCase:      Dict=None       ,	**UpperCamelCase:      Dict						)		->		Union[str, Any]:
											super().__init__(*UpperCamelCase       ,	**UpperCamelCase						)
											snake_case__									=     eval_examples
											snake_case__									=     post_process_function
											snake_case__									=     quant_trainer_args
											snake_case__									=     1_28  # default number of calibration samples
							def lowerCAmelCase_ (     self:      Any       ,	UpperCamelCase:      Any=None						)		->		Optional[Any]:
											if calib_dataset is None and self.calib_dataset is None:
															raise ValueError('Trainer: calibration requires an calib_dataset.'						)
											snake_case__									=     calib_dataset if calib_dataset is not None else self.calib_dataset

											snake_case__									=     self._remove_unused_columns(UpperCamelCase       ,	description='Calibration'						)

											return DataLoader(
											    UpperCamelCase       ,	batch_size=self.args.eval_batch_size       ,	collate_fn=self.data_collator       ,	drop_last=self.args.dataloader_drop_last       ,	num_workers=self.args.dataloader_num_workers       ,	pin_memory=self.args.dataloader_pin_memory       ,	shuffle=UpperCamelCase       ,	)
							def lowerCAmelCase_ (     self:      Tuple       ,	UpperCamelCase:      List[str]=None						)		->		Optional[int]:
											snake_case__									=     self.train_dataset if calib_dataset is None else calib_dataset
											snake_case__									=     self.get_calib_dataloader(UpperCamelCase						)

											snake_case__									=     self.model
											quant_trainer.configure_model(UpperCamelCase       ,	self.quant_trainer_args       ,	calib=UpperCamelCase						)
											model.eval()
											quant_trainer.enable_calibration(UpperCamelCase						)

											logger.info('***** Running calibration *****'						)
											logger.info(F'''  Num examples = {self.calib_num}'''						)
											logger.info(F'''  Batch size = {calib_dataloader.batch_size}'''						)

											for step, inputs in enumerate(UpperCamelCase						):
															# Prediction step
															snake_case__							,						snake_case__							,						snake_case__									=     self.prediction_step(UpperCamelCase       ,	UpperCamelCase       ,	prediction_loss_only=UpperCamelCase						)
															if (step + 1) * calib_dataloader.batch_size >= self.calib_num:
																			break

											quant_trainer.finish_calibration(UpperCamelCase       ,	self.quant_trainer_args						)
											snake_case__									=     model
							def lowerCAmelCase_ (     self:      Dict       ,	UpperCamelCase:      Optional[Any]=None       ,	UpperCamelCase:      Optional[Any]=None       ,	UpperCamelCase:      List[str]=None       ,	UpperCamelCase:      str = "eval"						)		->		Any:
											snake_case__									=     self.eval_dataset if eval_dataset is None else eval_dataset
											snake_case__									=     self.get_eval_dataloader(UpperCamelCase						)
											snake_case__									=     self.eval_examples if eval_examples is None else eval_examples

											# Temporarily disable metric computation, we will do it in the loop here.
											snake_case__									=     self.compute_metrics
											snake_case__									=     None
											snake_case__									=     self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
											try:
															snake_case__									=     eval_loop(
															    UpperCamelCase       ,	description='Evaluation'       ,	prediction_loss_only=True if compute_metrics is None else None       ,	ignore_keys=UpperCamelCase       ,	)
											finally:
															snake_case__									=     compute_metrics

											if self.post_process_function is not None and self.compute_metrics is not None:
															snake_case__									=     self.post_process_function(UpperCamelCase       ,	UpperCamelCase       ,	output.predictions						)
															snake_case__									=     self.compute_metrics(UpperCamelCase						)

															# Prefix all keys with metric_key_prefix + '_'
															for key in list(metrics.keys()						):
																			if not key.startswith(F'''{metric_key_prefix}_'''						):
																							snake_case__									=     metrics.pop(UpperCamelCase						)

															self.log(UpperCamelCase						)
											else:
															snake_case__									=     {}

											if self.args.tpu_metrics_debug or self.args.debug:
															# tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.)
															xm.master_print(met.metrics_report()						)

											snake_case__									=     self.callback_handler.on_evaluate(self.args       ,	self.state       ,	self.control       ,	UpperCamelCase						)
											return metrics
							def lowerCAmelCase_ (     self:      int       ,	UpperCamelCase:      Dict       ,	UpperCamelCase:      int       ,	UpperCamelCase:      Dict=None       ,	UpperCamelCase:      str = "test"						)		->		List[str]:
											snake_case__									=     self.get_test_dataloader(UpperCamelCase						)

											# Temporarily disable metric computation, we will do it in the loop here.
											snake_case__									=     self.compute_metrics
											snake_case__									=     None
											snake_case__									=     self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
											try:
															snake_case__									=     eval_loop(
															    UpperCamelCase       ,	description='Prediction'       ,	prediction_loss_only=True if compute_metrics is None else None       ,	ignore_keys=UpperCamelCase       ,	)
											finally:
															snake_case__									=     compute_metrics

											if self.post_process_function is None or self.compute_metrics is None:
															return output

											snake_case__									=     self.post_process_function(UpperCamelCase       ,	UpperCamelCase       ,	output.predictions       ,	'predict'						)
											snake_case__									=     self.compute_metrics(UpperCamelCase						)

											# Prefix all keys with metric_key_prefix + '_'
											for key in list(metrics.keys()						):
															if not key.startswith(F'''{metric_key_prefix}_'''						):
																			snake_case__									=     metrics.pop(UpperCamelCase						)

											return PredictionOutput(predictions=predictions.predictions       ,	label_ids=predictions.label_ids       ,	metrics=UpperCamelCase						)


							def lowerCAmelCase_ (     self:      Optional[int]       ,	UpperCamelCase:      Optional[Any]="./"						)		->		int:
											snake_case__									=     self.eval_dataset
											snake_case__									=     self.get_eval_dataloader(UpperCamelCase						)

											snake_case__									=     next(iter(UpperCamelCase						)						)

											# saving device - to make it consistent
											snake_case__									=     torch.device('cuda' if torch.cuda.is_available() else 'cpu'						)

											# convert to tuple
											snake_case__									=     tuple(v.to(UpperCamelCase						) for k, v in batch.items()						)

											logger.info('Converting model to be onnx compatible'						)
											from pytorch_quantization.nn import TensorQuantizer

											snake_case__									=     True

											snake_case__									=     self.model.to(UpperCamelCase						)

											model.eval()
											model.float()

											snake_case__									=     model.module if hasattr(UpperCamelCase       ,	'module'						) else model
											quant_trainer.configure_model(UpperCamelCase       ,	self.quant_trainer_args						)

											snake_case__									=     os.path.join(UpperCamelCase       ,	'model.onnx'						)
											logger.info(F'''exporting model to {output_model_file}'''						)

											snake_case__									=     {0: 'batch_size', 1: 'seq_len'}

											torch.onnx.export(
											    UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase       ,	export_params=UpperCamelCase       ,	opset_version=13       ,	do_constant_folding=UpperCamelCase       ,	input_names=['input_ids', 'attention_mask', 'token_type_ids']       ,	output_names=['output_start_logits', 'output_end_logits']       ,	dynamic_axes={
											        'input_ids': axes,
											        'attention_mask': axes,
											        'token_type_ids': axes,
											        'output_start_logits': axes,
											        'output_end_logits': axes,
											    }       ,	verbose=UpperCamelCase       ,	)
											logger.info('onnx export finished'						)












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						)




