






import os
from argparse import ArgumentParser, Namespace

from ..data import SingleSentenceClassificationProcessor as Processor
from ..pipelines import TextClassificationPipeline
from ..utils import is_tf_available, is_torch_available, logging
from . import BaseTransformersCLICommand


if not is_tf_available() and not is_torch_available():
			raise RuntimeError('''At least one of PyTorch or TensorFlow 2.0+ should be installed to use CLI training''')

# TF training parameters
UpperCAmelCase__      			=						False
UpperCAmelCase__      			=						False







def     a_   (__A      )				->						List[str]:



					"""simple docstring"""
					return TrainCommand(__A      )




class 							snake_case_       (    __UpperCamelCase      ):

						"""simple docstring"""



						@staticmethod
						def        UpperCAmelCase__					(__UpperCAmelCase:					ArgumentParser   )    ->     Union[str, Any]:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					parser.add_parser("train" ,					help="CLI tool to train a model on a task."   )

											train_parser.add_argument(
											    "--train_data" ,					type=__UpperCAmelCase ,					required=__UpperCAmelCase ,					help="path to train (and optionally evaluation) dataset as a csv with tab separated labels and sentences." ,					)
											train_parser.add_argument(
											    "--column_label" ,					type=__UpperCAmelCase ,					default=0 ,					help="Column of the dataset csv file with example labels."   )
											train_parser.add_argument(
											    "--column_text" ,					type=__UpperCAmelCase ,					default=1 ,					help="Column of the dataset csv file with example texts."   )
											train_parser.add_argument(
											    "--column_id" ,					type=__UpperCAmelCase ,					default=2 ,					help="Column of the dataset csv file with example ids."   )
											train_parser.add_argument(
											    "--skip_first_row" ,					action="store_true" ,					help="Skip the first row of the csv file (headers)."   )

											train_parser.add_argument("--validation_data" ,					type=__UpperCAmelCase ,					default="" ,					help="path to validation dataset."   )
											train_parser.add_argument(
											    "--validation_split" ,					type=__UpperCAmelCase ,					default=0.1 ,					help="if validation dataset is not provided, fraction of train dataset to use as validation dataset." ,					)

											train_parser.add_argument("--output" ,					type=__UpperCAmelCase ,					default="./" ,					help="path to saved the trained model."   )

											train_parser.add_argument(
											    "--task" ,					type=__UpperCAmelCase ,					default="text_classification" ,					help="Task to train the model on."   )
											train_parser.add_argument(
											    "--model" ,					type=__UpperCAmelCase ,					default="bert-base-uncased" ,					help="Model's name or path to stored model."   )
											train_parser.add_argument("--train_batch_size" ,					type=__UpperCAmelCase ,					default=32 ,					help="Batch size for training."   )
											train_parser.add_argument("--valid_batch_size" ,					type=__UpperCAmelCase ,					default=64 ,					help="Batch size for validation."   )
											train_parser.add_argument("--learning_rate" ,					type=__UpperCAmelCase ,					default=3E-5 ,					help="Learning rate."   )
											train_parser.add_argument("--adam_epsilon" ,					type=__UpperCAmelCase ,					default=1E-08 ,					help="Epsilon for Adam optimizer."   )
											train_parser.set_defaults(func=__UpperCAmelCase   )



						def __init__(self:					Optional[Any] ,					__UpperCAmelCase:					Namespace   )    ->     int:




											'''simple docstring'''



											__a					:						List[Any]      =					logging.get_logger("transformers-cli/training"   )

											__a					:						Optional[int]      =					"tf" if is_tf_available() else "torch"

											os.makedirs(args.output ,					exist_ok=__UpperCAmelCase   )
											__a					:						Union[str, Any]      =					args.output

											__a					:						List[Any]      =					args.column_label
											__a					:						Optional[int]      =					args.column_text
											__a					:						int      =					args.column_id

											self.logger.info(f'Loading {args.task} pipeline for {args.model}'   )
											if args.task == "text_classification":
																__a					:						Optional[Any]      =					TextClassificationPipeline.from_pretrained(args.model   )
											elif args.task == "token_classification":
																raise NotImplementedError
											elif args.task == "question_answering":
																raise NotImplementedError

											self.logger.info(f'Loading dataset from {args.train_data}'   )
											__a					:						List[str]      =					Processor.create_from_csv(
											    args.train_data ,					column_label=args.column_label ,					column_text=args.column_text ,					column_id=args.column_id ,					skip_first_row=args.skip_first_row ,					)
											__a					:						str      =					None
											if args.validation_data:
																self.logger.info(f'Loading validation dataset from {args.validation_data}'   )
																__a					:						List[str]      =					Processor.create_from_csv(
																    args.validation_data ,					column_label=args.column_label ,					column_text=args.column_text ,					column_id=args.column_id ,					skip_first_row=args.skip_first_row ,					)

											__a					:						Any      =					args.validation_split
											__a					:						Optional[int]      =					args.train_batch_size
											__a					:						Tuple      =					args.valid_batch_size
											__a					:						str      =					args.learning_rate
											__a					:						int      =					args.adam_epsilon



						def        UpperCAmelCase__					(self:					int   )    ->     Tuple:




											'''simple docstring'''



											if self.framework == "tf":
																return self.run_tf()
											return self.run_torch()



						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     Union[str, Any]:




											'''simple docstring'''



											raise NotImplementedError



						def        UpperCAmelCase__					(self:					List[Any]   )    ->     Optional[int]:




											'''simple docstring'''



											self.pipeline.fit(
											    self.train_dataset ,					validation_data=self.valid_dataset ,					validation_split=self.validation_split ,					learning_rate=self.learning_rate ,					adam_epsilon=self.adam_epsilon ,					train_batch_size=self.train_batch_size ,					valid_batch_size=self.valid_batch_size ,					)

											# Save trained pipeline
											self.pipeline.save_pretrained(self.output   )













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 OwlViTImageProcessor, OwlViTProcessor




