


"""simple docstring"""


import argparse
import glob
import logging
import os
import time
from argparse import Namespace

import numpy as np
import torch
from lightning_base import BaseTransformer, add_generic_args, generic_train
from torch.utils.data import DataLoader, TensorDataset

from transformers import glue_compute_metrics as compute_metrics
from transformers import glue_convert_examples_to_features as convert_examples_to_features
from transformers import glue_output_modes, glue_tasks_num_labels
from transformers import glue_processors as processors


A     :   Union[str, Any]			    =			logging.getLogger(__name__)
class   _UpperCamelCase  (   lowerCAmelCase__		):
							'''simple docstring'''







							__UpperCAmelCase						:    Optional[Any]				      ="""sequence-classification"""

							def __init__(     self    ,   __a	):
										if type(__a	) == dict:
													__lowerCAmelCase				    =			Namespace(**__a	)
										__lowerCAmelCase				    =			glue_output_modes[hparams.task]
										__lowerCAmelCase				    =			glue_tasks_num_labels[hparams.task]

										super().__init__(__a    ,   __a    ,   self.mode	)

							def 			snake_case				(     self    ,   **__a	):
										return self.model(**__a	)

							def 			snake_case				(     self    ,   __a    ,   __a	):
										__lowerCAmelCase				    =			{"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}

										if self.config.model_type not in ["distilbert", "bart"]:
													__lowerCAmelCase				    =			batch[2] if self.config.model_type in ["bert", "xlnet", "albert"] else None

										__lowerCAmelCase				    =			self(**__a	)
										__lowerCAmelCase				    =			outputs[0]

										__lowerCAmelCase				    =			self.trainer.lr_schedulers[0]["scheduler"]
										__lowerCAmelCase				    =			{"loss": loss, "rate": lr_scheduler.get_last_lr()[-1]}
										return {"loss": loss, "log": tensorboard_logs}

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.hparams
										__lowerCAmelCase				    =			processors[args.task]()
										__lowerCAmelCase				    =			processor.get_labels()

										for mode in ["train", "dev"]:
													__lowerCAmelCase				    =			self._feature_file(__a	)
													if os.path.exists(__a	) and not args.overwrite_cache:
																logger.info("Loading features from cached file %s"    ,   __a	)
													else:
																logger.info("Creating features from dataset file at %s"    ,   args.data_dir	)
																__lowerCAmelCase				    =			(
																    processor.get_dev_examples(args.data_dir	)
																    if mode == "dev"
																    else processor.get_train_examples(args.data_dir	)
																)
																__lowerCAmelCase				    =			convert_examples_to_features(
																    __a    ,   self.tokenizer    ,   max_length=args.max_seq_length    ,   label_list=self.labels    ,   output_mode=args.glue_output_mode    ,   )
																logger.info("Saving features into cached file %s"    ,   __a	)
																torch.save(__a    ,   __a	)

							def 			snake_case				(     self    ,   __a    ,   __a    ,   __a = False	):
										__lowerCAmelCase				    =			"dev" if mode == "test" else mode

										__lowerCAmelCase				    =			self._feature_file(__a	)
										logger.info("Loading features from cached file %s"    ,   __a	)
										__lowerCAmelCase				    =			torch.load(__a	)
										__lowerCAmelCase				    =			torch.tensor([f.input_ids for f in features]    ,   dtype=torch.long	)
										__lowerCAmelCase				    =			torch.tensor([f.attention_mask for f in features]    ,   dtype=torch.long	)
										__lowerCAmelCase				    =			torch.tensor([f.token_type_ids for f in features]    ,   dtype=torch.long	)
										if self.hparams.glue_output_mode == "classification":
													__lowerCAmelCase				    =			torch.tensor([f.label for f in features]    ,   dtype=torch.long	)
										elif self.hparams.glue_output_mode == "regression":
													__lowerCAmelCase				    =			torch.tensor([f.label for f in features]    ,   dtype=torch.float	)

										return DataLoader(
										    TensorDataset(__a    ,   __a    ,   __a    ,   __a	)    ,   batch_size=__a    ,   shuffle=__a    ,   )

							def 			snake_case				(     self    ,   __a    ,   __a	):
										__lowerCAmelCase				    =			{"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}

										if self.config.model_type not in ["distilbert", "bart"]:
													__lowerCAmelCase				    =			batch[2] if self.config.model_type in ["bert", "xlnet", "albert"] else None

										__lowerCAmelCase				    =			self(**__a	)
										__lowerCAmelCase    ,	__lowerCAmelCase				    =			outputs[:2]
										__lowerCAmelCase				    =			logits.detach().cpu().numpy()
										__lowerCAmelCase				    =			inputs["labels"].detach().cpu().numpy()

										return {"val_loss": tmp_eval_loss.detach().cpu(), "pred": preds, "target": out_label_ids}

							def 			snake_case				(     self    ,   __a	):
										__lowerCAmelCase				    =			torch.stack([x["val_loss"] for x in outputs]	).mean().detach().cpu().item()
										__lowerCAmelCase				    =			np.concatenate([x["pred"] for x in outputs]    ,   axis=0	)

										if self.hparams.glue_output_mode == "classification":
													__lowerCAmelCase				    =			np.argmax(__a    ,   axis=1	)
										elif self.hparams.glue_output_mode == "regression":
													__lowerCAmelCase				    =			np.squeeze(__a	)

										__lowerCAmelCase				    =			np.concatenate([x["target"] for x in outputs]    ,   axis=0	)
										__lowerCAmelCase				    =			[[] for _ in range(out_label_ids.shape[0]	)]
										__lowerCAmelCase				    =			[[] for _ in range(out_label_ids.shape[0]	)]

										__lowerCAmelCase				    =			{**{"val_loss": val_loss_mean}, **compute_metrics(self.hparams.task    ,   __a    ,   __a	)}

										__lowerCAmelCase				    =			dict(results.items()	)
										__lowerCAmelCase				    =			results
										return ret, preds_list, out_label_list

							def 			snake_case				(     self    ,   __a	):
										__lowerCAmelCase    ,	__lowerCAmelCase    ,	__lowerCAmelCase				    =			self._eval_end(__a	)
										__lowerCAmelCase				    =			ret["log"]
										return {"val_loss": logs["val_loss"], "log": logs, "progress_bar": logs}

							def 			snake_case				(     self    ,   __a	):
										__lowerCAmelCase    ,	__lowerCAmelCase    ,	__lowerCAmelCase				    =			self._eval_end(__a	)
										__lowerCAmelCase				    =			ret["log"]
										# `val_loss` is the key returned by `self._eval_end()` but actually refers to `test_loss`
										return {"avg_test_loss": logs["val_loss"], "log": logs, "progress_bar": logs}



							@staticmethod
							def 			snake_case				(     __a    ,   __a	):
										BaseTransformer.add_model_specific_args(__a    ,   __a	)
										parser.add_argument(
										    "--max_seq_length"    ,   default=1_28    ,   type=__a    ,   help=(
										        "The maximum total input sequence length after tokenization. Sequences longer "
										        "than this will be truncated, sequences shorter will be padded."
										    )    ,   )

										parser.add_argument(
										    "--task"    ,   default=""    ,   type=__a    ,   required=__a    ,   help="The GLUE task to run"    ,   )
										parser.add_argument(
										    "--gpus"    ,   default=0    ,   type=__a    ,   help="The number of GPUs allocated for this, it is by default 0 meaning none"    ,   )

										parser.add_argument(
										    "--overwrite_cache"    ,   action="store_true"    ,   help="Overwrite the cached training and evaluation sets"	)

										return parser


def _lowerCamelCase	(		):

			'''simple docstring'''




			__lowerCAmelCase				    =			argparse.ArgumentParser()
			add_generic_args(_UpperCamelCase    , os.getcwd()      )
			__lowerCAmelCase				    =			GLUETransformer.add_model_specific_args(_UpperCamelCase    , os.getcwd()      )
			__lowerCAmelCase				    =			parser.parse_args()

			# If output_dir not provided, a folder will be generated in pwd
			if args.output_dir is None:
						__lowerCAmelCase				    =			os.path.join(
						    "./results"    , f"{args.task}_{time.strftime('%Y%m%d_%H%M%S'      )}"    , )
						os.makedirs(args.output_dir      )

			__lowerCAmelCase				    =			GLUETransformer(_UpperCamelCase      )
			__lowerCAmelCase				    =			generic_train(_UpperCamelCase    , _UpperCamelCase      )

			# Optionally, predict on dev set and write to output_dir
			if args.do_predict:
						__lowerCAmelCase				    =			sorted(glob.glob(os.path.join(args.output_dir    , "checkpoint-epoch=*.ckpt"      )    , recursive=_UpperCamelCase      )      )
						__lowerCAmelCase				    =			model.load_from_checkpoint(checkpoints[-1]      )
						return trainer.test(_UpperCamelCase      )


if __name__ == "__main__":
	main()











'''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 CLIPImageProcessor, CLIPProcessor






@require_vision
class    UpperCAmelCase	(       unittest.TestCase				):
 def      UpperCAmelCase_							(				self      :Optional[Any]							)->							Tuple:
     A__				=			tempfile.mkdtemp()

     # fmt: off
     A__				=			["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
     A__				=			dict(zip(lowercase_						,       range(len(lowercase_							)							)							)							)
     A__				=			["#version: 0.2", "l o", "lo w</w>", "e r</w>", ""]
     A__				=			{"unk_token": "<unk>"}

     A__				=			os.path.join(self.tmpdirname						,       VOCAB_FILES_NAMES["vocab_file"]							)
     A__				=			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(lowercase_							) + "\n"							)
     with open(self.merges_file						,       "w"						,       encoding="utf-8"							) as fp:
         fp.write("\n".join(lowercase_							)							)

     A__				=			{
         "do_resize": True,
         "size": 20,
         "do_center_crop": True,
         "crop_size": 18,
         "do_normalize": True,
         "image_mean": [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
         "image_std": [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
     }
     A__				=			os.path.join(self.tmpdirname						,       lowercase_							)
     with open(self.image_processor_file						,       "w"						,       encoding="utf-8"							) as fp:
         json.dump(lowercase_						,       lowercase_							)
 def      UpperCAmelCase_							(				self      :Any						,       **lowercase_      :Union[str, Any]							)->							Tuple:
     return CLIPTokenizer.from_pretrained(self.tmpdirname						,       **lowercase_							)
 def      UpperCAmelCase_							(				self      :Any						,       **lowercase_      :Tuple							)->							Dict:
     return CLIPTokenizerFast.from_pretrained(self.tmpdirname						,       **lowercase_							)
 def      UpperCAmelCase_							(				self      :Dict						,       **lowercase_      :Union[str, Any]							)->							Any:
     return CLIPImageProcessor.from_pretrained(self.tmpdirname						,       **lowercase_							)
 def      UpperCAmelCase_							(				self      :List[str]							)->							int:
     shutil.rmtree(self.tmpdirname							)
 def      UpperCAmelCase_							(				self      :Optional[int]							)->							Optional[int]:
     A__				=			[np.random.randint(2_55						,       size=(3, 30, 4_00)						,       dtype=np.uinta							)]

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

     return image_inputs
 def      UpperCAmelCase_							(				self      :int							)->							List[Any]:
     A__				=			self.get_tokenizer()
     A__				=			self.get_rust_tokenizer()
     A__				=			self.get_image_processor()

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)
     processor_slow.save_pretrained(self.tmpdirname							)
     A__				=			CLIPProcessor.from_pretrained(self.tmpdirname						,       use_fast=lowercase_							)

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)
     processor_fast.save_pretrained(self.tmpdirname							)
     A__				=			CLIPProcessor.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						,       lowercase_							)
     self.assertIsInstance(processor_fast.tokenizer						,       lowercase_							)

     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						,       lowercase_							)
     self.assertIsInstance(processor_fast.image_processor						,       lowercase_							)
 def      UpperCAmelCase_							(				self      :Optional[Any]							)->							Optional[int]:
     A__				=			CLIPProcessor(tokenizer=self.get_tokenizer()						,       image_processor=self.get_image_processor()							)
     processor.save_pretrained(self.tmpdirname							)

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

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

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

     self.assertEqual(processor.image_processor.to_json_string()						,       image_processor_add_kwargs.to_json_string()							)
     self.assertIsInstance(processor.image_processor						,       lowercase_							)
 def      UpperCAmelCase_							(				self      :List[Any]							)->							Tuple:
     A__				=			self.get_image_processor()
     A__				=			self.get_tokenizer()

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)

     A__				=			self.prepare_image_inputs()

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

     for key in input_image_proc.keys():
         self.assertAlmostEqual(input_image_proc[key].sum()						,       input_processor[key].sum()						,       delta=1E-2							)
 def      UpperCAmelCase_							(				self      :Optional[int]							)->							Dict:
     A__				=			self.get_image_processor()
     A__				=			self.get_tokenizer()

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)

     A__				=			"lower newer"

     A__				=			processor(text=lowercase_							)

     A__				=			tokenizer(lowercase_							)

     for key in encoded_tok.keys():
         self.assertListEqual(encoded_tok[key]						,       encoded_processor[key]							)
 def      UpperCAmelCase_							(				self      :str							)->							Any:
     A__				=			self.get_image_processor()
     A__				=			self.get_tokenizer()

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)

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

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

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

     # test if it raises when no input is passed
     with pytest.raises(lowercase_							):
         processor()
 def      UpperCAmelCase_							(				self      :Tuple							)->							Tuple:
     A__				=			self.get_image_processor()
     A__				=			self.get_tokenizer()

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)

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

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

     self.assertListEqual(lowercase_						,       lowercase_							)



 def      UpperCAmelCase_							(				self      :List[Any]							)->							Dict:
     A__				=			self.get_image_processor()
     A__				=			self.get_tokenizer()

     A__				=			CLIPProcessor(tokenizer=lowercase_						,       image_processor=lowercase_							)

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

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

     self.assertListEqual(list(inputs.keys()							)						,       processor.model_input_names							)



