



'''simple docstring'''


from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
      import tensorflow as tf

      from transformers import (
          TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFTransfoXLForSequenceClassification,
          TFTransfoXLLMHeadModel,
          TFTransfoXLModel,
      )




class      __UpperCamelCase       :







 def __init__(    self ,				_lowerCAmelCase ,				)    ->    List[Any]:
       '''simple docstring'''






       lowercase        =							parent
       lowercase        =							13
       lowercase        =							7
       lowercase        =							30
       lowercase        =							self.seq_length + self.mem_len
       lowercase        =							15
       lowercase        =							True
       lowercase        =							True
       lowercase        =							99
       lowercase        =							[10, 50, 80]
       lowercase        =							32
       lowercase        =							32
       lowercase        =							4
       lowercase        =							8
       lowercase        =							128
       lowercase        =							2
       lowercase        =							2
       lowercase        =							None
       lowercase        =							1
       lowercase        =							0
       lowercase        =							3
       lowercase        =							self.vocab_size - 1
       lowercase        =							0.01







 def   _a   (    self						)    ->    Tuple:
       '''simple docstring'''






       lowercase        =							ids_tensor([self.batch_size, self.seq_length] ,				self.vocab_size						)
       lowercase        =							ids_tensor([self.batch_size, self.seq_length] ,				self.vocab_size						)

       lowercase        =							None
       if self.use_labels:
             lowercase        =							ids_tensor([self.batch_size, self.seq_length] ,				self.vocab_size						)

       lowercase        =							TransfoXLConfig(
           vocab_size=self.vocab_size ,				mem_len=self.mem_len ,				clamp_len=self.clamp_len ,				cutoffs=self.cutoffs ,				d_model=self.hidden_size ,				d_embed=self.d_embed ,				n_head=self.num_attention_heads ,				d_head=self.d_head ,				d_inner=self.d_inner ,				div_val=self.div_val ,				n_layer=self.num_hidden_layers ,				eos_token_id=self.eos_token_id ,				pad_token_id=self.vocab_size - 1 ,				init_range=self.init_range ,				num_labels=self.num_labels ,				)

       return (config, input_ids_a, input_ids_a, lm_labels)







 def   _a   (    self						)    ->    Tuple:
       '''simple docstring'''






       random.seed(self.seed						)
       tf.random.set_seed(self.seed						)







 def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    Optional[int]:
       '''simple docstring'''






       lowercase        =							TFTransfoXLModel(UpperCamelCase__						)

       lowercase     ,   lowercase        =							model(UpperCamelCase__						).to_tuple()

       lowercase        =							{"""input_ids""": input_ids_a, """mems""": mems_a}

       lowercase     ,   lowercase        =							model(UpperCamelCase__						).to_tuple()

       self.parent.assertEqual(hidden_states_a.shape ,				(self.batch_size, self.seq_length, self.hidden_size)						)
       self.parent.assertEqual(hidden_states_a.shape ,				(self.batch_size, self.seq_length, self.hidden_size)						)
       self.parent.assertListEqual(
           [mem.shape for mem in mems_a] ,				[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,				)
       self.parent.assertListEqual(
           [mem.shape for mem in mems_a] ,				[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,				)







 def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    str:
       '''simple docstring'''






       lowercase        =							TFTransfoXLLMHeadModel(UpperCamelCase__						)

       lowercase     ,   lowercase        =							model(UpperCamelCase__						).to_tuple()

       lowercase        =							{"""input_ids""": input_ids_a, """labels""": lm_labels}
       lowercase     ,   lowercase        =							model(UpperCamelCase__						).to_tuple()

       lowercase     ,   lowercase        =							model([input_ids_a, mems_a]						).to_tuple()

       lowercase        =							{"""input_ids""": input_ids_a, """mems""": mems_a, """labels""": lm_labels}

       lowercase     ,   lowercase        =							model(UpperCamelCase__						).to_tuple()

       self.parent.assertEqual(lm_logits_a.shape ,				(self.batch_size, self.seq_length, self.vocab_size)						)
       self.parent.assertListEqual(
           [mem.shape for mem in mems_a] ,				[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,				)

       self.parent.assertEqual(lm_logits_a.shape ,				(self.batch_size, self.seq_length, self.vocab_size)						)
       self.parent.assertListEqual(
           [mem.shape for mem in mems_a] ,				[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,				)







 def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    str:
       '''simple docstring'''






       lowercase        =							TFTransfoXLForSequenceClassification(UpperCamelCase__						)
       lowercase        =							model(UpperCamelCase__						)
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_labels)						)







 def   _a   (    self						)    ->    int:
       '''simple docstring'''






       lowercase        =							self.prepare_config_and_inputs()
       ((lowercase)     ,   (lowercase)     ,   (lowercase)     ,   (lowercase))        =							config_and_inputs
       lowercase        =							{"""input_ids""": input_ids_a}
       return config, inputs_dict




@require_tf
class      __UpperCamelCase       (_A			,   _A			,   unittest.TestCase			):
 __A			  =					(
     (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
 )
 __A			  =					() if is_tf_available() else ()
 __A			  =					(
     {
         '''feature-extraction''': TFTransfoXLModel,
         '''text-classification''': TFTransfoXLForSequenceClassification,
         '''text-generation''': TFTransfoXLLMHeadModel,
         '''zero-shot''': TFTransfoXLForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )
 # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
 __A			  =					False
 __A			  =					False
 __A			  =					False
 __A			  =					False







 def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    List[Any]:
       '''simple docstring'''






       if pipeline_test_casse_name == "TextGenerationPipelineTests":
             # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
             # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
             # tokenizer.
             return True

       return False







 def   _a   (    self						)    ->    Any:
       '''simple docstring'''






       lowercase        =							TFTransfoXLModelTester(self						)
       lowercase        =							ConfigTester(self ,				config_class=UpperCamelCase__ ,				d_embed=37						)







 def   _a   (    self						)    ->    Tuple:
       '''simple docstring'''






       self.config_tester.run_common_tests()







 def   _a   (    self						)    ->    Tuple:
       '''simple docstring'''






       self.model_tester.set_seed()
       lowercase        =							self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_model(*UpperCamelCase__						)







 def   _a   (    self						)    ->    Optional[int]:
       '''simple docstring'''






       self.model_tester.set_seed()
       lowercase        =							self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_lm_head(*UpperCamelCase__						)







 def   _a   (    self						)    ->    Optional[Any]:
       '''simple docstring'''






       lowercase        =							self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*UpperCamelCase__						)







 def   _a   (    self						)    ->    Tuple:
       '''simple docstring'''






       lowercase     ,   lowercase        =							self.model_tester.prepare_config_and_inputs_for_common()
       lowercase        =							[TFTransfoXLForSequenceClassification]

       for model_class in self.all_model_classes:
             lowercase        =							model_class(UpperCamelCase__						)
             assert isinstance(model.get_input_embeddings() ,				tf.keras.layers.Layer						)
             if model_class in list_other_models_with_output_ebd:
                   lowercase        =							model.get_output_embeddings()
                   assert isinstance(UpperCamelCase__ ,				tf.keras.layers.Layer						)
                   lowercase        =							model.get_bias()
                   assert name is None
             else:
                   lowercase        =							model.get_output_embeddings()
                   assert x is None
                   lowercase        =							model.get_bias()
                   assert name is None







 def   _a   (    self						)    ->    Optional[Any]:
       '''simple docstring'''






       pass







 @slow
 def   _a   (    self						)    ->    int:
       '''simple docstring'''






       for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowercase        =							TFTransfoXLModel.from_pretrained(UpperCamelCase__						)
             self.assertIsNotNone(UpperCamelCase__						)







 @unittest.skip(reason="""This model doesn't play well with fit() due to not returning a single loss."""						)
 def   _a   (    self						)    ->    Tuple:
       '''simple docstring'''






       pass




@require_tf
class      __UpperCamelCase       (unittest.TestCase			):







 @unittest.skip("""Skip test until #12651 is resolved."""						)
 @slow
 def   _a   (    self						)    ->    List[Any]:
       '''simple docstring'''






       lowercase        =							TFTransfoXLLMHeadModel.from_pretrained("""transfo-xl-wt103"""						)
       # fmt: off
       lowercase        =							tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0]] ,				dtype=tf.intaa						)  # noqa: E231
       # fmt: on
       #  In 1991 , the remains of Russian Tsar Nicholas II and his family
       #  ( except for Alexei and Maria ) are discovered .
       #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
       #  remainder of the story . 1883 Western Siberia ,
       #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
       #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
       #  father initially slaps him for making such an accusation , Rasputin watches as the
       #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
       #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
       #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

       # fmt: off
       lowercase        =							[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0,33,1,1857,2,1,1009,4,1109,1_1739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,0]  # noqa: E231
       # fmt: on
       #  In 1991, the remains of Russian Tsar Nicholas II and his family (
       #  except for Alexei and Maria ) are discovered. The voice of young son,
       #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
       #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
       #  and a group of men to perform magic. Rasputin has a vision and
       #  denounces one of the men as a horse thief. Although his father initially
       #  slaps him for making such an accusation, Rasputin watches as the man
       #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
       #  of the Virgin Mary, prompting him to become a priest.
       #  Rasputin quickly becomes famous, with people, even a bishop, begging for
       #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
       # Nicholas II and his family were discovered. The voice of <unk> young son,
       # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

       lowercase        =							model.generate(UpperCamelCase__ ,				max_length=200 ,				do_sample=UpperCamelCase__						)
       self.assertListEqual(output_ids[0].numpy().tolist() ,				UpperCamelCase__						)







