




"""simple docstring"""

import argparse
import logging
import os
import sys
import time

import tensorflow as tf
from datasets import load_dataset
from tqdm import tqdm

from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
from transformers.utils import is_sagemaker_dp_enabled


if os.environ.get('SDP_ENABLED') or is_sagemaker_dp_enabled():
		_lowerCamelCase	:      Any   =							True
		_lowerCamelCase	:      Optional[int]   =							'p3dn.24xlarge'
		import smdistributed.dataparallel.tensorflow as sdp
else:
		_lowerCamelCase	:      List[str]   =							False

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase=None						):




	"""simple docstring"""






	A_	:					Dict						 =		tqdm(_UpperCAmelCase						)
	for i, batch in enumerate(_UpperCAmelCase						):
		with tf.GradientTape() as tape:
			A_ ,			A_	:					Optional[int]						 =		batch
			A_	:					Optional[Any]						 =		model(_UpperCAmelCase						)
			A_	:					List[Any]						 =		loss(_UpperCAmelCase	,   outputs.logits						)

		if SDP_ENABLED:
			A_	:					int						 =		sdp.DistributedGradientTape(_UpperCAmelCase	,   sparse_as_dense=_UpperCAmelCase						)

		A_	:					int						 =		tape.gradient(_UpperCAmelCase	,   model.trainable_variables						)
		opt.apply_gradients(zip(_UpperCAmelCase	,   model.trainable_variables						)						)

		pbar.set_description(f"""Loss: {loss_value:.4f}"""						)

		if SDP_ENABLED and i == 0:
			sdp.broadcast_variables(model.variables	,   root_rank=0						)
			sdp.broadcast_variables(opt.variables()	,   root_rank=0						)

		if max_steps and i >= max_steps:
			break

	A_	:					List[Any]						 =		{'''loss''': loss_value.numpy()}
	return train_results

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase						):




	"""simple docstring"""






	A_ ,			A_	:					Optional[int]						 =		load_dataset('''imdb'''	,   split=['''train''', '''test''']						)

	# Preprocess train dataset
	A_	:					str						 =		train_dataset.map(
	    lambda _UpperCAmelCase						: tokenizer(e['''text''']	,   truncation=_UpperCAmelCase	,   padding='''max_length'''						)	,   batched=_UpperCAmelCase						)
	train_dataset.set_format(type='''tensorflow'''	,   columns=['''input_ids''', '''attention_mask''', '''label''']						)

	A_	:					List[str]						 =		{
	    x: train_dataset[x].to_tensor(default_value=0	,   shape=[None, tokenizer.model_max_length]						)
	    for x in ['''input_ids''', '''attention_mask''']
	}
	A_	:					Optional[int]						 =		tf.data.Dataset.from_tensor_slices((train_features, train_dataset['''label'''])						)

	# Preprocess test dataset
	A_	:					int						 =		test_dataset.map(
	    lambda _UpperCAmelCase						: tokenizer(e['''text''']	,   truncation=_UpperCAmelCase	,   padding='''max_length'''						)	,   batched=_UpperCAmelCase						)
	test_dataset.set_format(type='''tensorflow'''	,   columns=['''input_ids''', '''attention_mask''', '''label''']						)

	A_	:					Optional[Any]						 =		{
	    x: test_dataset[x].to_tensor(default_value=0	,   shape=[None, tokenizer.model_max_length]						)
	    for x in ['''input_ids''', '''attention_mask''']
	}
	A_	:					Optional[Any]						 =		tf.data.Dataset.from_tensor_slices((test_features, test_dataset['''label'''])						)

	if SDP_ENABLED:
		A_	:					Union[str, Any]						 =		tf_train_dataset.shard(sdp.size()	,   sdp.rank()						)
		A_	:					Any						 =		tf_test_dataset.shard(sdp.size()	,   sdp.rank()						)
	A_	:					List[str]						 =		tf_train_dataset.batch(_UpperCAmelCase	,   drop_remainder=_UpperCAmelCase						)
	A_	:					List[str]						 =		tf_test_dataset.batch(_UpperCAmelCase	,   drop_remainder=_UpperCAmelCase						)

	return tf_train_dataset, tf_test_dataset