@require_vision
class 							snake_case_       (    unittest.TestCase      ):

						"""simple docstring"""



						def        UpperCAmelCase__					(self:					int   )    ->     str:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					tempfile.mkdtemp()

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

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

											__a					:						str      =					{
											    "do_resize": True,
											    "size": 20,
											    "do_center_crop": True,
											    "crop_size": 18,
											    "do_normalize": True,
											    "image_mean": [0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73],
											    "image_std": [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11],
											}
											__a					:						Any      =					os.path.join(self.tmpdirname ,					__UpperCAmelCase   )
											with open(self.image_processor_file ,					"w" ,					encoding="utf-8"   ) as fp:
																json.dump(__UpperCAmelCase ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Tuple ,					**__UpperCAmelCase:					Dict   )    ->     List[str]:




											'''simple docstring'''



											return CLIPTokenizer.from_pretrained(self.tmpdirname ,					pad_token="!" ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Optional[Any] ,					**__UpperCAmelCase:					int   )    ->     Any:




											'''simple docstring'''



											return CLIPTokenizerFast.from_pretrained(self.tmpdirname ,					pad_token="!" ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					List[Any] ,					**__UpperCAmelCase:					Dict   )    ->     Optional[int]:




											'''simple docstring'''



											return OwlViTImageProcessor.from_pretrained(self.tmpdirname ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					str   )    ->     int:




											'''simple docstring'''



											shutil.rmtree(self.tmpdirname   )



						def        UpperCAmelCase__					(self:					Dict   )    ->     Union[str, Any]:




											'''simple docstring'''



											__a					:						Dict      =					[np.random.randint(255 ,					size=(3, 30, 400) ,					dtype=np.uinta   )]

											__a					:						Any      =					[Image.fromarray(np.moveaxis(__UpperCAmelCase ,					0 ,					-1   )   ) for x in image_inputs]

											return image_inputs



						def        UpperCAmelCase__					(self:					Tuple   )    ->     Optional[Any]:




											'''simple docstring'''



											__a					:						Dict      =					self.get_tokenizer()
											__a					:						Dict      =					self.get_rust_tokenizer()
											__a					:						List[str]      =					self.get_image_processor()

											__a					:						Any      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )
											processor_slow.save_pretrained(self.tmpdirname   )
											__a					:						str      =					OwlViTProcessor.from_pretrained(self.tmpdirname ,					use_fast=__UpperCAmelCase   )

											__a					:						Union[str, Any]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )
											processor_fast.save_pretrained(self.tmpdirname   )
											__a					:						List[Any]      =					OwlViTProcessor.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 ,					__UpperCAmelCase   )
											self.assertIsInstance(processor_fast.tokenizer ,					__UpperCAmelCase   )

											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 ,					__UpperCAmelCase   )
											self.assertIsInstance(processor_fast.image_processor ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					str   )    ->     Dict:




											'''simple docstring'''



											__a					:						Tuple      =					OwlViTProcessor(tokenizer=self.get_tokenizer() ,					image_processor=self.get_image_processor()   )
											processor.save_pretrained(self.tmpdirname   )

											__a					:						Optional[Any]      =					self.get_tokenizer(bos_token="(BOS)" ,					eos_token="(EOS)"   )
											__a					:						str      =					self.get_image_processor(do_normalize=__UpperCAmelCase   )

											__a					:						str      =					OwlViTProcessor.from_pretrained(
											    self.tmpdirname ,					bos_token="(BOS)" ,					eos_token="(EOS)" ,					do_normalize=__UpperCAmelCase   )

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

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



						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     Dict:




											'''simple docstring'''



											__a					:						Optional[Any]      =					self.get_image_processor()
											__a					:						str      =					self.get_tokenizer()

											__a					:						List[str]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						List[str]      =					self.prepare_image_inputs()

											__a					:						Optional[Any]      =					image_processor(__UpperCAmelCase ,					return_tensors="np"   )
											__a					:						int      =					processor(images=__UpperCAmelCase ,					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:					Dict   )    ->     Optional[int]:




											'''simple docstring'''



											__a					:						int      =					self.get_image_processor()
											__a					:						Tuple      =					self.get_tokenizer()

											__a					:						Optional[int]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						Dict      =					"lower newer"

											__a					:						Any      =					processor(text=__UpperCAmelCase ,					return_tensors="np"   )

											__a					:						List[str]      =					tokenizer(__UpperCAmelCase ,					return_tensors="np"   )

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



						def        UpperCAmelCase__					(self:					List[Any]   )    ->     Dict:




											'''simple docstring'''



											__a					:						Dict      =					self.get_image_processor()
											__a					:						List[str]      =					self.get_tokenizer()

											__a					:						Optional[Any]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						Optional[int]      =					"lower newer"
											__a					:						int      =					self.prepare_image_inputs()

											__a					:						Optional[int]      =					processor(text=__UpperCAmelCase ,					images=__UpperCAmelCase   )

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

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



						def        UpperCAmelCase__					(self:					int   )    ->     Union[str, Any]:




											'''simple docstring'''



											__a					:						Dict      =					"google/owlvit-base-patch32"
											__a					:						Dict      =					OwlViTProcessor.from_pretrained(__UpperCAmelCase   )

											__a					:						List[str]      =					["cat", "nasa badge"]
											__a					:						List[Any]      =					processor(text=__UpperCAmelCase   )

											__a					:						Any      =					16
											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask"]   )
											self.assertEqual(inputs["input_ids"].shape ,					(2, seq_length)   )

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



						def        UpperCAmelCase__					(self:					Any   )    ->     Optional[int]:




											'''simple docstring'''



											__a					:						Optional[int]      =					"google/owlvit-base-patch32"
											__a					:						Optional[int]      =					OwlViTProcessor.from_pretrained(__UpperCAmelCase   )

											__a					:						Tuple      =					[["cat", "nasa badge"], ["person"]]
											__a					:						List[Any]      =					processor(text=__UpperCAmelCase   )

											__a					:						Tuple      =					16
											__a					:						Optional[Any]      =					len(__UpperCAmelCase   )
											__a					:						Optional[Any]      =					max([len(__UpperCAmelCase   ) for texts in input_texts]   )

											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask"]   )
											self.assertEqual(inputs["input_ids"].shape ,					(batch_size * num_max_text_queries, seq_length)   )

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



						def        UpperCAmelCase__					(self:					Tuple   )    ->     Dict:




											'''simple docstring'''



											__a					:						int      =					"google/owlvit-base-patch32"
											__a					:						Dict      =					OwlViTProcessor.from_pretrained(__UpperCAmelCase   )

											__a					:						List[str]      =					["cat", "nasa badge"]
											__a					:						List[Any]      =					processor(text=__UpperCAmelCase   )

											__a					:						int      =					16
											__a					:						Union[str, Any]      =					inputs["input_ids"]
											__a					:						Optional[int]      =					[
											    [49406, 2368, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
											    [49406, 6841, 11301, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
											]

											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask"]   )
											self.assertEqual(inputs["input_ids"].shape ,					(2, seq_length)   )
											self.assertListEqual(list(input_ids[0]   ) ,					predicted_ids[0]   )
											self.assertListEqual(list(input_ids[1]   ) ,					predicted_ids[1]   )



						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     List[Any]:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					self.get_image_processor()
											__a					:						List[str]      =					self.get_tokenizer()

											__a					:						Tuple      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						str      =					self.prepare_image_inputs()
											__a					:						Any      =					self.prepare_image_inputs()

											__a					:						str      =					processor(images=__UpperCAmelCase ,					query_images=__UpperCAmelCase   )

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

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



						def        UpperCAmelCase__					(self:					Any   )    ->     Tuple:




											'''simple docstring'''



											__a					:						int      =					self.get_image_processor()
											__a					:						Tuple      =					self.get_tokenizer()

											__a					:						Optional[int]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						List[str]      =					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

											__a					:						Tuple      =					processor.batch_decode(__UpperCAmelCase   )
											__a					:						str      =					tokenizer.batch_decode(__UpperCAmelCase   )

											self.assertListEqual(__UpperCAmelCase ,					__UpperCAmelCase   )





