



import logging
import os
from dataclasses import dataclass, field
from typing import Dict, Optional

import datasets
import numpy as np
import tensorflow as tf

from transformers import (
    AutoConfig,
    AutoTokenizer,
    EvalPrediction,
    HfArgumentParser,
    PreTrainedTokenizer,
    TFAutoModelForSequenceClassification,
    TFTrainer,
    TFTrainingArguments,
)
from transformers.utils import logging as hf_logging


hf_logging.set_verbosity_info()
hf_logging.enable_default_handler()
hf_logging.enable_explicit_format()







def     UpperCAmelCase_		(					snake_case__    ,			snake_case__    ,			snake_case__    ,			snake_case__    ,			snake_case__    ,			snake_case__ = None    ,			)	->     Optional[int]:



				"""simple docstring"""





				lowerCAmelCase__		  =  {}

				if train_file is not None:
								lowerCAmelCase__		  =  [train_file]
				if eval_file is not None:
								lowerCAmelCase__		  =  [eval_file]
				if test_file is not None:
								lowerCAmelCase__		  =  [test_file]

				lowerCAmelCase__		  =  datasets.load_dataset('csv'    ,			data_files=A__					)
				lowerCAmelCase__		  =  list(ds[list(files.keys()					)[0]].features.keys()					)
				lowerCAmelCase__		  =  features_name.pop(A__					)
				lowerCAmelCase__		  =  list(set(ds[list(files.keys()					)[0]][label_name]					)					)
				lowerCAmelCase__		  =  {label: i for i, label in enumerate(A__					)}
				lowerCAmelCase__		  =  tokenizer.model_input_names
				lowerCAmelCase__		  =  {}

				if len(A__					) == 1:
								for k in files.keys():
												lowerCAmelCase__		  =  ds[k].map(
												    lambda snake_case__					: tokenizer.batch_encode_plus(
												        example[features_name[0]]    ,			truncation=A__    ,			max_length=A__    ,			padding='max_length'					)    ,			batched=A__    ,			)
				elif len(A__					) == 2:
								for k in files.keys():
												lowerCAmelCase__		  =  ds[k].map(
												    lambda snake_case__					: tokenizer.batch_encode_plus(
												        (example[features_name[0]], example[features_name[1]])    ,			truncation=A__    ,			max_length=A__    ,			padding='max_length'    ,			)    ,			batched=A__    ,			)

				def gen_train():
								for ex in transformed_ds[datasets.Split.TRAIN]:
												lowerCAmelCase__		  =  {k: v for k, v in ex.items() if k in input_names}
												lowerCAmelCase__		  =  labelaid[ex[label_name]]
												yield (d, label)

				def gen_val():
								for ex in transformed_ds[datasets.Split.VALIDATION]:
												lowerCAmelCase__		  =  {k: v for k, v in ex.items() if k in input_names}
												lowerCAmelCase__		  =  labelaid[ex[label_name]]
												yield (d, label)

				def gen_test():
								for ex in transformed_ds[datasets.Split.TEST]:
												lowerCAmelCase__		  =  {k: v for k, v in ex.items() if k in input_names}
												lowerCAmelCase__		  =  labelaid[ex[label_name]]
												yield (d, label)

				lowerCAmelCase__		  =  (
				    tf.data.Dataset.from_generator(
				        A__    ,			({k: tf.intaa for k in input_names}, tf.intaa)    ,			({k: tf.TensorShape([None]					) for k in input_names}, tf.TensorShape([]					))    ,			)
				    if datasets.Split.TRAIN in transformed_ds
				    else None
				)

				if train_ds is not None:
								lowerCAmelCase__		  =  train_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TRAIN]					)					)					)

				lowerCAmelCase__		  =  (
				    tf.data.Dataset.from_generator(
				        A__    ,			({k: tf.intaa for k in input_names}, tf.intaa)    ,			({k: tf.TensorShape([None]					) for k in input_names}, tf.TensorShape([]					))    ,			)
				    if datasets.Split.VALIDATION in transformed_ds
				    else None
				)

				if val_ds is not None:
								lowerCAmelCase__		  =  val_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.VALIDATION]					)					)					)

				lowerCAmelCase__		  =  (
				    tf.data.Dataset.from_generator(
				        A__    ,			({k: tf.intaa for k in input_names}, tf.intaa)    ,			({k: tf.TensorShape([None]					) for k in input_names}, tf.TensorShape([]					))    ,			)
				    if datasets.Split.TEST in transformed_ds
				    else None
				)

				if test_ds is not None:
								lowerCAmelCase__		  =  test_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TEST]					)					)					)

				return train_ds, val_ds, test_ds, labelaid