'''simple docstring'''


from random import shuffle

import tensorflow as tf
from numpy import array







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      List[str] ,  lowercase_    :      Optional[int]						):
						lowercase        =							int(lowercase_						)
						assert noofclusters < len(lowercase_						)

						# Find out the dimensionality
						lowercase        =							len(vectors[0]						)

						# Will help select random centroids from among the available vectors
						lowercase        =							list(range(len(lowercase_						)						)						)
						shuffle(lowercase_						)

						# GRAPH OF COMPUTATION
						# We initialize a new graph and set it as the default during each run
						# of this algorithm. This ensures that as this function is called
						# multiple times, the default graph doesn't keep getting crowded with
						# unused ops and Variables from previous function calls.

						lowercase        =							tf.Graph()

						with graph.as_default():
												# SESSION OF COMPUTATION

												lowercase        =							tf.Session()

												##CONSTRUCTING THE ELEMENTS OF COMPUTATION

												##First lets ensure we have a Variable vector for each centroid,
												##initialized to one of the vectors from the available data points
												lowercase        =							[
												    tf.Variable(vectors[vector_indices[i]]						) for i in range(lowercase_						)
												]
												##These nodes will assign the centroid Variables the appropriate
												##values
												lowercase        =							tf.placeholder("""float64""" ,  [dim]						)
												lowercase        =							[]
												for centroid in centroids:
																		cent_assigns.append(tf.assign(lowercase_ ,  lowercase_						)						)

												##Variables for cluster assignments of individual vectors(initialized
												##to 0 at first)
												lowercase        =							[tf.Variable(0						) for i in range(len(lowercase_						)						)]
												##These nodes will assign an assignment Variable the appropriate
												##value
												lowercase        =							tf.placeholder("""int32"""						)
												lowercase        =							[]
												for assignment in assignments:
																		cluster_assigns.append(tf.assign(lowercase_ ,  lowercase_						)						)

												##Now lets construct the node that will compute the mean
												# The placeholder for the input
												lowercase        =							tf.placeholder("""float""" ,  [None, dim]						)
												# The Node/op takes the input and computes a mean along the 0th
												# dimension, i.e. the list of input vectors
												lowercase        =							tf.reduce_mean(lowercase_ ,  0						)

												##Node for computing Euclidean distances
												# Placeholders for input
												lowercase        =							tf.placeholder("""float""" ,  [dim]						)
												lowercase        =							tf.placeholder("""float""" ,  [dim]						)
												lowercase        =							tf.sqrt(tf.reduce_sum(tf.pow(tf.sub(lowercase_ ,  lowercase_						) ,  2						)						)						)

												##This node will figure out which cluster to assign a vector to,
												##based on Euclidean distances of the vector from the centroids.
												# Placeholder for input
												lowercase        =							tf.placeholder("""float""" ,  [noofclusters]						)
												lowercase        =							tf.argmin(lowercase_ ,  0						)

												##INITIALIZING STATE VARIABLES

												##This will help initialization of all Variables defined with respect
												##to the graph. The Variable-initializer should be defined after
												##all the Variables have been constructed, so that each of them
												##will be included in the initialization.
												lowercase        =							tf.initialize_all_variables()

												# Initialize all variables
												sess.run(lowercase_						)

												##CLUSTERING ITERATIONS

												# Now perform the Expectation-Maximization steps of K-Means clustering
												# iterations. To keep things simple, we will only do a set number of
												# iterations, instead of using a Stopping Criterion.
												lowercase        =							100
												for _ in range(lowercase_						):
																		##EXPECTATION STEP
																		##Based on the centroid locations till last iteration, compute
																		##the _expected_ centroid assignments.
																		# Iterate over each vector
																		for vector_n in range(len(lowercase_						)						):
																								lowercase        =							vectors[vector_n]
																								# Compute Euclidean distance between this vector and each
																								# centroid. Remember that this list cannot be named
																								#'centroid_distances', since that is the input to the
																								# cluster assignment node.
																								lowercase        =							[
																								    sess.run(lowercase_ ,  feed_dict={va: vect, va: sess.run(lowercase_						)}						)
																								    for centroid in centroids
																								]
																								# Now use the cluster assignment node, with the distances
																								# as the input
																								lowercase        =							sess.run(
																								    lowercase_ ,  feed_dict={centroid_distances: distances}						)
																								# Now assign the value to the appropriate state variable
																								sess.run(
																								    cluster_assigns[vector_n] ,  feed_dict={assignment_value: assignment}						)

																		##MAXIMIZATION STEP
																		# Based on the expected state computed from the Expectation Step,
																		# compute the locations of the centroids so as to maximize the
																		# overall objective of minimizing within-cluster Sum-of-Squares
																		for cluster_n in range(lowercase_						):
																								# Collect all the vectors assigned to this cluster
																								lowercase        =							[
																								    vectors[i]
																								    for i in range(len(lowercase_						)						)
																								    if sess.run(assignments[i]						) == cluster_n
																								]
																								# Compute new centroid location
																								lowercase        =							sess.run(
																								    lowercase_ ,  feed_dict={mean_input: array(lowercase_						)}						)
																								# Assign value to appropriate variable
																								sess.run(
																								    cent_assigns[cluster_n] ,  feed_dict={centroid_value: new_location}						)

        # Return centroids and assignments
												lowercase        =							sess.run(lowercase_						)
												lowercase        =							sess.run(lowercase_						)
												return centroids, assignments


