





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():
  __UpperCAmelCase						=      True
  __UpperCAmelCase						=      'p3dn.24xlarge'
  import smdistributed.dataparallel.tensorflow as sdp
else:
  __UpperCAmelCase						=      False
def 			__UpperCamelCase				(			lowercase__	:       int		,    lowercase__	:       Optional[int]		,    lowercase__	:       Union[str, Any]		,    lowercase__	:       int		,    lowercase__	:       Optional[Any]		,    lowercase__	:       List[Any]		,    lowercase__	:       Union[str, Any]=None		)	->      Optional[int]:
    '''simple docstring'''





    lowerCAmelCase_					:	Optional[int]						=   tqdm(lowercase__		)
    for i, batch in enumerate(lowercase__		):
        with tf.GradientTape() as tape:
            lowerCAmelCase_		,		lowerCAmelCase_					:	List[Any]						=   batch
            lowerCAmelCase_					:	str						=   model(lowercase__		)
            lowerCAmelCase_					:	Tuple						=   loss(lowercase__		,    outputs.logits		)

        if SDP_ENABLED:
            lowerCAmelCase_					:	Union[str, Any]						=   sdp.DistributedGradientTape(lowercase__		,    sparse_as_dense=lowercase__		)

        lowerCAmelCase_					:	Tuple						=   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_					:	Tuple						=   {"""loss""": loss_value.numpy()}
    return train_results
def 			__UpperCamelCase				(			lowercase__	:       List[str]		,    lowercase__	:       Union[str, Any]		,    lowercase__	:       Tuple		)	->      str:
    '''simple docstring'''





    lowerCAmelCase_		,		lowerCAmelCase_					:	List[Any]						=   load_dataset("""imdb"""		,    split=["""train""", """test"""]		)

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

    # Preprocess test dataset
    lowerCAmelCase_					:	Tuple						=   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_					:	List[Any]						=   {
        x: test_dataset[x].to_tensor(default_value=0		,    shape=[None, tokenizer.model_max_length]		)
        for x in ["""input_ids""", """attention_mask"""]
    }
    lowerCAmelCase_					:	Any						=   tf.data.Dataset.from_tensor_slices((test_features, test_dataset["""label"""])		)

    if SDP_ENABLED:
        lowerCAmelCase_					:	Tuple						=   tf_train_dataset.shard(sdp.size()		,    sdp.rank()		)
        lowerCAmelCase_					:	Any						=   tf_test_dataset.shard(sdp.size()		,    sdp.rank()		)
    lowerCAmelCase_					:	List[Any]						=   tf_train_dataset.batch(lowercase__		,    drop_remainder=lowercase__		)
    lowerCAmelCase_					:	Dict						=   tf_test_dataset.batch(lowercase__		,    drop_remainder=lowercase__		)

    return tf_train_dataset, tf_test_dataset


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

  __UpperCAmelCase		,					__UpperCAmelCase						=      parser.parse_known_args()

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

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

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

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

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









from __future__ import annotations

import math
from itertools import permutations
def 			__UpperCamelCase				(			lowercase__	:       int		)	->      bool:
    '''simple docstring'''





    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5		,    int(math.sqrt(lowercase__		) + 1		)		,    6		):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True
def 			__UpperCamelCase				(			lowercase__	:       int = 7		)	->      int:
    '''simple docstring'''





    lowerCAmelCase_					:	str						=   """""".join(str(lowercase__		) for i in range(1		,    n + 1		)		)
    lowerCAmelCase_					:	Any						=   [int("""""".join(lowercase__		)		) for i in permutations(lowercase__		,    lowercase__		)]
    lowerCAmelCase_					:	List[Any]						=   [num for num in perm_list if is_prime(lowercase__		)]
    return max(lowercase__		) if pandigitals else 0


if __name__ == "__main__":
  print(f"""{solution() = }""")


