

'''simple docstring'''
from __future__ import annotations

import unittest

from transformers import XGLMConfig, XGLMTokenizer, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers.models.xglm.modeling_tf_xglm import (
     TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
     TFXGLMForCausalLM,
     TFXGLMModel,
 )







@require_tf
class 							A__   :
  A__					=    XGLMConfig
  A__					=    {}
  A__					=    '''gelu'''





  def __init__(		self				:     Optional[int]							, _a				:     Any							, _a				:     Dict=14							, _a				:     Optional[int]=7							, _a				:     Dict=True							, _a				:     int=True							, _a				:     List[Any]=True							, _a				:     int=99							, _a				:     Optional[Any]=32							, _a				:     Any=2							, _a				:     Any=4							, _a				:     List[Any]=37							, _a				:     List[str]="gelu"							, _a				:     Any=0.1							, _a				:     Optional[int]=0.1							, _a				:     Tuple=512							, _a				:     str=0.02							, )     ->   str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =parent
       _SCREAMING_SNAKE_CASE							   =batch_size
       _SCREAMING_SNAKE_CASE							   =seq_length
       _SCREAMING_SNAKE_CASE							   =is_training
       _SCREAMING_SNAKE_CASE							   =use_input_mask
       _SCREAMING_SNAKE_CASE							   =use_labels
       _SCREAMING_SNAKE_CASE							   =vocab_size
       _SCREAMING_SNAKE_CASE							   =d_model
       _SCREAMING_SNAKE_CASE							   =num_hidden_layers
       _SCREAMING_SNAKE_CASE							   =num_attention_heads
       _SCREAMING_SNAKE_CASE							   =ffn_dim
       _SCREAMING_SNAKE_CASE							   =activation_function
       _SCREAMING_SNAKE_CASE							   =activation_dropout
       _SCREAMING_SNAKE_CASE							   =attention_dropout
       _SCREAMING_SNAKE_CASE							   =max_position_embeddings
       _SCREAMING_SNAKE_CASE							   =initializer_range
       _SCREAMING_SNAKE_CASE							   =None
       _SCREAMING_SNAKE_CASE							   =0
       _SCREAMING_SNAKE_CASE							   =2
       _SCREAMING_SNAKE_CASE							   =1





  def 						A  (		self				:     Optional[int]			)     ->   List[Any]:





       '''simple docstring'''






       return XGLMConfig.from_pretrained('facebook/xglm-564M'			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =tf.clip_by_value(
           ids_tensor([self.batch_size, self.seq_length]							, self.vocab_size			)							, clip_value_min=0							, clip_value_max=3			)

       _SCREAMING_SNAKE_CASE							   =None
       if self.use_input_mask:
            _SCREAMING_SNAKE_CASE							   =random_attention_mask([self.batch_size, self.seq_length]			)

       _SCREAMING_SNAKE_CASE							   =self.get_config()

       _SCREAMING_SNAKE_CASE							   =floats_tensor([self.num_hidden_layers, self.num_attention_heads]							, 2			)

       return (
           config,
           input_ids,
           input_mask,
           head_mask,
       )





  def 						A  (		self				:     Union[str, Any]			)     ->   Optional[Any]:





       '''simple docstring'''






       return XGLMConfig(
           vocab_size=self.vocab_size							, d_model=self.hidden_size							, num_layers=self.num_hidden_layers							, attention_heads=self.num_attention_heads							, ffn_dim=self.ffn_dim							, activation_function=self.activation_function							, activation_dropout=self.activation_dropout							, attention_dropout=self.attention_dropout							, max_position_embeddings=self.max_position_embeddings							, initializer_range=self.initializer_range							, use_cache=_a							, bos_token_id=self.bos_token_id							, eos_token_id=self.eos_token_id							, pad_token_id=self.pad_token_id							, return_dict=_a							, )





  def 						A  (		self				:     Dict			)     ->   Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.prepare_config_and_inputs()

       (
           (
           _SCREAMING_SNAKE_CASE				
       )   ,						(
           _SCREAMING_SNAKE_CASE				
       )   ,						(
           _SCREAMING_SNAKE_CASE				
       )   ,						(
           _SCREAMING_SNAKE_CASE				
       )   ,										
       )							   =config_and_inputs

       _SCREAMING_SNAKE_CASE							   ={
           'input_ids': input_ids,
           'head_mask': head_mask,
       }

       return config, inputs_dict







@require_tf
class 							A__   (	A__					,       A__					,       unittest.TestCase  ):
  A__					=    (TFXGLMModel, TFXGLMForCausalLM) if is_tf_available() else ()
  A__					=    (TFXGLMForCausalLM,) if is_tf_available() else ()
  A__					=    (
      {'''feature-extraction''': TFXGLMModel, '''text-generation''': TFXGLMForCausalLM} if is_tf_available() else {}
  )
  A__					=    False
  A__					=    False
  A__					=    False





  def 						A  (		self				:     List[Any]			)     ->   int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFXGLMModelTester(self			)
       _SCREAMING_SNAKE_CASE							   =ConfigTester(self							, config_class=_a							, n_embd=37			)





  def 						A  (		self				:     Any			)     ->   Dict:





       '''simple docstring'''






       self.config_tester.run_common_tests()





  @slow
  def 						A  (		self				:     Any			)     ->   Union[str, Any]:





       '''simple docstring'''






       for model_name in TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            _SCREAMING_SNAKE_CASE							   =TFXGLMModel.from_pretrained(_a			)
            self.assertIsNotNone(_a			)





  @unittest.skip(reason='Currently, model embeddings are going to undergo a major refactor.'			)
  def 						A  (		self				:     int			)     ->   List[str]:





       '''simple docstring'''






       super().test_resize_token_embeddings()







@require_tf
class 							A__   (	unittest.TestCase  ):





  @slow
  def 						A  (		self				:     List[str]							, _a				:     str=True			)     ->   Optional[int]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M'			)
       _SCREAMING_SNAKE_CASE							   =tf.convert_to_tensor([[2, 268, 9865]]							, dtype=tf.intaa			)  # The dog
       # </s> The dog is a very friendly dog. He is very affectionate and loves to play with other
       # fmt: off
       _SCREAMING_SNAKE_CASE							   =[2, 268, 9865, 67, 11, 1988, 5_7252, 9865, 5, 984, 67, 1988, 21_3838, 1658, 53, 7_0446, 33, 6657, 278, 1581]
       # fmt: on
       _SCREAMING_SNAKE_CASE							   =model.generate(_a							, do_sample=_a							, num_beams=1			)
       if verify_outputs:
            self.assertListEqual(output_ids[0].numpy().tolist()							, _a			)





  @slow
  def 						A  (		self				:     Dict			)     ->   int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =XGLMTokenizer.from_pretrained('facebook/xglm-564M'			)
       _SCREAMING_SNAKE_CASE							   =TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M'			)

       tf.random.set_seed(0			)
       _SCREAMING_SNAKE_CASE							   =tokenizer('Today is a nice day and'							, return_tensors='tf'			)
       _SCREAMING_SNAKE_CASE							   =tokenized.input_ids
       # forces the generation to happen on CPU, to avoid GPU-related quirks (and assure same output regardless of the available devices)
       with tf.device(':/CPU:0'			):
            _SCREAMING_SNAKE_CASE							   =model.generate(_a							, do_sample=_a							, seed=[7, 0]			)
       _SCREAMING_SNAKE_CASE							   =tokenizer.decode(output_ids[0]							, skip_special_tokens=_a			)

       _SCREAMING_SNAKE_CASE							   =(
           'Today is a nice day and warm evening here over Southern Alberta!! Today when they closed schools due'
       )
       self.assertEqual(_a							, _a			)





  @slow
  def 						A  (		self				:     List[Any]			)     ->   Any:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M'			)
       _SCREAMING_SNAKE_CASE							   =XGLMTokenizer.from_pretrained('facebook/xglm-564M'			)

       _SCREAMING_SNAKE_CASE							   ='left'

       # use different length sentences to test batching
       _SCREAMING_SNAKE_CASE							   =[
           'This is an extremelly long sentence that only exists to test the ability of the model to cope with '
           'left-padding, such as in batched generation. The output for the sequence below should be the same '
           'regardless of whether left padding is applied or not. When',
           'Hello, my dog is a little',
       ]

       _SCREAMING_SNAKE_CASE							   =tokenizer(_a							, return_tensors='tf'							, padding=_a			)
       _SCREAMING_SNAKE_CASE							   =inputs['input_ids']

       _SCREAMING_SNAKE_CASE							   =model.generate(input_ids=_a							, attention_mask=inputs['attention_mask']							, max_new_tokens=12			)

       _SCREAMING_SNAKE_CASE							   =tokenizer(sentences[0]							, return_tensors='tf'			).input_ids
       _SCREAMING_SNAKE_CASE							   =model.generate(input_ids=_a							, max_new_tokens=12			)

       _SCREAMING_SNAKE_CASE							   =tokenizer(sentences[1]							, return_tensors='tf'			).input_ids
       _SCREAMING_SNAKE_CASE							   =model.generate(input_ids=_a							, max_new_tokens=12			)

       _SCREAMING_SNAKE_CASE							   =tokenizer.batch_decode(_a							, skip_special_tokens=_a			)
       _SCREAMING_SNAKE_CASE							   =tokenizer.decode(output_non_padded[0]							, skip_special_tokens=_a			)
       _SCREAMING_SNAKE_CASE							   =tokenizer.decode(output_padded[0]							, skip_special_tokens=_a			)

       _SCREAMING_SNAKE_CASE							   =[
           'This is an extremelly long sentence that only exists to test the ability of the model to cope with '
           'left-padding, such as in batched generation. The output for the sequence below should be the same '
           'regardless of whether left padding is applied or not. When left padding is applied, the sequence will be '
           'a single',
           'Hello, my dog is a little bit of a shy one, but he is very friendly',
       ]
       self.assertListEqual(_a							, _a			)
       self.assertListEqual(_a							, [non_padded_sentence, padded_sentence]			)



'''simple docstring'''
import warnings


warnings.warn(
    "memory_utils has been reorganized to utils.memory. Import `find_executable_batchsize` from the main `__init__`: "
    "`from accelerate import find_executable_batch_size` to avoid this warning.",
    FutureWarning,
)
