
"""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():
    A__   :						int 							=     True
    A__   :						str 							=     'p3dn.24xlarge'
    import smdistributed.dataparallel.tensorflow as sdp
else:
    A__   :						List[str] 							=     False



def 				a__			(					lowerCAmelCase						:							str							,     lowerCAmelCase						:							Optional[Any]							,     lowerCAmelCase						:							str							,     lowerCAmelCase						:							Tuple							,     lowerCAmelCase						:							Union[str, Any]							,     lowerCAmelCase						:							Optional[int]							,     lowerCAmelCase						:							List[Any]=None		):






     '''simple docstring'''
     UpperCAmelCase__				:			Any							=    tqdm(_SCREAMING_SNAKE_CASE		)
     for i, batch in enumerate(_SCREAMING_SNAKE_CASE		):
          with tf.GradientTape() as tape:
               UpperCAmelCase__				,						UpperCAmelCase__				:			Any							=    batch
               UpperCAmelCase__				:			Dict							=    model(_SCREAMING_SNAKE_CASE		)
               UpperCAmelCase__				:			List[str]							=    loss(_SCREAMING_SNAKE_CASE							,     outputs.logits		)

          if SDP_ENABLED:
               UpperCAmelCase__				:			Dict							=    sdp.DistributedGradientTape(_SCREAMING_SNAKE_CASE							,     sparse_as_dense=_SCREAMING_SNAKE_CASE		)

          UpperCAmelCase__				:			Dict							=    tape.gradient(_SCREAMING_SNAKE_CASE							,     model.trainable_variables		)
          opt.apply_gradients(zip(_SCREAMING_SNAKE_CASE							,     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

     UpperCAmelCase__				:			str							=    {"loss": loss_value.numpy()}
     return train_results



def 				a__			(					lowerCAmelCase						:							Any							,     lowerCAmelCase						:							Tuple							,     lowerCAmelCase						:							Tuple		):






     '''simple docstring'''
     # Load dataset
     UpperCAmelCase__				,						UpperCAmelCase__				:			Dict							=    load_dataset("imdb"							,     split=["train", "test"]		)

     # Preprocess train dataset
     UpperCAmelCase__				:			Union[str, Any]							=    train_dataset.map(
         lambda lowerCAmelCase		: tokenizer(e["text"]							,     truncation=_SCREAMING_SNAKE_CASE							,     padding="max_length"		)							,     batched=_SCREAMING_SNAKE_CASE		)
     train_dataset.set_format(type="tensorflow"							,     columns=["input_ids", "attention_mask", "label"]		)

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

     # Preprocess test dataset
     UpperCAmelCase__				:			Any							=    test_dataset.map(
         lambda lowerCAmelCase		: tokenizer(e["text"]							,     truncation=_SCREAMING_SNAKE_CASE							,     padding="max_length"		)							,     batched=_SCREAMING_SNAKE_CASE		)
     test_dataset.set_format(type="tensorflow"							,     columns=["input_ids", "attention_mask", "label"]		)

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

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

     return tf_train_dataset, tf_test_dataset


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

    A__   :						int 							=     parser.parse_known_args()

    # Set up logging
    A__   :						Optional[int] 							=     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()

        A__   :						Tuple 							=     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
    A__   :						int 							=     TFAutoModelForSequenceClassification.from_pretrained(args.model_name_or_path)
    A__   :						Union[str, Any] 							=     AutoTokenizer.from_pretrained(args.model_name_or_path)

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

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

        A__   :						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 argparse
import json
import re
import string
import sys
from collections import Counter







def     _a					(   _SCREAMING_SNAKE_CASE					)     ->					Any:

							def remove_articles(_SCREAMING_SNAKE_CASE					):
														return re.sub(r"""\b(a|an|the)\b"""					,			""" """					,			_SCREAMING_SNAKE_CASE					)

							def white_space_fix(_SCREAMING_SNAKE_CASE					):
														return " ".join(text.split()					)

							def remove_punc(_SCREAMING_SNAKE_CASE					):
														snake_case_     							=		set(string.punctuation					)
														return "".join(ch for ch in text if ch not in exclude					)

							def lower(_SCREAMING_SNAKE_CASE					):
														return text.lower()

							return white_space_fix(remove_articles(remove_punc(lower(_SCREAMING_SNAKE_CASE					)					)					)					)







def     _a					(   _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)     ->					Optional[int]:
							snake_case_     							=		normalize_answer(_SCREAMING_SNAKE_CASE					).split()
							snake_case_     							=		normalize_answer(_SCREAMING_SNAKE_CASE					).split()
							snake_case_     							=		Counter(_SCREAMING_SNAKE_CASE					) & Counter(_SCREAMING_SNAKE_CASE					)
							snake_case_     							=		sum(common.values()					)
							if num_same == 0:
														return 0
							snake_case_     							=		1.0 * num_same / len(_SCREAMING_SNAKE_CASE					)
							snake_case_     							=		1.0 * num_same / len(_SCREAMING_SNAKE_CASE					)
							snake_case_     							=		(2 * precision * recall) / (precision + recall)
							return fa







def     _a					(   _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)     ->					Union[str, Any]:
							return normalize_answer(_SCREAMING_SNAKE_CASE					) == normalize_answer(_SCREAMING_SNAKE_CASE					)







def     _a					(   _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)     ->					Optional[int]:
							snake_case_     							=		[]
							for ground_truth in ground_truths:
														snake_case_     							=		metric_fn(_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)
														scores_for_ground_truths.append(_SCREAMING_SNAKE_CASE					)
							return max(_SCREAMING_SNAKE_CASE					)







def     _a					(   _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)     ->					Optional[int]:
							snake_case_     							=		snake_case_     							=		snake_case_     							=		0
							for article in dataset:
														for paragraph in article["paragraphs"]:
																					for qa in paragraph["qas"]:
																												total += 1
																												if qa["id"] not in predictions:
																																			snake_case_     							=		"""Unanswered question """ + qa["""id"""] + """ will receive score 0."""
																																			print(_SCREAMING_SNAKE_CASE					,			file=sys.stderr					)
																																			continue
																												snake_case_     							=		[x["""text"""] for x in qa["""answers"""]]
																												snake_case_     							=		predictions[qa["""id"""]]
																												exact_match += metric_max_over_ground_truths(_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)
																												fa += metric_max_over_ground_truths(_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					)

							snake_case_     							=		100.0 * exact_match / total
							snake_case_     							=		100.0 * fa / total

							return {"exact_match": exact_match, "f1": fa}


if __name__ == "__main__":
				__SCREAMING_SNAKE_CASE				:     Tuple		=     '1.1'
				__SCREAMING_SNAKE_CASE				:     Union[str, Any]		=     argparse.ArgumentParser(description='Evaluation for SQuAD ' + expected_version)
				parser.add_argument('dataset_file', help='Dataset file')
				parser.add_argument('prediction_file', help='Prediction File')
				__SCREAMING_SNAKE_CASE				:     Union[str, Any]		=     parser.parse_args()
				with open(args.dataset_file) as dataset_file:
								__SCREAMING_SNAKE_CASE				:     Optional[Any]		=     json.load(dataset_file)
								if dataset_json["version"] != expected_version:
												print(
												    'Evaluation expects v-' + expected_version + ', but got dataset with v-' + dataset_json['version'],
												    file=sys.stderr,
												)
								__SCREAMING_SNAKE_CASE				:     str		=     dataset_json['data']
				with open(args.prediction_file) as prediction_file:
								__SCREAMING_SNAKE_CASE				:     int		=     json.load(prediction_file)
				print(json.dumps(evaluate(dataset, predictions)))



