

'''simple docstring'''





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_							=					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       ( lowercase__			):







				def __init__(					self    :		Dict		,				*UpperCAmelCase__    :		str		,				UpperCAmelCase__    :		Optional[int]=None		,				UpperCAmelCase__    :		List[str]=None		,				UpperCAmelCase__    :		Optional[int]=None		,				**UpperCAmelCase__    :		Optional[int]      ):
										'''simple docstring'''
										super().__init__(*UpperCAmelCase__		,				**UpperCAmelCase__      )
										lowercase   :       Dict								=eval_examples
										lowercase   :       Union[str, Any]								=post_process_function
										lowercase   :       Optional[Any]								=quant_trainer_args
										lowercase   :       Tuple								=128  # default number of calibration samples







				def    lowerCamelCase_  (					self    :		Dict		,				UpperCAmelCase__    :		str=None      ):
										'''simple docstring'''
										if calib_dataset is None and self.calib_dataset is None:
																raise ValueError('''Trainer: calibration requires an calib_dataset.'''      )
										lowercase   :       Dict								=calib_dataset if calib_dataset is not None else self.calib_dataset

										lowercase   :       str								=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    :		Dict		,				UpperCAmelCase__    :		Optional[Any]=None      ):
										'''simple docstring'''
										lowercase   :       int								=self.train_dataset if calib_dataset is None else calib_dataset
										lowercase   :       Any								=self.get_calib_dataloader(UpperCAmelCase__      )

										lowercase   :       Optional[int]								=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
																lowercase		,  lowercase		,  lowercase   :       Any								=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      )
										lowercase   :       Union[str, Any]								=model







				def    lowerCamelCase_  (					self    :		str		,				UpperCAmelCase__    :		List[Any]=None		,				UpperCAmelCase__    :		List[Any]=None		,				UpperCAmelCase__    :		List[str]=None		,				UpperCAmelCase__    :		str = "eval"      ):
										'''simple docstring'''
										lowercase   :       str								=self.eval_dataset if eval_dataset is None else eval_dataset
										lowercase   :       List[Any]								=self.get_eval_dataloader(UpperCAmelCase__      )
										lowercase   :       Optional[int]								=self.eval_examples if eval_examples is None else eval_examples

										# Temporarily disable metric computation, we will do it in the loop here.
										lowercase   :       Optional[int]								=self.compute_metrics
										lowercase   :       Dict								=None
										lowercase   :       int								=self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
										try:
																lowercase   :       List[str]								=eval_loop(
																    UpperCAmelCase__		,				description='''Evaluation'''		,				prediction_loss_only=True if compute_metrics is None else None		,				ignore_keys=UpperCAmelCase__		,				)
										finally:
																lowercase   :       Tuple								=compute_metrics

										if self.post_process_function is not None and self.compute_metrics is not None:
																lowercase   :       Tuple								=self.post_process_function(UpperCAmelCase__		,				UpperCAmelCase__		,				output.predictions      )
																lowercase   :       Optional[int]								=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}_'''      ):
																												lowercase   :       Optional[int]								=metrics.pop(UpperCAmelCase__      )

																self.log(UpperCAmelCase__      )
										else:
																lowercase   :       str								={}

										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()      )

										lowercase   :       Any								=self.callback_handler.on_evaluate(self.args		,				self.state		,				self.control		,				UpperCAmelCase__      )
										return metrics







				def    lowerCamelCase_  (					self    :		Optional[int]		,				UpperCAmelCase__    :		Optional[int]		,				UpperCAmelCase__    :		List[Any]		,				UpperCAmelCase__    :		Tuple=None		,				UpperCAmelCase__    :		str = "test"      ):
										'''simple docstring'''
										lowercase   :       Any								=self.get_test_dataloader(UpperCAmelCase__      )

										# Temporarily disable metric computation, we will do it in the loop here.
										lowercase   :       List[str]								=self.compute_metrics
										lowercase   :       List[str]								=None
										lowercase   :       Union[str, Any]								=self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
										try:
																lowercase   :       List[Any]								=eval_loop(
																    UpperCAmelCase__		,				description='''Prediction'''		,				prediction_loss_only=True if compute_metrics is None else None		,				ignore_keys=UpperCAmelCase__		,				)
										finally:
																lowercase   :       Tuple								=compute_metrics

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

										lowercase   :       List[str]								=self.post_process_function(UpperCAmelCase__		,				UpperCAmelCase__		,				output.predictions		,				'''predict'''      )
										lowercase   :       Any								=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}_'''      ):
																						lowercase   :       str								=metrics.pop(UpperCAmelCase__      )

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







				def    lowerCamelCase_  (					self    :		Optional[Any]		,				UpperCAmelCase__    :		Optional[int]="./"      ):
										'''simple docstring'''
										lowercase   :       str								=self.eval_dataset
										lowercase   :       List[str]								=self.get_eval_dataloader(UpperCAmelCase__      )

										lowercase   :       Union[str, Any]								=next(iter(UpperCAmelCase__      )      )

										# saving device - to make it consistent
										lowercase   :       Optional[Any]								=torch.device('''cuda''' if torch.cuda.is_available() else '''cpu'''      )

										# convert to tuple
										lowercase   :       Any								=tuple(v.to(UpperCAmelCase__      ) for k, v in batch.items()      )

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

										lowercase   :       str								=True

										lowercase   :       Optional[int]								=self.model.to(UpperCAmelCase__      )

										model.eval()
										model.float()

										lowercase   :       Optional[int]								=model.module if hasattr(UpperCAmelCase__		,				'''module'''      ) else model
										quant_trainer.configure_model(UpperCAmelCase__		,				self.quant_trainer_args      )

										lowercase   :       Dict								=os.path.join(UpperCAmelCase__		,				'''model.onnx'''      )
										logger.info(F'''exporting model to {output_model_file}'''      )

										lowercase   :       Any								={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'''      )








'''simple docstring'''





# coding=utf-8
# Copyright 2023 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import platform
import sys


UpperCamelCase_							=					"""3"""

print("""Python version:""", sys.version)

print("""OS platform:""", platform.platform())
print("""OS architecture:""", platform.machine())

try:
							import torch

							print("""Torch version:""", torch.__version__)
							print("""Cuda available:""", torch.cuda.is_available())
							print("""Cuda version:""", torch.version.cuda)
							print("""CuDNN version:""", torch.backends.cudnn.version())
							print("""Number of GPUs available:""", torch.cuda.device_count())
except ImportError:
							print("""Torch version:""", None)

try:
							import transformers

							print("""transformers version:""", transformers.__version__)
except ImportError:
							print("""transformers version:""", None)





