


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      (    __UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase=None			):
     a_     :  int				      =     tqdm(__UpperCamelCase			)
     for i, batch in enumerate(__UpperCamelCase			):
          with tf.GradientTape() as tape:
               a_      ,      a_     :  List[Any]				      =     batch
               a_     :  List[str]				      =     model(__UpperCamelCase			)
               a_     :  Dict				      =     loss(__UpperCamelCase	,	outputs.logits			)

          if SDP_ENABLED:
               a_     :  Dict				      =     sdp.DistributedGradientTape(__UpperCamelCase	,	sparse_as_dense=__UpperCamelCase			)

          a_     :  Optional[Any]				      =     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[str]				      =     {"""loss""": loss_value.numpy()}
     return train_results



def 			_a      (    __UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase			):
     # Load dataset
     a_      ,      a_     :  int				      =     load_dataset("""imdb"""	,	split=["""train""", """test"""]			)

     # Preprocess train dataset
     a_     :  Optional[Any]				      =     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_     :  Optional[Any]				      =     {
         x: train_dataset[x].to_tensor(default_value=0	,	shape=[None, tokenizer.model_max_length]			)
         for x in ["""input_ids""", """attention_mask"""]
     }
     a_     :  int				      =     tf.data.Dataset.from_tensor_slices((train_features, train_dataset["""label"""])			)

     # Preprocess test dataset
     a_     :  Any				      =     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_     :  int				      =     {
         x: test_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((test_features, test_dataset["""label"""])			)

     if SDP_ENABLED:
          a_     :  int				      =     tf_train_dataset.shard(sdp.size()	,	sdp.rank()			)
          a_     :  Optional[Any]				      =     tf_test_dataset.shard(sdp.size()	,	sdp.rank()			)
     a_     :  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   	=  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   	=  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	,							__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)










import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig
from ..clip.configuration_clip import CLIPVisionConfig


UpperCAmelCase_       : Union[str, Any]							=    logging.get_logger(__name__)





class   lowercase__     (				__A	):
  __UpperCamelCase						  =	"""vision-text-dual-encoder"""
  __UpperCamelCase						  =	True







  def __init__(						self     ,    _lowercase=512     ,    _lowercase=2.6592     ,    **_lowercase    ):
       super().__init__(**_lowercase    )

       if "vision_config" not in kwargs:
            raise ValueError("""`vision_config` can not be `None`."""    )

       if "text_config" not in kwargs:
            raise ValueError("""`text_config` can not be `None`."""    )

       lowerCAmelCase_       :							Dict			 =		kwargs.pop("""vision_config"""    )
       lowerCAmelCase_       :							Optional[int]			 =		kwargs.pop("""text_config"""    )

       lowerCAmelCase_       :							Tuple			 =		vision_config.pop("""model_type"""    )
       lowerCAmelCase_       :							str			 =		text_config.pop("""model_type"""    )

       if vision_model_type == "clip":
            lowerCAmelCase_       :							Dict			 =		AutoConfig.for_model(_lowercase     ,    **_lowercase    ).vision_config
       elif vision_model_type == "clip_vision_model":
            lowerCAmelCase_       :							Any			 =		CLIPVisionConfig(**_lowercase    )
       else:
            lowerCAmelCase_       :							Tuple			 =		AutoConfig.for_model(_lowercase     ,    **_lowercase    )

       lowerCAmelCase_       :							List[Any]			 =		AutoConfig.for_model(_lowercase     ,    **_lowercase    )

       lowerCAmelCase_       :							Union[str, Any]			 =		projection_dim
       lowerCAmelCase_       :							Optional[int]			 =		logit_scale_init_value







  @classmethod
  def 						UpperCAmelCase__		(						cls     ,    _lowercase     ,    _lowercase     ,    **_lowercase    ):
       return cls(vision_config=vision_config.to_dict()     ,    text_config=text_config.to_dict()     ,    **_lowercase    )







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_       :							int			 =		copy.deepcopy(self.__dict__    )
       lowerCAmelCase_       :							List[str]			 =		self.vision_config.to_dict()
       lowerCAmelCase_       :							List[str]			 =		self.text_config.to_dict()
       lowerCAmelCase_       :							str			 =		self.__class__.model_type
       return output
