

'''simple docstring'''



from random import shuffle

import tensorflow as tf
from numpy import array







def   a__			(    a__ ,       a__		):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE      = int(a__		)
     assert noofclusters < len(a__		)

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

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

     # 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.

     __SCREAMING_SNAKE_CASE      = tf.Graph()

     with graph.as_default():
          # SESSION OF COMPUTATION

          __SCREAMING_SNAKE_CASE      = 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
          __SCREAMING_SNAKE_CASE      = [
              tf.Variable(vectors[vector_indices[i]]		) for i in range(a__		)
          ]
          ##These nodes will assign the centroid Variables the appropriate
          ##values
          __SCREAMING_SNAKE_CASE      = tf.placeholder("""float64""" ,       [dim]		)
          __SCREAMING_SNAKE_CASE      = []
          for centroid in centroids:
               cent_assigns.append(tf.assign(a__ ,       a__		)		)

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

          ##Now lets construct the node that will compute the mean
          # The placeholder for the input
          __SCREAMING_SNAKE_CASE      = 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
          __SCREAMING_SNAKE_CASE      = tf.reduce_mean(a__ ,       0		)

          ##Node for computing Euclidean distances
          # Placeholders for input
          __SCREAMING_SNAKE_CASE      = tf.placeholder("""float""" ,       [dim]		)
          __SCREAMING_SNAKE_CASE      = tf.placeholder("""float""" ,       [dim]		)
          __SCREAMING_SNAKE_CASE      = tf.sqrt(tf.reduce_sum(tf.pow(tf.sub(a__ ,       a__		) ,       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
          __SCREAMING_SNAKE_CASE      = tf.placeholder("""float""" ,       [noofclusters]		)
          __SCREAMING_SNAKE_CASE      = tf.argmin(a__ ,       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.
          __SCREAMING_SNAKE_CASE      = tf.initialize_all_variables()

          # Initialize all variables
          sess.run(a__		)

          ##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.
          __SCREAMING_SNAKE_CASE      = 1_00
          for _ in range(a__		):
               ##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(a__		)		):
                    __SCREAMING_SNAKE_CASE      = 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.
                    __SCREAMING_SNAKE_CASE      = [
                        sess.run(a__ ,       feed_dict={va: vect, va: sess.run(a__		)}		)
                        for centroid in centroids
                    ]
                    # Now use the cluster assignment node, with the distances
                    # as the input
                    __SCREAMING_SNAKE_CASE      = sess.run(
                        a__ ,       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(a__		):
                    # Collect all the vectors assigned to this cluster
                    __SCREAMING_SNAKE_CASE      = [
                        vectors[i]
                        for i in range(len(a__		)		)
                        if sess.run(assignments[i]		) == cluster_n
                    ]
                    # Compute new centroid location
                    __SCREAMING_SNAKE_CASE      = sess.run(
                        a__ ,       feed_dict={mean_input: array(a__		)}		)
                    # Assign value to appropriate variable
                    sess.run(
                        cent_assigns[cluster_n] ,       feed_dict={centroid_value: new_location}		)

        # Return centroids and assignments
          __SCREAMING_SNAKE_CASE      = sess.run(a__		)
          __SCREAMING_SNAKE_CASE      = sess.run(a__		)
          return centroids, assignments









'''simple docstring'''



import unittest

from transformers import LiltConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      LiltForQuestionAnswering,
      LiltForSequenceClassification,
      LiltForTokenClassification,
      LiltModel,
  )
  from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST







class 		lowerCAmelCase__  :



 """simple docstring"""



 def __init__(						self   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			str=13   ,				__SCREAMING_SNAKE_CASE   :			int=7   ,				__SCREAMING_SNAKE_CASE   :			List[str]=True   ,				__SCREAMING_SNAKE_CASE   :			Any=True   ,				__SCREAMING_SNAKE_CASE   :			str=True   ,				__SCREAMING_SNAKE_CASE   :			str=True   ,				__SCREAMING_SNAKE_CASE   :			Dict=99   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]=24   ,				__SCREAMING_SNAKE_CASE   :			Any=2   ,				__SCREAMING_SNAKE_CASE   :			Any=6   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]=37   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]="gelu"   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]=0.1   ,				__SCREAMING_SNAKE_CASE   :			List[Any]=0.1   ,				__SCREAMING_SNAKE_CASE   :			int=512   ,				__SCREAMING_SNAKE_CASE   :			str=16   ,				__SCREAMING_SNAKE_CASE   :			Any=2   ,				__SCREAMING_SNAKE_CASE   :			List[str]=0.02   ,				__SCREAMING_SNAKE_CASE   :			int=3   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]=None   ,				__SCREAMING_SNAKE_CASE   :			List[Any]=1_000   ,				)    ->					int:


      """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_token_type_ids
      __SCREAMING_SNAKE_CASE      = use_labels
      __SCREAMING_SNAKE_CASE      = vocab_size
      __SCREAMING_SNAKE_CASE      = hidden_size
      __SCREAMING_SNAKE_CASE      = num_hidden_layers
      __SCREAMING_SNAKE_CASE      = num_attention_heads
      __SCREAMING_SNAKE_CASE      = intermediate_size
      __SCREAMING_SNAKE_CASE      = hidden_act
      __SCREAMING_SNAKE_CASE      = hidden_dropout_prob
      __SCREAMING_SNAKE_CASE      = attention_probs_dropout_prob
      __SCREAMING_SNAKE_CASE      = max_position_embeddings
      __SCREAMING_SNAKE_CASE      = type_vocab_size
      __SCREAMING_SNAKE_CASE      = type_sequence_label_size
      __SCREAMING_SNAKE_CASE      = initializer_range
      __SCREAMING_SNAKE_CASE      = num_labels
      __SCREAMING_SNAKE_CASE      = scope
      __SCREAMING_SNAKE_CASE      = range_bbox
 def  UpperCAmelCase__						(						self   :			Union[str, Any]     )    ->					Optional[int]:


      """simple docstring"""




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

      __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.seq_length, 4]   ,				self.range_bbox     )
      # Ensure that bbox is legal
      for i in range(bbox.shape[0]     ):
           for j in range(bbox.shape[1]     ):
                if bbox[i, j, 3] < bbox[i, j, 1]:
                     __SCREAMING_SNAKE_CASE      = bbox[i, j, 3]
                     __SCREAMING_SNAKE_CASE      = bbox[i, j, 1]
                     __SCREAMING_SNAKE_CASE      = t
                if bbox[i, j, 2] < bbox[i, j, 0]:
                     __SCREAMING_SNAKE_CASE      = bbox[i, j, 2]
                     __SCREAMING_SNAKE_CASE      = bbox[i, j, 0]
                     __SCREAMING_SNAKE_CASE      = t

      __SCREAMING_SNAKE_CASE      = None
      if self.use_input_mask:
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.seq_length]   ,				vocab_size=2     )

      __SCREAMING_SNAKE_CASE      = None
      if self.use_token_type_ids:
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.seq_length]   ,				self.type_vocab_size     )

      __SCREAMING_SNAKE_CASE      = None
      __SCREAMING_SNAKE_CASE      = None
      if self.use_labels:
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size]   ,				self.type_sequence_label_size     )
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.seq_length]   ,				self.num_labels     )

      __SCREAMING_SNAKE_CASE      = self.get_config()

      return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels
 def  UpperCAmelCase__						(						self   :			str     )    ->					int:


      """simple docstring"""




      return LiltConfig(
          vocab_size=self.vocab_size   ,				hidden_size=self.hidden_size   ,				num_hidden_layers=self.num_hidden_layers   ,				num_attention_heads=self.num_attention_heads   ,				intermediate_size=self.intermediate_size   ,				hidden_act=self.hidden_act   ,				hidden_dropout_prob=self.hidden_dropout_prob   ,				attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,				max_position_embeddings=self.max_position_embeddings   ,				type_vocab_size=self.type_vocab_size   ,				initializer_range=self.initializer_range   ,				)
 def  UpperCAmelCase__						(						self   :			int   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			str   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			int   ,				)    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = LiltModel(config=__SCREAMING_SNAKE_CASE     )
      model.to(__SCREAMING_SNAKE_CASE     )
      model.eval()
      __SCREAMING_SNAKE_CASE      = model(__SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE   ,				attention_mask=__SCREAMING_SNAKE_CASE   ,				token_type_ids=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = model(__SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE   ,				token_type_ids=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = model(__SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE     )

      self.parent.assertEqual(result.last_hidden_state.shape   ,				(self.batch_size, self.seq_length, self.hidden_size)     )
      self.parent.assertEqual(result.pooler_output.shape   ,				(self.batch_size, self.hidden_size)     )
 def  UpperCAmelCase__						(						self   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]   ,				__SCREAMING_SNAKE_CASE   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				)    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.num_labels
      __SCREAMING_SNAKE_CASE      = LiltForTokenClassification(config=__SCREAMING_SNAKE_CASE     )
      model.to(__SCREAMING_SNAKE_CASE     )
      model.eval()
      __SCREAMING_SNAKE_CASE      = model(
          __SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE   ,				attention_mask=__SCREAMING_SNAKE_CASE   ,				token_type_ids=__SCREAMING_SNAKE_CASE   ,				labels=__SCREAMING_SNAKE_CASE     )
      self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.seq_length, self.num_labels)     )
 def  UpperCAmelCase__						(						self   :			int   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			Any   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]   ,				)    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = LiltForQuestionAnswering(config=__SCREAMING_SNAKE_CASE     )
      model.to(__SCREAMING_SNAKE_CASE     )
      model.eval()
      __SCREAMING_SNAKE_CASE      = model(
          __SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE   ,				attention_mask=__SCREAMING_SNAKE_CASE   ,				token_type_ids=__SCREAMING_SNAKE_CASE   ,				start_positions=__SCREAMING_SNAKE_CASE   ,				end_positions=__SCREAMING_SNAKE_CASE   ,				)
      self.parent.assertEqual(result.start_logits.shape   ,				(self.batch_size, self.seq_length)     )
      self.parent.assertEqual(result.end_logits.shape   ,				(self.batch_size, self.seq_length)     )


 def  UpperCAmelCase__						(						self   :			Dict     )    ->					str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.prepare_config_and_inputs()
      (
          (
          __SCREAMING_SNAKE_CASE
      )  ,     (
          __SCREAMING_SNAKE_CASE
      )  ,     (
          __SCREAMING_SNAKE_CASE
      )  ,     (
          __SCREAMING_SNAKE_CASE
      )  ,     (
          __SCREAMING_SNAKE_CASE
      )  ,     (
          __SCREAMING_SNAKE_CASE
      )  ,     (
          __SCREAMING_SNAKE_CASE
      )  ,     
      )      = config_and_inputs
      __SCREAMING_SNAKE_CASE      = {
          """input_ids""": input_ids,
          """bbox""": bbox,
          """token_type_ids""": token_type_ids,
          """attention_mask""": input_mask,
      }
      return config, inputs_dict







@require_torch
class 		lowerCAmelCase__  ( a					,   a					,   a					,   unittest.TestCase   ):



 """simple docstring"""



 lowerCAmelCase__       = (
     (
         LiltModel,
         LiltForSequenceClassification,
         LiltForTokenClassification,
         LiltForQuestionAnswering,
     )
     if is_torch_available()
     else ()
 )
 lowerCAmelCase__       = (
     {
         "feature-extraction": LiltModel,
         "question-answering": LiltForQuestionAnswering,
         "text-classification": LiltForSequenceClassification,
         "token-classification": LiltForTokenClassification,
         "zero-shot": LiltForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 lowerCAmelCase__       = False
 lowerCAmelCase__       = False
 def  UpperCAmelCase__						(						self   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			Any   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			str   ,				__SCREAMING_SNAKE_CASE   :			int     )    ->					str:


      """simple docstring"""




      return True
 def  UpperCAmelCase__						(						self   :			List[Any]     )    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = LiltModelTester(self     )
      __SCREAMING_SNAKE_CASE      = ConfigTester(self   ,				config_class=__SCREAMING_SNAKE_CASE   ,				hidden_size=37     )
 def  UpperCAmelCase__						(						self   :			int     )    ->					Any:


      """simple docstring"""




      self.config_tester.run_common_tests()
 def  UpperCAmelCase__						(						self   :			Optional[Any]     )    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			List[str]     )    ->					Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
           __SCREAMING_SNAKE_CASE      = type
           self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			int     )    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			Any     )    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE     )


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


      """simple docstring"""




      for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           __SCREAMING_SNAKE_CASE      = LiltModel.from_pretrained(__SCREAMING_SNAKE_CASE     )
           self.assertIsNotNone(__SCREAMING_SNAKE_CASE     )







@require_torch
@slow
class 		lowerCAmelCase__  ( unittest.TestCase   ):



 """simple docstring"""



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


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = LiltModel.from_pretrained("""SCUT-DLVCLab/lilt-roberta-en-base"""     ).to(__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = torch.tensor([[1, 2]]   ,				device=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]   ,				device=__SCREAMING_SNAKE_CASE     )

      # forward pass
      with torch.no_grad():
           __SCREAMING_SNAKE_CASE      = model(input_ids=__SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = torch.Size([1, 2, 768]     )
      __SCREAMING_SNAKE_CASE      = torch.tensor(
          [[-0.0653, 0.0950, -0.0061], [-0.0545, 0.0926, -0.0324]]   ,				device=__SCREAMING_SNAKE_CASE   ,				)

      self.assertTrue(outputs.last_hidden_state.shape   ,				__SCREAMING_SNAKE_CASE     )
      self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3]   ,				__SCREAMING_SNAKE_CASE   ,				atol=1E-3     )     )






