
'''simple docstring'''



import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
					from PIL import Image

					from transformers import CLIPSegProcessor, ViTImageProcessor

@require_vision
class    _a				(unittest.TestCase):





							"""simple docstring"""




							def        UpperCamelCase				(							self      )    ->			List[Any]:
										_SCREAMING_SNAKE_CASE      =				tempfile.mkdtemp()

										# fmt: off
										_SCREAMING_SNAKE_CASE      =				["""l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """lo""", """l</w>""", """w</w>""", """r</w>""", """t</w>""", """low</w>""", """er</w>""", """lowest</w>""", """newer</w>""", """wider""", """<unk>""", """<|startoftext|>""", """<|endoftext|>"""]
										# fmt: on
										_SCREAMING_SNAKE_CASE      =				dict(zip(A__       ,							range(len(A__      )      )      )      )
										_SCREAMING_SNAKE_CASE      =				["""#version: 0.2""", """l o""", """lo w</w>""", """e r</w>""", """"""]
										_SCREAMING_SNAKE_CASE      =				{"""unk_token""": """<unk>"""}

										_SCREAMING_SNAKE_CASE      =				os.path.join(self.tmpdirname       ,							VOCAB_FILES_NAMES["""vocab_file"""]      )
										_SCREAMING_SNAKE_CASE      =				os.path.join(self.tmpdirname       ,							VOCAB_FILES_NAMES["""merges_file"""]      )
										with open(self.vocab_file       ,							"""w"""       ,							encoding="""utf-8"""      ) as fp:
													fp.write(json.dumps(A__      ) + """\n"""      )
										with open(self.merges_file       ,							"""w"""       ,							encoding="""utf-8"""      ) as fp:
													fp.write("""\n""".join(A__      )      )

										_SCREAMING_SNAKE_CASE      =				{
										    """do_resize""": True,
										    """size""": 20,
										    """do_center_crop""": True,
										    """crop_size""": 18,
										    """do_normalize""": True,
										    """image_mean""": [0.4814_5466, 0.457_8275, 0.4082_1073],
										    """image_std""": [0.2686_2954, 0.2613_0258, 0.2757_7711],
										}
										_SCREAMING_SNAKE_CASE      =				os.path.join(self.tmpdirname       ,							A__      )
										with open(self.image_processor_file       ,							"""w"""       ,							encoding="""utf-8"""      ) as fp:
													json.dump(A__       ,							A__      )






							def        UpperCamelCase				(							self       ,							**A__      )    ->			Any:
										return CLIPTokenizer.from_pretrained(self.tmpdirname       ,							**A__      )






							def        UpperCamelCase				(							self       ,							**A__      )    ->			str:
										return CLIPTokenizerFast.from_pretrained(self.tmpdirname       ,							**A__      )






							def        UpperCamelCase				(							self       ,							**A__      )    ->			Dict:
										return ViTImageProcessor.from_pretrained(self.tmpdirname       ,							**A__      )






							def        UpperCamelCase				(							self      )    ->			Any:
										shutil.rmtree(self.tmpdirname      )






							def        UpperCamelCase				(							self      )    ->			List[Any]:
										_SCREAMING_SNAKE_CASE      =				[np.random.randint(2_55       ,							size=(3, 30, 4_00)       ,							dtype=np.uinta      )]

										_SCREAMING_SNAKE_CASE      =				[Image.fromarray(np.moveaxis(A__       ,							0       ,							-1      )      ) for x in image_inputs]

										return image_inputs






							def        UpperCamelCase				(							self      )    ->			Union[str, Any]:
										_SCREAMING_SNAKE_CASE      =				self.get_tokenizer()
										_SCREAMING_SNAKE_CASE      =				self.get_rust_tokenizer()
										_SCREAMING_SNAKE_CASE      =				self.get_image_processor()

										_SCREAMING_SNAKE_CASE      =				CLIPSegProcessor(tokenizer=A__       ,							image_processor=A__      )
										processor_slow.save_pretrained(self.tmpdirname      )
										_SCREAMING_SNAKE_CASE      =				CLIPSegProcessor.from_pretrained(self.tmpdirname       ,							use_fast=A__      )

										_SCREAMING_SNAKE_CASE      =				CLIPSegProcessor(tokenizer=A__       ,							image_processor=A__      )
										processor_fast.save_pretrained(self.tmpdirname      )
										_SCREAMING_SNAKE_CASE      =				CLIPSegProcessor.from_pretrained(self.tmpdirname      )

										self.assertEqual(processor_slow.tokenizer.get_vocab()       ,							tokenizer_slow.get_vocab()      )
										self.assertEqual(processor_fast.tokenizer.get_vocab()       ,							tokenizer_fast.get_vocab()      )
										self.assertEqual(tokenizer_slow.get_vocab()       ,							tokenizer_fast.get_vocab()      )
										self.assertIsInstance(processor_slow.tokenizer       ,							A__      )
										self.assertIsInstance(processor_fast.tokenizer       ,							A__      )

										self.assertEqual(processor_slow.image_processor.to_json_string()       ,							image_processor.to_json_string()      )
										self.assertEqual(processor_fast.image_processor.to_json_string()       ,							image_processor.to_json_string()      )
										self.assertIsInstance(processor_slow.image_processor       ,							A__      )
										self.assertIsInstance(processor_fast.image_processor       ,							A__      )






							def        UpperCamelCase				(							self      )    ->			Optional[Any]:
										_SCREAMING_SNAKE_CASE      =				CLIPSegProcessor(tokenizer=self.get_tokenizer()       ,							image_processor=self.get_image_processor()      )
										processor.save_pretrained(self.tmpdirname      )

										_SCREAMING_SNAKE_CASE      =				self.get_tokenizer(bos_token="""(BOS)"""       ,							eos_token="""(EOS)"""      )
										_SCREAMING_SNAKE_CASE      =				self.get_image_processor(do_normalize=A__       ,							padding_value=1.0      )

										_SCREAMING_SNAKE_CASE      =				CLIPSegProcessor.from_pretrained(
										    self.tmpdirname       ,							bos_token="""(BOS)"""       ,							eos_token="""(EOS)"""       ,							do_normalize=A__       ,							padding_value=1.0      )

										self.assertEqual(processor.tokenizer.get_vocab()       ,							tokenizer_add_kwargs.get_vocab()      )
										self.assertIsInstance(processor.tokenizer       ,							A__      )

										self.assertEqual(processor.image_processor.to_json_string()       ,							image_processor_add_kwargs.to_json_string()      )
										self.assertIsInstance(processor.image_processor       ,							A__      )






							def        UpperCamelCase				(							self      )    ->			Dict:
										_SCREAMING_SNAKE_CASE      =				self.get_image_processor()
										_SCREAMING_SNAKE_CASE      =				self.get_tokenizer()

										_SCREAMING_SNAKE_CASE      =				CLIPSegProcessor(tokenizer=A__       ,							image_processor=A__      )

										_SCREAMING_SNAKE_CASE      =				self.prepare_image_inputs()

										_SCREAMING_SNAKE_CASE      =				image_processor(A__       ,							return_tensors="""np"""      )
										_SCREAMING_SNAKE_CASE      =				processor(images=A__       ,							return_tensors="""np"""      )

										for key in input_feat_extract.keys():
													self.assertAlmostEqual(input_feat_extract[key].sum()       ,							input_processor[key].sum()       ,							delta=1E-2      )






							def        UpperCamelCase				(							self      )    ->			Tuple:
										_SCREAMING_SNAKE_CASE      =				self.get_image_processor()
										_SCREAMING_SNAKE_CASE      =				self.get_tokenizer()

										_SCREAMING_SNAKE_CASE      =				CLIPSegProcessor(tokenizer=A__       ,							image_processor=A__      )

										_SCREAMING_SNAKE_CASE      =				"""lower newer"""

										_SCREAMING_SNAKE_CASE      =				processor(text=A__      )

										_SCREAMING_SNAKE_CASE      =				tokenizer(A__      )

										for key in encoded_tok.keys():
													self.assertListEqual(encoded_tok[key]       ,							encoded_processor[key]      )






							def        UpperCamelCase				(							self      )    ->			Any:
										_SCREAMING_SNAKE_CASE      =				self.get_image_processor()
										_SCREAMING_SNAKE_CASE      =				self.get_tokenizer()

										_SCREAMING_SNAKE_CASE      =				CLIPSegProcessor(tokenizer=A__       ,							image_processor=A__      )

										_SCREAMING_SNAKE_CASE      =				"""lower newer"""
										_SCREAMING_SNAKE_CASE      =				self.prepare_image_inputs()

										_SCREAMING_SNAKE_CASE      =				processor(text=A__       ,							images=A__      )

										self.assertListEqual(list(inputs.keys()      )       ,							["""input_ids""", """attention_mask""", """pixel_values"""]      )

										# test if it raises when no input is passed
										with pytest.raises(A__      ):
													processor()






							def        UpperCamelCase				(							self      )    ->			int:
										_SCREAMING_SNAKE_CASE      =				self.get_image_processor()
										_SCREAMING_SNAKE_CASE      =				self.get_tokenizer()

										_SCREAMING_SNAKE_CASE      =				CLIPSegProcessor(tokenizer=A__       ,							image_processor=A__      )

										_SCREAMING_SNAKE_CASE      =				self.prepare_image_inputs()
										_SCREAMING_SNAKE_CASE      =				self.prepare_image_inputs()

										_SCREAMING_SNAKE_CASE      =				processor(images=A__       ,							visual_prompt=A__      )

										self.assertListEqual(list(inputs.keys()      )       ,							["""pixel_values""", """conditional_pixel_values"""]      )

										# test if it raises when no input is passed
										with pytest.raises(A__      ):
													processor()






							def        UpperCamelCase				(							self      )    ->			Optional[Any]:
										_SCREAMING_SNAKE_CASE      =				self.get_image_processor()
										_SCREAMING_SNAKE_CASE      =				self.get_tokenizer()

										_SCREAMING_SNAKE_CASE      =				CLIPSegProcessor(tokenizer=A__       ,							image_processor=A__      )

										_SCREAMING_SNAKE_CASE      =				[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

										_SCREAMING_SNAKE_CASE      =				processor.batch_decode(A__      )
										_SCREAMING_SNAKE_CASE      =				tokenizer.batch_decode(A__      )

										self.assertListEqual(A__       ,							A__      )








'''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__      :		Tuple       							=  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    _a				(_lowerCamelCase):





       """simple docstring"""




       def __init__(							self       ,							*A__       ,							A__=None       ,							A__=None       ,							A__=None       ,							**A__      )    ->			Optional[int]:
          super().__init__(*A__       ,							**A__      )
          _SCREAMING_SNAKE_CASE      =				eval_examples
          _SCREAMING_SNAKE_CASE      =				post_process_function
          _SCREAMING_SNAKE_CASE      =				quant_trainer_args
          _SCREAMING_SNAKE_CASE      =				1_28  # default number of calibration samples






       def        UpperCamelCase				(							self       ,							A__=None      )    ->			Union[str, Any]:
          if calib_dataset is None and self.calib_dataset is None:
             raise ValueError("""Trainer: calibration requires an calib_dataset."""      )
          _SCREAMING_SNAKE_CASE      =				calib_dataset if calib_dataset is not None else self.calib_dataset

          _SCREAMING_SNAKE_CASE      =				self._remove_unused_columns(A__       ,							description="""Calibration"""      )

          return DataLoader(
              A__       ,							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=A__       ,							)






       def        UpperCamelCase				(							self       ,							A__=None      )    ->			str:
          _SCREAMING_SNAKE_CASE      =				self.train_dataset if calib_dataset is None else calib_dataset
          _SCREAMING_SNAKE_CASE      =				self.get_calib_dataloader(A__      )

          _SCREAMING_SNAKE_CASE      =				self.model
          quant_trainer.configure_model(A__       ,							self.quant_trainer_args       ,							calib=A__      )
          model.eval()
          quant_trainer.enable_calibration(A__      )

          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(A__      ):
             # Prediction step
             _SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE      =				self.prediction_step(A__       ,							A__       ,							prediction_loss_only=A__      )
             if (step + 1) * calib_dataloader.batch_size >= self.calib_num:
                break

          quant_trainer.finish_calibration(A__       ,							self.quant_trainer_args      )
          _SCREAMING_SNAKE_CASE      =				model






       def        UpperCamelCase				(							self       ,							A__=None       ,							A__=None       ,							A__=None       ,							A__ = "eval"      )    ->			List[Any]:
          _SCREAMING_SNAKE_CASE      =				self.eval_dataset if eval_dataset is None else eval_dataset
          _SCREAMING_SNAKE_CASE      =				self.get_eval_dataloader(A__      )
          _SCREAMING_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.
          _SCREAMING_SNAKE_CASE      =				self.compute_metrics
          _SCREAMING_SNAKE_CASE      =				None
          _SCREAMING_SNAKE_CASE      =				self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
          try:
             _SCREAMING_SNAKE_CASE      =				eval_loop(
                 A__       ,							description="""Evaluation"""       ,							prediction_loss_only=True if compute_metrics is None else None       ,							ignore_keys=A__       ,							)
          finally:
             _SCREAMING_SNAKE_CASE      =				compute_metrics

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

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

             self.log(A__      )
          else:
             _SCREAMING_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()      )

          _SCREAMING_SNAKE_CASE      =				self.callback_handler.on_evaluate(self.args       ,							self.state       ,							self.control       ,							A__      )
          return metrics






       def        UpperCamelCase				(							self       ,							A__       ,							A__       ,							A__=None       ,							A__ = "test"      )    ->			List[str]:
          _SCREAMING_SNAKE_CASE      =				self.get_test_dataloader(A__      )

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

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

          _SCREAMING_SNAKE_CASE      =				self.post_process_function(A__       ,							A__       ,							output.predictions       ,							"""predict"""      )
          _SCREAMING_SNAKE_CASE      =				self.compute_metrics(A__      )

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

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






       def        UpperCamelCase				(							self       ,							A__="./"      )    ->			Tuple:
          _SCREAMING_SNAKE_CASE      =				self.eval_dataset
          _SCREAMING_SNAKE_CASE      =				self.get_eval_dataloader(A__      )

          _SCREAMING_SNAKE_CASE      =				next(iter(A__      )      )

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

          # convert to tuple
          _SCREAMING_SNAKE_CASE      =				tuple(v.to(A__      ) for k, v in batch.items()      )

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

          _SCREAMING_SNAKE_CASE      =				True

          _SCREAMING_SNAKE_CASE      =				self.model.to(A__      )

          model.eval()
          model.float()

          _SCREAMING_SNAKE_CASE      =				model.module if hasattr(A__       ,							"""module"""      ) else model
          quant_trainer.configure_model(A__       ,							self.quant_trainer_args      )

          _SCREAMING_SNAKE_CASE      =				os.path.join(A__       ,							"""model.onnx"""      )
          logger.info(F"exporting model to {output_model_file}"      )

          _SCREAMING_SNAKE_CASE      =				{0: """batch_size""", 1: """seq_len"""}

          torch.onnx.export(
              A__       ,							A__       ,							A__       ,							export_params=A__       ,							opset_version=13       ,							do_constant_folding=A__       ,							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=A__       ,							)
          logger.info("""onnx export finished"""      )