if __name__ == "__main__":
		_lowerCamelCase	:      Dict   =							argparse.ArgumentParser()

		# Hyperparameters sent by the client are passed as command-line arguments to the script.
		parser.add_argument('--epochs', type=int, default=3)
		parser.add_argument('--per_device_train_batch_size', type=int, default=16)
		parser.add_argument('--per_device_eval_batch_size', type=int, default=8)
		parser.add_argument('--model_name_or_path', type=str)
		parser.add_argument('--learning_rate', type=str, default=5E-5)
		parser.add_argument('--do_train', type=bool, default=True)
		parser.add_argument('--do_eval', type=bool, default=True)
		parser.add_argument('--output_dir', type=str)
		parser.add_argument('--max_steps', type=int, default=None)

		# Data, model, and output directories
		parser.add_argument('--output_data_dir', type=str, default=os.environ['SM_OUTPUT_DATA_DIR'])
		parser.add_argument('--model_dir', type=str, default=os.environ['SM_MODEL_DIR'])
		parser.add_argument('--n_gpus', type=str, default=os.environ['SM_NUM_GPUS'])

		_lowerCamelCase  ,    _lowerCamelCase	:      Union[str, Any]   =							parser.parse_known_args()

		# Set up logging
		_lowerCamelCase	:      Any   =							logging.getLogger(__name__)

		logging.basicConfig(
		    level=logging.getLevelName('INFO'),
		    handlers=[logging.StreamHandler(sys.stdout)],
		    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
		)

		if SDP_ENABLED:
				sdp.init()

				_lowerCamelCase	:      Union[str, Any]   =							tf.config.experimental.list_physical_devices('GPU')
				for gpu in gpus:
						tf.config.experimental.set_memory_growth(gpu, True)
				if gpus:
						tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU')

    # Load model and tokenizer
		_lowerCamelCase	:      Optional[int]   =							TFAutoModelForSequenceClassification.from_pretrained(args.model_name_or_path)
		_lowerCamelCase	:      int   =							AutoTokenizer.from_pretrained(args.model_name_or_path)

		# get datasets
		_lowerCamelCase  ,    _lowerCamelCase	:      int   =							get_datasets(
		    tokenizer=tokenizer,
		    train_batch_size=args.per_device_train_batch_size,
		    eval_batch_size=args.per_device_eval_batch_size,
		)

		# fine optimizer and loss
		_lowerCamelCase	:      Union[str, Any]   =							tf.keras.optimizers.Adam(learning_rate=args.learning_rate)
		_lowerCamelCase	:      Optional[Any]   =							tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
		_lowerCamelCase	:      Tuple   =							[tf.keras.metrics.SparseCategoricalAccuracy()]
		model.compile(optimizer=optimizer, loss=loss, metrics=metrics)

		# Training
		if args.do_train:
				# train_results = model.fit(tf_train_dataset, epochs=args.epochs, batch_size=args.train_batch_size)
				_lowerCamelCase	:      List[str]   =							time.time()
				_lowerCamelCase	:      List[str]   =							fit(
				    model,
				    loss,
				    optimizer,
				    tf_train_dataset,
				    args.epochs,
				    args.per_device_train_batch_size,
				    max_steps=args.max_steps,
				)
				_lowerCamelCase	:      Any   =							time.time() - start_train_time
				logger.info('*** Train ***')
				logger.info(f'train_runtime = {end_train_time}')

				_lowerCamelCase	:      Dict   =							os.path.join(args.output_dir, 'train_results.txt')

				if not SDP_ENABLED or sdp.rank() == 0:
						with open(output_eval_file, 'w') as writer:
								logger.info('***** Train results *****')
								logger.info(train_results)
								for key, value in train_results.items():
										logger.info(f'  {key} = {value}')
										writer.write(f'{key} = {value}\n')

    # Evaluation
		if args.do_eval and (not SDP_ENABLED or sdp.rank() == 0):
				_lowerCamelCase	:      int   =							model.evaluate(tf_test_dataset, batch_size=args.per_device_eval_batch_size, return_dict=True)
				logger.info('*** Evaluate ***')

				_lowerCamelCase	:      Dict   =							os.path.join(args.output_dir, 'eval_results.txt')

				with open(output_eval_file, 'w') as writer:
						logger.info('***** Eval results *****')
						logger.info(result)
						for key, value in result.items():
								logger.info(f'  {key} = {value}')
								writer.write(f'{key} = {value}\n')

    # Save result
		if SDP_ENABLED:
				if sdp.rank() == 0:
						model.save_pretrained(args.output_dir)
						tokenizer.save_pretrained(args.output_dir)
		else:
				model.save_pretrained(args.output_dir)
				tokenizer.save_pretrained(args.output_dir)











