





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():
      __lowercase													=			True
      __lowercase													=			'p3dn.24xlarge'
      import smdistributed.dataparallel.tensorflow as sdp
else:
      __lowercase													=			False


def 					__SCREAMING_SNAKE_CASE  (							__lowercase:		Optional[Any]     ,							__lowercase:		Optional[Any]     ,							__lowercase:		Dict     ,							__lowercase:		List[Any]     ,							__lowercase:		Any     ,							__lowercase:		Any     ,							__lowercase:		int=None):



  '''simple docstring'''






  __lowerCAmelCase			=				tqdm(__lowercase)
  for i, batch in enumerate(__lowercase):
    with tf.GradientTape() as tape:
      __lowerCAmelCase	,						__lowerCAmelCase			=				batch
      __lowerCAmelCase			=				model(__lowercase)
      __lowerCAmelCase			=				loss(__lowercase     ,							outputs.logits)

    if SDP_ENABLED:
      __lowerCAmelCase			=				sdp.DistributedGradientTape(__lowercase     ,							sparse_as_dense=__lowercase)

    __lowerCAmelCase			=				tape.gradient(__lowercase     ,							model.trainable_variables)
    opt.apply_gradients(zip(__lowercase     ,							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

  __lowerCAmelCase			=				{'''loss''': loss_value.numpy()}
  return train_results


def 					__SCREAMING_SNAKE_CASE  (							__lowercase:		List[Any]     ,							__lowercase:		Tuple     ,							__lowercase:		List[Any]):



  '''simple docstring'''






  __lowerCAmelCase	,						__lowerCAmelCase			=				load_dataset('''imdb'''     ,							split=['''train''', '''test'''])

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

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

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

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

  if SDP_ENABLED:
    __lowerCAmelCase			=				tf_train_dataset.shard(sdp.size()     ,							sdp.rank())
    __lowerCAmelCase			=				tf_test_dataset.shard(sdp.size()     ,							sdp.rank())
  __lowerCAmelCase			=				tf_train_dataset.batch(__lowercase     ,							drop_remainder=__lowercase)
  __lowerCAmelCase			=				tf_test_dataset.batch(__lowercase     ,							drop_remainder=__lowercase)

  return tf_train_dataset, tf_test_dataset


if __name__ == "__main__":
      __lowercase													=			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"""])

      __lowercase													=			parser.parse_known_args()

      # Set up logging
      __lowercase													=			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()

            __lowercase													=			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
      __lowercase													=			TFAutoModelForSequenceClassification.from_pretrained(args.model_name_or_path)
      __lowercase													=			AutoTokenizer.from_pretrained(args.model_name_or_path)

      # get datasets
      __lowercase													=			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
      __lowercase													=			tf.keras.optimizers.Adam(learning_rate=args.learning_rate)
      __lowercase													=			tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
      __lowercase													=			[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)
            __lowercase													=			time.time()
            __lowercase													=			fit(
                model,
                loss,
                optimizer,
                tf_train_dataset,
                args.epochs,
                args.per_device_train_batch_size,
                max_steps=args.max_steps,
            )
            __lowercase													=			time.time() - start_train_time
            logger.info("""*** Train ***""")
            logger.info(f"""train_runtime = {end_train_time}""")

            __lowercase													=			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):
            __lowercase													=			model.evaluate(tf_test_dataset, batch_size=args.per_device_eval_batch_size, return_dict=True)
            logger.info("""*** Evaluate ***""")

            __lowercase													=			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)







import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import ViltImageProcessor

class   __snake_case				(			unittest.TestCase   ):






    '''simple docstring'''





    def __init__(   self						:		Tuple			,						snake_case						:		List[str]			,						snake_case						:		Dict=7			,						snake_case						:		str=3			,						snake_case						:		Union[str, Any]=18			,						snake_case						:		str=30			,						snake_case						:		str=400			,						snake_case						:		Optional[Any]=True			,						snake_case						:		List[str]=None			,						snake_case						:		Tuple=2			,						snake_case						:		Dict=True			,						snake_case						:		Dict=[0.5, 0.5, 0.5]			,						snake_case						:		Tuple=[0.5, 0.5, 0.5]			,						):

      """simple docstring"""





      __lowerCAmelCase			=				size if size is not None else {'''shortest_edge''': 30}
      __lowerCAmelCase			=				parent
      __lowerCAmelCase			=				batch_size
      __lowerCAmelCase			=				num_channels
      __lowerCAmelCase			=				image_size
      __lowerCAmelCase			=				min_resolution
      __lowerCAmelCase			=				max_resolution
      __lowerCAmelCase			=				do_resize
      __lowerCAmelCase			=				size
      __lowerCAmelCase			=				size_divisor
      __lowerCAmelCase			=				do_normalize
      __lowerCAmelCase			=				image_mean
      __lowerCAmelCase			=				image_std





    def 	A		(   self						:		int							):

      """simple docstring"""





      return {
          "image_mean": self.image_mean,
          "image_std": self.image_std,
          "do_normalize": self.do_normalize,
          "do_resize": self.do_resize,
          "size": self.size,
          "size_divisor": self.size_divisor,
      }





    def 	A		(   self						:		Dict			,						snake_case						:		List[Any]			,						snake_case						:		Any=False							):

      """simple docstring"""





      if not batched:
        __lowerCAmelCase			=				self.size['''shortest_edge''']
        __lowerCAmelCase			=				image_inputs[0]
        if isinstance(snake_case			,						Image.Image							):
          __lowerCAmelCase	,						__lowerCAmelCase			=				image.size
        else:
          __lowerCAmelCase	,						__lowerCAmelCase			=				image.shape[1], image.shape[2]
        __lowerCAmelCase			=				size / min(snake_case			,						snake_case							)
        if h < w:
          __lowerCAmelCase	,						__lowerCAmelCase			=				size, scale * w
        else:
          __lowerCAmelCase	,						__lowerCAmelCase			=				scale * h, size

        __lowerCAmelCase			=				int((1_333 / 800) * size							)
        if max(snake_case			,						snake_case							) > max_size:
          __lowerCAmelCase			=				max_size / max(snake_case			,						snake_case							)
          __lowerCAmelCase			=				newh * scale
          __lowerCAmelCase			=				neww * scale

        __lowerCAmelCase	,						__lowerCAmelCase			=				int(newh + 0.5							), int(neww + 0.5							)
        __lowerCAmelCase	,						__lowerCAmelCase			=				(
            newh // self.size_divisor * self.size_divisor,
            neww // self.size_divisor * self.size_divisor,
        )

      else:
        __lowerCAmelCase			=				[]
        for image in image_inputs:
          __lowerCAmelCase	,						__lowerCAmelCase			=				self.get_expected_values([image]							)
          expected_values.append((expected_height, expected_width)							)
        __lowerCAmelCase			=				max(snake_case			,						key=lambda snake_case							: item[0]							)[0]
        __lowerCAmelCase			=				max(snake_case			,						key=lambda snake_case							: item[1]							)[1]

      return expected_height, expected_width


@require_torch
@require_vision
class   __snake_case				(			_a       ,				unittest.TestCase   ):






    '''simple docstring'''
    _lowerCAmelCase     =	ViltImageProcessor if is_vision_available() else None





    def 	A		(   self						:		Union[str, Any]							):

      """simple docstring"""





      __lowerCAmelCase			=				ViltImageProcessingTester(self							)





    @property
    def 	A		(   self						:		Any							):

      """simple docstring"""





      return self.image_processor_tester.prepare_image_processor_dict()





    def 	A		(   self						:		List[Any]							):

      """simple docstring"""





      __lowerCAmelCase			=				self.image_processing_class(**self.image_processor_dict							)
      self.assertTrue(hasattr(snake_case			,						'''image_mean'''							)							)
      self.assertTrue(hasattr(snake_case			,						'''image_std'''							)							)
      self.assertTrue(hasattr(snake_case			,						'''do_normalize'''							)							)
      self.assertTrue(hasattr(snake_case			,						'''do_resize'''							)							)
      self.assertTrue(hasattr(snake_case			,						'''size'''							)							)
      self.assertTrue(hasattr(snake_case			,						'''size_divisor'''							)							)





    def 	A		(   self						:		Optional[Any]							):

      """simple docstring"""





      __lowerCAmelCase			=				self.image_processing_class.from_dict(self.image_processor_dict							)
      self.assertEqual(image_processor.size			,						{'''shortest_edge''': 30}							)

      __lowerCAmelCase			=				self.image_processing_class.from_dict(self.image_processor_dict			,						size=42							)
      self.assertEqual(image_processor.size			,						{'''shortest_edge''': 42}							)





    def 	A		(   self						:		Union[str, Any]							):

      """simple docstring"""





      pass





    def 	A		(   self						:		Union[str, Any]							):

      """simple docstring"""





      __lowerCAmelCase			=				self.image_processing_class(**self.image_processor_dict							)
      # create random PIL images
      __lowerCAmelCase			=				prepare_image_inputs(self.image_processor_tester			,						equal_resolution=snake_case							)
      for image in image_inputs:
        self.assertIsInstance(snake_case			,						Image.Image							)

      # Test not batched input
      __lowerCAmelCase			=				image_processing(image_inputs[0]			,						return_tensors='''pt'''							).pixel_values

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.image_processor_tester.get_expected_values(snake_case							)
      self.assertEqual(
          encoded_images.shape			,						(1, self.image_processor_tester.num_channels, expected_height, expected_width)			,						)

      # Test batched
      __lowerCAmelCase			=				image_processing(snake_case			,						return_tensors='''pt'''							).pixel_values

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.image_processor_tester.get_expected_values(snake_case			,						batched=snake_case							)
      self.assertEqual(
          encoded_images.shape			,						(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              expected_height,
              expected_width,
          )			,						)





    def 	A		(   self						:		Tuple							):

      """simple docstring"""





      __lowerCAmelCase			=				self.image_processing_class(**self.image_processor_dict							)
      # create random numpy tensors
      __lowerCAmelCase			=				prepare_image_inputs(self.image_processor_tester			,						equal_resolution=snake_case			,						numpify=snake_case							)
      for image in image_inputs:
        self.assertIsInstance(snake_case			,						np.ndarray							)

      # Test not batched input
      __lowerCAmelCase			=				image_processing(image_inputs[0]			,						return_tensors='''pt'''							).pixel_values

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.image_processor_tester.get_expected_values(snake_case							)
      self.assertEqual(
          encoded_images.shape			,						(1, self.image_processor_tester.num_channels, expected_height, expected_width)			,						)

      # Test batched
      __lowerCAmelCase			=				image_processing(snake_case			,						return_tensors='''pt'''							).pixel_values

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.image_processor_tester.get_expected_values(snake_case			,						batched=snake_case							)
      self.assertEqual(
          encoded_images.shape			,						(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              expected_height,
              expected_width,
          )			,						)





    def 	A		(   self						:		List[str]							):

      """simple docstring"""





      __lowerCAmelCase			=				self.image_processing_class(**self.image_processor_dict							)
      # create random PyTorch tensors
      __lowerCAmelCase			=				prepare_image_inputs(self.image_processor_tester			,						equal_resolution=snake_case			,						torchify=snake_case							)
      for image in image_inputs:
        self.assertIsInstance(snake_case			,						torch.Tensor							)

      # Test not batched input
      __lowerCAmelCase			=				image_processing(image_inputs[0]			,						return_tensors='''pt'''							).pixel_values

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.image_processor_tester.get_expected_values(snake_case							)
      self.assertEqual(
          encoded_images.shape			,						(1, self.image_processor_tester.num_channels, expected_height, expected_width)			,						)

      # Test batched
      __lowerCAmelCase			=				image_processing(snake_case			,						return_tensors='''pt'''							).pixel_values

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.image_processor_tester.get_expected_values(snake_case			,						batched=snake_case							)
      self.assertEqual(
          encoded_images.shape			,						(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              expected_height,
              expected_width,
          )			,						)
