

from .constants import (
    MODEL_NAME,
    OPTIMIZER_NAME,
    RNG_STATE_NAME,
    SAFE_WEIGHTS_INDEX_NAME,
    SAFE_WEIGHTS_NAME,
    SCALER_NAME,
    SCHEDULER_NAME,
    TORCH_LAUNCH_PARAMS,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
)
from .dataclasses import (
    BnbQuantizationConfig,
    ComputeEnvironment,
    CustomDtype,
    DeepSpeedPlugin,
    DistributedDataParallelKwargs,
    DistributedType,
    DynamoBackend,
    FPaRecipeKwargs,
    FullyShardedDataParallelPlugin,
    GradientAccumulationPlugin,
    GradScalerKwargs,
    InitProcessGroupKwargs,
    KwargsHandler,
    LoggerType,
    MegatronLMPlugin,
    PrecisionType,
    ProjectConfiguration,
    RNGType,
    SageMakerDistributedType,
    TensorInformation,
    TorchDynamoPlugin,
)
from .environment import get_int_from_env, parse_choice_from_env, parse_flag_from_env
from .imports import (
    get_ccl_version,
    is_abit_bnb_available,
    is_abit_bnb_available,
    is_aim_available,
    is_bfaa_available,
    is_bnb_available,
    is_botoa_available,
    is_ccl_available,
    is_comet_ml_available,
    is_datasets_available,
    is_deepspeed_available,
    is_fpa_available,
    is_ipex_available,
    is_megatron_lm_available,
    is_mlflow_available,
    is_mps_available,
    is_npu_available,
    is_rich_available,
    is_safetensors_available,
    is_sagemaker_available,
    is_tensorboard_available,
    is_tpu_available,
    is_transformers_available,
    is_wandb_available,
    is_xpu_available,
)
from .modeling import (
    check_device_map,
    check_tied_parameters_in_config,
    check_tied_parameters_on_same_device,
    compute_module_sizes,
    convert_file_size_to_int,
    dtype_byte_size,
    find_tied_parameters,
    get_balanced_memory,
    get_max_layer_size,
    get_max_memory,
    get_mixed_precision_context_manager,
    id_tensor_storage,
    infer_auto_device_map,
    load_checkpoint_in_model,
    load_offloaded_weights,
    load_state_dict,
    named_module_tensors,
    retie_parameters,
    set_module_tensor_to_device,
    shard_checkpoint,
)
from .offload import (
    OffloadedWeightsLoader,
    PrefixedDataset,
    extract_submodules_state_dict,
    load_offloaded_weight,
    offload_state_dict,
    offload_weight,
    save_offload_index,
)
from .operations import (
    broadcast,
    broadcast_object_list,
    concatenate,
    convert_outputs_to_fpaa,
    convert_to_fpaa,
    find_batch_size,
    find_device,
    gather,
    gather_object,
    get_data_structure,
    honor_type,
    initialize_tensors,
    is_namedtuple,
    is_tensor_information,
    is_torch_tensor,
    listify,
    pad_across_processes,
    recursively_apply,
    reduce,
    send_to_device,
    slice_tensors,
)
from .versions import compare_versions, is_torch_version


if is_deepspeed_available():
						from .deepspeed import (
						    DeepSpeedEngineWrapper,
						    DeepSpeedOptimizerWrapper,
						    DeepSpeedSchedulerWrapper,
						    DummyOptim,
						    DummyScheduler,
						    HfDeepSpeedConfig,
						)

