code: 
  
  
  
  
  
  
  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_   =   True
     lowerCAmelCase_   =   """p3dn.24xlarge"""
     import smdistributed.dataparallel.tensorflow as sdp
  else:
     lowerCAmelCase_   =   False
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_      ,		lowercase_      ,		lowercase_      ,		lowercase_      ,		lowercase_=None  )			->						List[str]:
         _snake_case      :							List[Any]     				=						tqdm(lowercase_  )
         for i, batch in enumerate(lowercase_  ):
                with tf.GradientTape() as tape:
                       _snake_case				,    _snake_case      :							Optional[int]     				=						batch
                       _snake_case      :							List[Any]     				=						model(lowercase_  )
                       _snake_case      :							Tuple     				=						loss(lowercase_      ,		outputs.logits  )
  
                if SDP_ENABLED:
                       _snake_case      :							Union[str, Any]     				=						sdp.DistributedGradientTape(lowercase_      ,		sparse_as_dense=lowercase_  )
  
                _snake_case      :							Any     				=						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
  
         _snake_case      :							Optional[int]     				=						{'''loss''': loss_value.numpy()}
         return train_results
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_  )			->						Union[str, Any]:
         _snake_case				,    _snake_case      :							Union[str, Any]     				=						load_dataset('''imdb'''      ,		split=['''train''', '''test''']  )
  
         # Preprocess train dataset
         _snake_case      :							Optional[Any]     				=						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''']  )
  
         _snake_case      :							Tuple     				=						{
             x: train_dataset[x].to_tensor(default_value=0      ,		shape=[None, tokenizer.model_max_length]  )
             for x in ['''input_ids''', '''attention_mask''']
         }
         _snake_case      :							Optional[int]     				=						tf.data.Dataset.from_tensor_slices((train_features, train_dataset['''label'''])  )
  
         # Preprocess test dataset
         _snake_case      :							Optional[int]     				=						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''']  )
  
         _snake_case      :							Dict     				=						{
             x: test_dataset[x].to_tensor(default_value=0      ,		shape=[None, tokenizer.model_max_length]  )
             for x in ['''input_ids''', '''attention_mask''']
         }
         _snake_case      :							List[str]     				=						tf.data.Dataset.from_tensor_slices((test_features, test_dataset['''label'''])  )
  
         if SDP_ENABLED:
                _snake_case      :							str     				=						tf_train_dataset.shard(sdp.size()      ,		sdp.rank()  )
                _snake_case      :							Union[str, Any]     				=						tf_test_dataset.shard(sdp.size()      ,		sdp.rank()  )
         _snake_case      :							Any     				=						tf_train_dataset.batch(lowercase_      ,		drop_remainder=lowercase_  )
         _snake_case      :							Optional[int]     				=						tf_test_dataset.batch(lowercase_      ,		drop_remainder=lowercase_  )
  
         return tf_train_dataset, tf_test_dataset
  
  
  if __name__ == "__main__":
     lowerCAmelCase_   =   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=1_6)
     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_   =   parser.parse_known_args()
  
     # Set up logging
     lowerCAmelCase_   =   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_   =   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_   =   TFAutoModelForSequenceClassification.from_pretrained(args.model_name_or_path)
     lowerCAmelCase_   =   AutoTokenizer.from_pretrained(args.model_name_or_path)
  
     # get datasets
     lowerCAmelCase_   =   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_   =   tf.keras.optimizers.Adam(learning_rate=args.learning_rate)
     lowerCAmelCase_   =   tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
     lowerCAmelCase_   =   [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_   =   time.time()
        lowerCAmelCase_   =   fit(
            model,
            loss,
            optimizer,
            tf_train_dataset,
            args.epochs,
            args.per_device_train_batch_size,
            max_steps=args.max_steps,
        )
        lowerCAmelCase_   =   time.time() - start_train_time
        logger.info("*** Train ***")
        logger.info(F"""train_runtime = {end_train_time}""")
  
        lowerCAmelCase_   =   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_   =   model.evaluate(tf_test_dataset, batch_size=args.per_device_eval_batch_size, return_dict=True)
        logger.info("*** Evaluate ***")
  
        lowerCAmelCase_   =   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)
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  import unittest
  
  from transformers import load_tool
  from transformers.tools.agent_types import AGENT_TYPE_MAPPING
  
  from .test_tools_common import ToolTesterMixin, output_types
  
  class 				A    (unittest.TestCase       ,__UpperCAmelCase				):
  
  
  
        def    __a (					self					)      ->   str:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							List[Any]     				=						load_tool('''translation'''					)
               self.tool.setup()
               _snake_case      :							Any     				=						load_tool('''translation'''     ,  remote=lowercase_					)
  
  
  
        def    __a (					self					)      ->   Optional[int]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Tuple     				=						self.tool('''Hey, what\'s up?'''     ,  src_lang='''English'''     ,  tgt_lang='''French'''					)
               self.assertEqual(lowercase_     ,  '''- Hé, comment ça va?'''					)
  
  
  
        def    __a (					self					)      ->   Union[str, Any]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[int]     				=						self.remote_tool('''Hey, what\'s up?'''     ,  src_lang='''English'''     ,  tgt_lang='''French'''					)
               self.assertEqual(lowercase_     ,  '''- Hé, comment ça va?'''					)
  
  
  
        def    __a (					self					)      ->   List[Any]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Dict     				=						self.tool(text='''Hey, what\'s up?'''     ,  src_lang='''English'''     ,  tgt_lang='''French'''					)
               self.assertEqual(lowercase_     ,  '''- Hé, comment ça va?'''					)
  
  
  
        def    __a (					self					)      ->   Dict:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							List[Any]     				=						self.remote_tool(text='''Hey, what\'s up?'''     ,  src_lang='''English'''     ,  tgt_lang='''French'''					)
               self.assertEqual(lowercase_     ,  '''- Hé, comment ça va?'''					)
  
  
  
        def    __a (					self					)      ->   str:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[int]     				=						['''Hey, what\'s up?''', '''English''', '''Spanish''']
               _snake_case      :							Dict     				=						self.tool(*lowercase_					)
  
               # There is a single output
               if len(self.tool.outputs					) == 1:
                      _snake_case      :							Optional[Any]     				=						[outputs]
  
               self.assertListEqual(output_types(lowercase_					)     ,  self.tool.outputs					)
  
  
  
        def    __a (					self					)      ->   Tuple:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Union[str, Any]     				=						['''Hey, what\'s up?''', '''English''', '''Spanish''']
               _snake_case      :							Dict     				=						self.tool(*lowercase_					)
  
               if not isinstance(lowercase_     ,  lowercase_					):
                      _snake_case      :							Optional[Any]     				=						[outputs]
  
               self.assertEqual(len(lowercase_					)     ,  len(self.tool.outputs					)					)
  
               for output, output_type in zip(lowercase_     ,  self.tool.outputs					):
                      _snake_case      :							List[str]     				=						AGENT_TYPE_MAPPING[output_type]
                      self.assertTrue(isinstance(lowercase_     ,  lowercase_					)					)
  
  
  
        def    __a (					self					)      ->   List[Any]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Dict     				=						['''Hey, what\'s up?''', '''English''', '''Spanish''']
  
               _snake_case      :							Any     				=						[]
  
               for _input, input_type in zip(lowercase_     ,  self.tool.inputs					):
                      if isinstance(lowercase_     ,  lowercase_					):
                             _inputs.append([AGENT_TYPE_MAPPING[_input_type](_input					) for _input_type in input_type]					)
                      else:
                             _inputs.append(AGENT_TYPE_MAPPING[input_type](_input					)					)
  
          # Should not raise an error
               _snake_case      :							List[Any]     				=						self.tool(*lowercase_					)
  
               if not isinstance(lowercase_     ,  lowercase_					):
                      _snake_case      :							Any     				=						[outputs]
  
               self.assertEqual(len(lowercase_					)     ,  len(self.tool.outputs					)					)
  
  
  
  
  
  
  