"""simple docstring"""

import unittest

from transformers import (
    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    PreTrainedTokenizer,
    is_vision_available,
)
from transformers.pipelines import ImageClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
		from PIL import Image
else:

		class 							lowercase   :







						@staticmethod
						def        a_	(				*_lowerCamelCase :       Tuple   ,  **_lowerCamelCase :       str							):



							"""simple docstring"""

							pass

@is_pipeline_test
@require_torch_or_tf
@require_vision
class 							lowercase   (     unittest.TestCase):
				__lowerCAmelCase     :     str								= MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
				__lowerCAmelCase     :     Union[str, Any]								= TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING







				def        a_	(				self :       Tuple   ,  _lowerCamelCase :       Any   ,  _lowerCamelCase :       str   ,  _lowerCamelCase :       Optional[Any]							):



					"""simple docstring"""

					A_	:					List[str]						 =		ImageClassificationPipeline(model=_lowerCamelCase   ,  image_processor=_lowerCamelCase   ,  top_k=2							)
					A_	:					Tuple						 =		[
					    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							),
					    '''http://images.cocodataset.org/val2017/000000039769.jpg''',
					]
					return image_classifier, examples







				def        a_	(				self :       Optional[Any]   ,  _lowerCamelCase :       Optional[int]   ,  _lowerCamelCase :       Optional[Any]							):



					"""simple docstring"""

					A_	:					int						 =		image_classifier('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)

					self.assertEqual(
					    _lowerCamelCase   ,  [
					        {'''score''': ANY(_lowerCamelCase							), '''label''': ANY(_lowerCamelCase							)},
					        {'''score''': ANY(_lowerCamelCase							), '''label''': ANY(_lowerCamelCase							)},
					    ]   ,  )

					import datasets

					A_	:					Optional[Any]						 =		datasets.load_dataset('''hf-internal-testing/fixtures_image_utils'''   ,  '''image'''   ,  split='''test'''							)

					# Accepts URL + PIL.Image + lists
					A_	:					Union[str, Any]						 =		image_classifier(
					    [
					        Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							),
					        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
					        # RGBA
					        dataset[0]['''file'''],
					        # LA
					        dataset[1]['''file'''],
					        # L
					        dataset[2]['''file'''],
					    ]							)
					self.assertEqual(
					    _lowerCamelCase   ,  [
					        [
					            {'''score''': ANY(_lowerCamelCase							), '''label''': ANY(_lowerCamelCase							)},
					            {'''score''': ANY(_lowerCamelCase							), '''label''': ANY(_lowerCamelCase							)},
					        ],
					        [
					            {'''score''': ANY(_lowerCamelCase							), '''label''': ANY(_lowerCamelCase							)},
					            {'''score''': ANY(_lowerCamelCase							), '''label''': ANY(_lowerCamelCase							)},
					        ],
					        [
					            {'''score''': ANY(_lowerCamelCase							), '''label''': ANY(_lowerCamelCase							)},
					            {'''score''': ANY(_lowerCamelCase							), '''label''': ANY(_lowerCamelCase							)},
					        ],
					        [
					            {'''score''': ANY(_lowerCamelCase							), '''label''': ANY(_lowerCamelCase							)},
					            {'''score''': ANY(_lowerCamelCase							), '''label''': ANY(_lowerCamelCase							)},
					        ],
					        [
					            {'''score''': ANY(_lowerCamelCase							), '''label''': ANY(_lowerCamelCase							)},
					            {'''score''': ANY(_lowerCamelCase							), '''label''': ANY(_lowerCamelCase							)},
					        ],
					    ]   ,  )







				@require_torch
				def        a_	(				self :       Dict							):



					"""simple docstring"""

					A_	:					Optional[int]						 =		'''hf-internal-testing/tiny-random-vit'''
					A_	:					Tuple						 =		pipeline('''image-classification'''   ,  model=_lowerCamelCase							)

					A_	:					Optional[int]						 =		image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''							)
					self.assertEqual(
					    nested_simplify(_lowerCamelCase   ,  decimals=4							)   ,  [{'''label''': '''LABEL_1''', '''score''': 0.574}, {'''label''': '''LABEL_0''', '''score''': 0.426}]   ,  )

					A_	:					str						 =		image_classifier(
					    [
					        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
					        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
					    ]   ,  top_k=2   ,  )
					self.assertEqual(
					    nested_simplify(_lowerCamelCase   ,  decimals=4							)   ,  [
					        [{'''label''': '''LABEL_1''', '''score''': 0.574}, {'''label''': '''LABEL_0''', '''score''': 0.426}],
					        [{'''label''': '''LABEL_1''', '''score''': 0.574}, {'''label''': '''LABEL_0''', '''score''': 0.426}],
					    ]   ,  )







				@require_tf
				def        a_	(				self :       Tuple							):



					"""simple docstring"""

					A_	:					List[str]						 =		'''hf-internal-testing/tiny-random-vit'''
					A_	:					Optional[int]						 =		pipeline('''image-classification'''   ,  model=_lowerCamelCase   ,  framework='''tf'''							)

					A_	:					Tuple						 =		image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''							)
					self.assertEqual(
					    nested_simplify(_lowerCamelCase   ,  decimals=4							)   ,  [{'''label''': '''LABEL_1''', '''score''': 0.574}, {'''label''': '''LABEL_0''', '''score''': 0.426}]   ,  )

					A_	:					Optional[Any]						 =		image_classifier(
					    [
					        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
					        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
					    ]   ,  top_k=2   ,  )
					self.assertEqual(
					    nested_simplify(_lowerCamelCase   ,  decimals=4							)   ,  [
					        [{'''label''': '''LABEL_1''', '''score''': 0.574}, {'''label''': '''LABEL_0''', '''score''': 0.426}],
					        [{'''label''': '''LABEL_1''', '''score''': 0.574}, {'''label''': '''LABEL_0''', '''score''': 0.426}],
					    ]   ,  )







				def        a_	(				self :       Dict							):



					"""simple docstring"""

					A_	:					Any						 =		PreTrainedTokenizer()

					# Assert that the pipeline can be initialized with a feature extractor that is not in any mapping
					A_	:					List[Any]						 =		pipeline(
					    '''image-classification'''   ,  model='''hf-internal-testing/tiny-random-vit'''   ,  tokenizer=_lowerCamelCase							)

					self.assertIs(image_classifier.tokenizer   ,  _lowerCamelCase							)







				@slow
				@require_torch
				def        a_	(				self :       List[str]							):



					"""simple docstring"""

					A_	:					List[Any]						 =		pipeline('''image-classification'''   ,  model='''deepmind/vision-perceiver-conv'''							)
					A_	:					Optional[Any]						 =		image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''							)
					self.assertEqual(
					    nested_simplify(_lowerCamelCase   ,  decimals=4							)   ,  [
					        {'''score''': 0.4385, '''label''': '''tabby, tabby cat'''},
					        {'''score''': 0.321, '''label''': '''tiger cat'''},
					        {'''score''': 0.0502, '''label''': '''Egyptian cat'''},
					        {'''score''': 0.0137, '''label''': '''crib, cot'''},
					        {'''score''': 0.007, '''label''': '''radiator'''},
					    ]   ,  )

					A_	:					Dict						 =		pipeline('''image-classification'''   ,  model='''deepmind/vision-perceiver-fourier'''							)
					A_	:					str						 =		image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''							)
					self.assertEqual(
					    nested_simplify(_lowerCamelCase   ,  decimals=4							)   ,  [
					        {'''score''': 0.5658, '''label''': '''tabby, tabby cat'''},
					        {'''score''': 0.1309, '''label''': '''tiger cat'''},
					        {'''score''': 0.0722, '''label''': '''Egyptian cat'''},
					        {'''score''': 0.0707, '''label''': '''remote control, remote'''},
					        {'''score''': 0.0082, '''label''': '''computer keyboard, keypad'''},
					    ]   ,  )

					A_	:					Optional[int]						 =		pipeline('''image-classification'''   ,  model='''deepmind/vision-perceiver-learned'''							)
					A_	:					int						 =		image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''							)
					self.assertEqual(
					    nested_simplify(_lowerCamelCase   ,  decimals=4							)   ,  [
					        {'''score''': 0.3022, '''label''': '''tabby, tabby cat'''},
					        {'''score''': 0.2362, '''label''': '''Egyptian cat'''},
					        {'''score''': 0.1856, '''label''': '''tiger cat'''},
					        {'''score''': 0.0324, '''label''': '''remote control, remote'''},
					        {'''score''': 0.0096, '''label''': '''quilt, comforter, comfort, puff'''},
					    ]   ,  )