from .bnb import has_abit_bnb_layers, load_and_quantize_model
from .fsdp_utils import load_fsdp_model, load_fsdp_optimizer, save_fsdp_model, save_fsdp_optimizer
from .launch import (
    PrepareForLaunch,
    _filter_args,
    prepare_deepspeed_cmd_env,
    prepare_multi_gpu_env,
    prepare_sagemager_args_inputs,
    prepare_simple_launcher_cmd_env,
    prepare_tpu,
)
from .megatron_lm import (
    AbstractTrainStep,
    BertTrainStep,
    GPTTrainStep,
    MegatronEngine,
    MegatronLMDummyDataLoader,
    MegatronLMDummyScheduler,
    MegatronLMOptimizerWrapper,
    MegatronLMSchedulerWrapper,
    TaTrainStep,
    avg_losses_across_data_parallel_group,
    gather_across_data_parallel_groups,
)
from .megatron_lm import initialize as megatron_lm_initialize
from .megatron_lm import prepare_data_loader as megatron_lm_prepare_data_loader
from .megatron_lm import prepare_model as megatron_lm_prepare_model
from .megatron_lm import prepare_optimizer as megatron_lm_prepare_optimizer
from .megatron_lm import prepare_scheduler as megatron_lm_prepare_scheduler
from .memory import find_executable_batch_size, release_memory
from .other import (
    extract_model_from_parallel,
    get_pretty_name,
    is_port_in_use,
    merge_dicts,
    patch_environment,
    save,
    wait_for_everyone,
    write_basic_config,
)
from .random import set_seed, synchronize_rng_state, synchronize_rng_states
from .torch_xla import install_xla
from .tqdm import tqdm
from .transformer_engine import convert_model, has_transformer_engine_layers










"""simple docstring"""



import unittest
from pathlib import Path
from tempfile import TemporaryDirectory

from transformers import AutoConfig, TFGPTaLMHeadModel, is_keras_nlp_available, is_tf_available
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import require_keras_nlp, require_tf, slow


if is_tf_available():
  import tensorflow as tf

if is_keras_nlp_available():
  from transformers.models.gpta import TFGPTaTokenizer


__snake_case       =       ["""gpt2"""]
__snake_case       =       """gpt2"""

if is_tf_available():







  class _lowerCAmelCase							( tf.Module      ):







     def __init__(      self		,      UpperCamelCase__		)      ->						Optional[Any]:

         '''simple docstring'''




         super().__init__()
         snake_case       : Dict    =       tokenizer
         snake_case       : List[str]    =       AutoConfig.from_pretrained(UpperCamelCase__		)
         snake_case       : List[str]    =       TFGPTaLMHeadModel.from_config(UpperCamelCase__		)







     @tf.function(input_signature=(tf.TensorSpec((None,)		,      tf.string		,      name="text"		),)		)
     def 					lowerCamelCase						(      self		,      UpperCamelCase__		)      ->						Optional[int]:

         '''simple docstring'''




         snake_case       : List[Any]    =       self.tokenizer(UpperCamelCase__		)
         snake_case       : Tuple    =       tokenized["input_ids"].to_tensor()

         snake_case       : str    =       tf.cast(input_ids_dense > 0		,      tf.intaa		)
         # input_mask = tf.reshape(input_mask, [-1, MAX_SEQ_LEN])

         snake_case       : int    =       self.model(input_ids=UpperCamelCase__		,      attention_mask=UpperCamelCase__		)["logits"]

         return outputs