_lowerCAmelCase	:   Union[str, Any]    =   logging.getLogger(__name__)


@dataclass
class 	__snake_case   :
		SCREAMING_SNAKE_CASE__								=	field(metadata={'help': 'Which column contains the label'} )
		SCREAMING_SNAKE_CASE__								=	field(default=__SCREAMING_SNAKE_CASE							, metadata={'help': 'The path of the training file'} )
		SCREAMING_SNAKE_CASE__								=	field(default=__SCREAMING_SNAKE_CASE							, metadata={'help': 'The path of the development file'} )
		SCREAMING_SNAKE_CASE__								=	field(default=__SCREAMING_SNAKE_CASE							, metadata={'help': 'The path of the test file'} )
		SCREAMING_SNAKE_CASE__								=	field(
		    default=128							, metadata={
		        'help': (
		            'The maximum total input sequence length after tokenization. Sequences longer '
		            'than this will be truncated, sequences shorter will be padded.'
		        )
		    }							, )
		SCREAMING_SNAKE_CASE__								=	field(
		    default=__SCREAMING_SNAKE_CASE							, metadata={'help': 'Overwrite the cached training and evaluation sets'} )



@dataclass
class 	__snake_case   :
		SCREAMING_SNAKE_CASE__								=	field(
		    metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'} )
		SCREAMING_SNAKE_CASE__								=	field(
		    default=__SCREAMING_SNAKE_CASE							, metadata={'help': 'Pretrained config name or path if not the same as model_name'} )
		SCREAMING_SNAKE_CASE__								=	field(
		    default=__SCREAMING_SNAKE_CASE							, metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'} )
		SCREAMING_SNAKE_CASE__								=	field(default=__SCREAMING_SNAKE_CASE							, metadata={'help': 'Set this flag to use fast tokenization.'} )
		# If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
		# or just modify its tokenizer_config.json.
		SCREAMING_SNAKE_CASE__								=	field(
		    default=__SCREAMING_SNAKE_CASE							, metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'}							, )







def     UpperCAmelCase_		(					)	->     List[Any]:



				"""simple docstring"""





				lowerCAmelCase__		  =  HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments)					)
				lowerCAmelCase__		  =  parser.parse_args_into_dataclasses()

				if (
				    os.path.exists(training_args.output_dir					)
				    and os.listdir(training_args.output_dir					)
				    and training_args.do_train
				    and not training_args.overwrite_output_dir
				):
								raise ValueError(
								    f'Output directory ({training_args.output_dir}) already exists and is not empty. Use'
								    ' --overwrite_output_dir to overcome.'					)

				# Setup logging
				logging.basicConfig(
				    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s'    ,			datefmt='%m/%d/%Y %H:%M:%S'    ,			level=logging.INFO    ,			)
				logger.info(
				    f'n_replicas: {training_args.n_replicas}, distributed training: {bool(training_args.n_replicas > 1					)}, '
				    f'16-bits training: {training_args.fpaa}'					)
				logger.info(f'Training/evaluation parameters {training_args}'					)

				# Load pretrained model and tokenizer
				#
				# Distributed training:
				# The .from_pretrained methods guarantee that only one local process can concurrently
				# download model & vocab.

				lowerCAmelCase__		  =  AutoTokenizer.from_pretrained(
				    model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path    ,			cache_dir=model_args.cache_dir    ,			)

				lowerCAmelCase__		  =  get_tfds(
				    train_file=data_args.train_file    ,			eval_file=data_args.dev_file    ,			test_file=data_args.test_file    ,			tokenizer=A__    ,			label_column_id=data_args.label_column_id    ,			max_seq_length=data_args.max_seq_length    ,			)

				lowerCAmelCase__		  =  AutoConfig.from_pretrained(
				    model_args.config_name if model_args.config_name else model_args.model_name_or_path    ,			num_labels=len(A__					)    ,			labelaid=A__    ,			idalabel={id: label for label, id in labelaid.items()}    ,			finetuning_task='text-classification'    ,			cache_dir=model_args.cache_dir    ,			)

				with training_args.strategy.scope():
								lowerCAmelCase__		  =  TFAutoModelForSequenceClassification.from_pretrained(
								    model_args.model_name_or_path    ,			from_pt=bool('.bin' in model_args.model_name_or_path					)    ,			config=A__    ,			cache_dir=model_args.cache_dir    ,			)

				def compute_metrics(snake_case__					) -> Dict:
								lowerCAmelCase__		  =  np.argmax(p.predictions    ,			axis=1					)

								return {"acc": (preds == p.label_ids).mean()}

				# Initialize our Trainer
				lowerCAmelCase__		  =  TFTrainer(
				    model=A__    ,			args=A__    ,			train_dataset=A__    ,			eval_dataset=A__    ,			compute_metrics=A__    ,			)

				# Training
				if training_args.do_train:
								trainer.train()
								trainer.save_model()
								tokenizer.save_pretrained(training_args.output_dir					)

				# Evaluation
				lowerCAmelCase__		  =  {}
				if training_args.do_eval:
								logger.info('*** Evaluate ***'					)
								lowerCAmelCase__		  =  trainer.evaluate()
								lowerCAmelCase__		  =  os.path.join(training_args.output_dir    ,			'eval_results.txt'					)

								with open(A__    ,			'w'					) as writer:
												logger.info('***** Eval results *****'					)

												for key, value in result.items():
																logger.info(f'  {key} = {value}'					)
																writer.write(f'{key} = {value}\n'					)

												results.update(A__					)

				return results


if __name__ == "__main__":
	main()




import unittest

from transformers import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING, is_vision_available, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
				from PIL import Image
else:







				class 	__lowercase    :





											"""simple docstring"""







											@staticmethod
											def 					UpperCamelCase__     (      *lowerCAmelCase__			,						**lowerCAmelCase__       ):





														"""simple docstring"""




														pass







@is_pipeline_test
@require_vision
@require_torch
class 	__lowercase    (unittest.TestCase  ):





							"""simple docstring"""







							_UpperCAmelCase      =						MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     List[str]					=					pipeline(
										    'zero-shot-object-detection'			,						model='hf-internal-testing/tiny-random-owlvit-object-detection'       )

										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					[
										    {
										        'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
										        'candidate_labels': ['cat', 'remote', 'couch'],
										    }
										]
										return object_detector, examples






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__			,						lowerCAmelCase__       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					object_detector(examples[0]			,						threshold=0.0       )

										SCREAMING_SNAKE_CASE_		:     int					=					len(lowerCAmelCase__       )
										self.assertGreater(lowerCAmelCase__			,						0       )
										self.assertEqual(
										    lowerCAmelCase__			,						[
										        {
										            'score': ANY(lowerCAmelCase__       ),
										            'label': ANY(lowerCAmelCase__       ),
										            'box': {'xmin': ANY(lowerCAmelCase__       ), 'ymin': ANY(lowerCAmelCase__       ), 'xmax': ANY(lowerCAmelCase__       ), 'ymax': ANY(lowerCAmelCase__       )},
										        }
										        for i in range(lowerCAmelCase__       )
										    ]			,						)






							@require_tf
							@unittest.skip('Zero Shot Object Detection not implemented in TF'       )
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										pass






							@require_torch
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     List[Any]					=					pipeline(
										    'zero-shot-object-detection'			,						model='hf-internal-testing/tiny-random-owlvit-object-detection'       )

										SCREAMING_SNAKE_CASE_		:     str					=					object_detector(
										    './tests/fixtures/tests_samples/COCO/000000039769.png'			,						candidate_labels=['cat', 'remote', 'couch']			,						threshold=0.64			,						)

										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,						decimals=4       )			,						[
										        {'score': 0.7_235, 'label': 'cat', 'box': {'xmin': 2_0_4, 'ymin': 1_6_7, 'xmax': 2_3_2, 'ymax': 1_9_0}},
										        {'score': 0.7_218, 'label': 'remote', 'box': {'xmin': 2_0_4, 'ymin': 1_6_7, 'xmax': 2_3_2, 'ymax': 1_9_0}},
										        {'score': 0.7_184, 'label': 'couch', 'box': {'xmin': 2_0_4, 'ymin': 1_6_7, 'xmax': 2_3_2, 'ymax': 1_9_0}},
										        {'score': 0.6_748, 'label': 'remote', 'box': {'xmin': 5_7_1, 'ymin': 8_3, 'xmax': 5_9_8, 'ymax': 1_0_3}},
										        {'score': 0.6_656, 'label': 'cat', 'box': {'xmin': 5_7_1, 'ymin': 8_3, 'xmax': 5_9_8, 'ymax': 1_0_3}},
										        {'score': 0.6_614, 'label': 'couch', 'box': {'xmin': 5_7_1, 'ymin': 8_3, 'xmax': 5_9_8, 'ymax': 1_0_3}},
										        {'score': 0.6_456, 'label': 'remote', 'box': {'xmin': 4_9_4, 'ymin': 1_0_5, 'xmax': 5_2_1, 'ymax': 1_2_7}},
										        {'score': 0.642, 'label': 'remote', 'box': {'xmin': 6_7, 'ymin': 2_7_4, 'xmax': 9_3, 'ymax': 2_9_7}},
										        {'score': 0.6_419, 'label': 'cat', 'box': {'xmin': 4_9_4, 'ymin': 1_0_5, 'xmax': 5_2_1, 'ymax': 1_2_7}},
										    ]			,						)

										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					object_detector(
										    [
										        {
										            'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
										            'candidate_labels': ['cat', 'remote', 'couch'],
										        }
										    ]			,						threshold=0.64			,						)

										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,						decimals=4       )			,						[
										        [
										            {'score': 0.7_235, 'label': 'cat', 'box': {'xmin': 2_0_4, 'ymin': 1_6_7, 'xmax': 2_3_2, 'ymax': 1_9_0}},
										            {'score': 0.7_218, 'label': 'remote', 'box': {'xmin': 2_0_4, 'ymin': 1_6_7, 'xmax': 2_3_2, 'ymax': 1_9_0}},
										            {'score': 0.7_184, 'label': 'couch', 'box': {'xmin': 2_0_4, 'ymin': 1_6_7, 'xmax': 2_3_2, 'ymax': 1_9_0}},
										            {'score': 0.6_748, 'label': 'remote', 'box': {'xmin': 5_7_1, 'ymin': 8_3, 'xmax': 5_9_8, 'ymax': 1_0_3}},
										            {'score': 0.6_656, 'label': 'cat', 'box': {'xmin': 5_7_1, 'ymin': 8_3, 'xmax': 5_9_8, 'ymax': 1_0_3}},
										            {'score': 0.6_614, 'label': 'couch', 'box': {'xmin': 5_7_1, 'ymin': 8_3, 'xmax': 5_9_8, 'ymax': 1_0_3}},
										            {'score': 0.6_456, 'label': 'remote', 'box': {'xmin': 4_9_4, 'ymin': 1_0_5, 'xmax': 5_2_1, 'ymax': 1_2_7}},
										            {'score': 0.642, 'label': 'remote', 'box': {'xmin': 6_7, 'ymin': 2_7_4, 'xmax': 9_3, 'ymax': 2_9_7}},
										            {'score': 0.6_419, 'label': 'cat', 'box': {'xmin': 4_9_4, 'ymin': 1_0_5, 'xmax': 5_2_1, 'ymax': 1_2_7}},
										        ]
										    ]			,						)






							@require_torch
							@slow
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     List[str]					=					pipeline('zero-shot-object-detection'       )

										SCREAMING_SNAKE_CASE_		:     List[str]					=					object_detector(
										    'http://images.cocodataset.org/val2017/000000039769.jpg'			,						candidate_labels=['cat', 'remote', 'couch']			,						)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,						decimals=4       )			,						[
										        {'score': 0.2_868, 'label': 'cat', 'box': {'xmin': 3_2_4, 'ymin': 2_0, 'xmax': 6_4_0, 'ymax': 3_7_3}},
										        {'score': 0.277, 'label': 'remote', 'box': {'xmin': 4_0, 'ymin': 7_2, 'xmax': 1_7_7, 'ymax': 1_1_5}},
										        {'score': 0.2_537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 5_5, 'xmax': 3_1_5, 'ymax': 4_7_2}},
										        {'score': 0.1_474, 'label': 'remote', 'box': {'xmin': 3_3_5, 'ymin': 7_4, 'xmax': 3_7_1, 'ymax': 1_8_7}},
										        {'score': 0.1_208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_4_2, 'ymax': 4_7_6}},
										    ]			,						)

										SCREAMING_SNAKE_CASE_		:     List[Any]					=					object_detector(
										    [
										        {
										            'image': 'http://images.cocodataset.org/val2017/000000039769.jpg',
										            'candidate_labels': ['cat', 'remote', 'couch'],
										        },
										        {
										            'image': 'http://images.cocodataset.org/val2017/000000039769.jpg',
										            'candidate_labels': ['cat', 'remote', 'couch'],
										        },
										    ]			,						)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,						decimals=4       )			,						[
										        [
										            {'score': 0.2_868, 'label': 'cat', 'box': {'xmin': 3_2_4, 'ymin': 2_0, 'xmax': 6_4_0, 'ymax': 3_7_3}},
										            {'score': 0.277, 'label': 'remote', 'box': {'xmin': 4_0, 'ymin': 7_2, 'xmax': 1_7_7, 'ymax': 1_1_5}},
										            {'score': 0.2_537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 5_5, 'xmax': 3_1_5, 'ymax': 4_7_2}},
										            {'score': 0.1_474, 'label': 'remote', 'box': {'xmin': 3_3_5, 'ymin': 7_4, 'xmax': 3_7_1, 'ymax': 1_8_7}},
										            {'score': 0.1_208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_4_2, 'ymax': 4_7_6}},
										        ],
										        [
										            {'score': 0.2_868, 'label': 'cat', 'box': {'xmin': 3_2_4, 'ymin': 2_0, 'xmax': 6_4_0, 'ymax': 3_7_3}},
										            {'score': 0.277, 'label': 'remote', 'box': {'xmin': 4_0, 'ymin': 7_2, 'xmax': 1_7_7, 'ymax': 1_1_5}},
										            {'score': 0.2_537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 5_5, 'xmax': 3_1_5, 'ymax': 4_7_2}},
										            {'score': 0.1_474, 'label': 'remote', 'box': {'xmin': 3_3_5, 'ymin': 7_4, 'xmax': 3_7_1, 'ymax': 1_8_7}},
										            {'score': 0.1_208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_4_2, 'ymax': 4_7_6}},
										        ],
										    ]			,						)






							@require_tf
							@unittest.skip('Zero Shot Object Detection not implemented in TF'       )
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										pass






							@require_torch
							@slow
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     str					=					0.2
										SCREAMING_SNAKE_CASE_		:     str					=					pipeline('zero-shot-object-detection'       )

										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					object_detector(
										    'http://images.cocodataset.org/val2017/000000039769.jpg'			,						candidate_labels=['cat', 'remote', 'couch']			,						threshold=lowerCAmelCase__			,						)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,						decimals=4       )			,						[
										        {'score': 0.2_868, 'label': 'cat', 'box': {'xmin': 3_2_4, 'ymin': 2_0, 'xmax': 6_4_0, 'ymax': 3_7_3}},
										        {'score': 0.277, 'label': 'remote', 'box': {'xmin': 4_0, 'ymin': 7_2, 'xmax': 1_7_7, 'ymax': 1_1_5}},
										        {'score': 0.2_537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 5_5, 'xmax': 3_1_5, 'ymax': 4_7_2}},
										    ]			,						)






							@require_torch
							@slow
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Dict					=					2
										SCREAMING_SNAKE_CASE_		:     int					=					pipeline('zero-shot-object-detection'       )

										SCREAMING_SNAKE_CASE_		:     Tuple					=					object_detector(
										    'http://images.cocodataset.org/val2017/000000039769.jpg'			,						candidate_labels=['cat', 'remote', 'couch']			,						top_k=lowerCAmelCase__			,						)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,						decimals=4       )			,						[
										        {'score': 0.2_868, 'label': 'cat', 'box': {'xmin': 3_2_4, 'ymin': 2_0, 'xmax': 6_4_0, 'ymax': 3_7_3}},
										        {'score': 0.277, 'label': 'remote', 'box': {'xmin': 4_0, 'ymin': 7_2, 'xmax': 1_7_7, 'ymax': 1_1_5}},
										    ]			,						)