@require_tf
@require_keras_nlp
class _lowerCAmelCase							( unittest.TestCase      ):







   def 					lowerCamelCase						(      self		)      ->						str:

       '''simple docstring'''




       super().setUp()

       snake_case       : Optional[int]    =       [GPTaTokenizer.from_pretrained(UpperCamelCase__		) for checkpoint in (TOKENIZER_CHECKPOINTS)]
       snake_case       : str    =       [TFGPTaTokenizer.from_pretrained(UpperCamelCase__		) for checkpoint in TOKENIZER_CHECKPOINTS]
       assert len(self.tokenizers		) == len(self.tf_tokenizers		)

       snake_case       : Optional[int]    =       [
           "This is a straightforward English test sentence.",
           "This one has some weird characters\rto\nsee\r\nif  those\u00E9break things.",
           "Now we're going to add some Chinese: 一 二 三 一二三",
           "And some much more rare Chinese: 齉 堃 齉堃",
           "Je vais aussi écrire en français pour tester les accents",
           "Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ",
       ]
       snake_case       : str    =       list(zip(self.test_sentences		,      self.test_sentences[::-1]		)		)







   def 					lowerCamelCase						(      self		)      ->						List[Any]:

       '''simple docstring'''




       for tokenizer, tf_tokenizer in zip(self.tokenizers		,      self.tf_tokenizers		):
           for test_inputs in self.test_sentences:
               snake_case       : Any    =       tokenizer([test_inputs]		,      return_tensors="tf"		)
               snake_case       : str    =       tf_tokenizer([test_inputs]		)

               for key in python_outputs.keys():
                   # convert them to numpy to avoid messing with ragged tensors
                   snake_case       : Any    =       python_outputs[key].numpy()
                   snake_case       : Any    =       tf_outputs[key].numpy()

                   self.assertTrue(tf.reduce_all(python_outputs_values.shape == tf_outputs_values.shape		)		)
                   self.assertTrue(tf.reduce_all(tf.cast(UpperCamelCase__		,      tf.intaa		) == tf_outputs_values		)		)







   @slow
   def 					lowerCamelCase						(      self		)      ->						str:

       '''simple docstring'''




       for tf_tokenizer in self.tf_tokenizers:
           snake_case       : str    =       tf.function(UpperCamelCase__		)
           for test_inputs in self.test_sentences:
               snake_case       : str    =       tf.constant(UpperCamelCase__		)
               snake_case       : Optional[int]    =       compiled_tokenizer(UpperCamelCase__		)
               snake_case       : Dict    =       tf_tokenizer(UpperCamelCase__		)

               for key in eager_outputs.keys():
                   self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key]		)		)







   @slow
   def 					lowerCamelCase						(      self		)      ->						Any:

       '''simple docstring'''




       for tf_tokenizer in self.tf_tokenizers:
           snake_case       : Tuple    =       ModelToSave(tokenizer=UpperCamelCase__		)
           snake_case       : Tuple    =       tf.convert_to_tensor([self.test_sentences[0]]		)
           snake_case       : Union[str, Any]    =       model.serving(UpperCamelCase__		)  # Build model with some sample inputs
           with TemporaryDirectory() as tempdir:
               snake_case       : int    =       Path(UpperCamelCase__		) / "saved.model"
               tf.saved_model.save(UpperCamelCase__		,      UpperCamelCase__		,      signatures={"serving_default": model.serving}		)
               snake_case       : Optional[Any]    =       tf.saved_model.load(UpperCamelCase__		)
           snake_case       : Union[str, Any]    =       loaded_model.signatures["serving_default"](UpperCamelCase__		)["output_0"]
           # We may see small differences because the loaded model is compiled, so we need an epsilon for the test
           self.assertTrue(tf.reduce_all(out == loaded_output		)		)







   @slow
   def 					lowerCamelCase						(      self		)      ->						int:

       '''simple docstring'''




       for tf_tokenizer in self.tf_tokenizers:
           snake_case       : Any    =       tf.convert_to_tensor([self.test_sentences[0]]		)
           snake_case       : List[str]    =       tf_tokenizer(UpperCamelCase__		)  # Build model with some sample inputs

           snake_case       : Dict    =       tf_tokenizer.get_config()
           snake_case       : Union[str, Any]    =       TFGPTaTokenizer.from_config(UpperCamelCase__		)
           snake_case       : Optional[Any]    =       model_from_config(UpperCamelCase__		)

           for key in from_config_output.keys():
               self.assertTrue(tf.reduce_all(from_config_output[key] == out[key]		)		)







   @slow
   def 					lowerCamelCase						(      self		)      ->						Tuple:

       '''simple docstring'''




       for tf_tokenizer in self.tf_tokenizers:
           # for the test to run
           snake_case       : List[str]    =       12_3123

           for max_length in [3, 5, 1024]:
               snake_case       : str    =       tf.convert_to_tensor([self.test_sentences[0]]		)
               snake_case       : List[Any]    =       tf_tokenizer(UpperCamelCase__		,      max_length=UpperCamelCase__		)

               snake_case       : str    =       out["input_ids"].numpy().shape[1]

               assert out_length == max_length





