






from random import shuffle

import tensorflow as tf
from numpy import array





def 	lowerCAmelCase_		(lowercase__						:       List[str]     ,					lowercase__						:       Optional[int]       )		->    Dict:


				'''simple docstring'''




				lowerCAmelCase__      			=						int(lowercase__       )
				assert noofclusters < len(lowercase__       )

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

				# Will help select random centroids from among the available vectors
				lowerCAmelCase__      			=						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.

				lowerCAmelCase__      			=						tf.Graph()

				with graph.as_default():
								# SESSION OF COMPUTATION

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

								##Variables for cluster assignments of individual vectors(initialized
								##to 0 at first)
								lowerCAmelCase__      			=						[tf.Variable(0       ) for i in range(len(lowercase__       )       )]
								##These nodes will assign an assignment Variable the appropriate
								##value
								lowerCAmelCase__      			=						tf.placeholder('''int32'''       )
								lowerCAmelCase__      			=						[]
								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
								lowerCAmelCase__      			=						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
								lowerCAmelCase__      			=						tf.reduce_mean(lowercase__     ,					0       )

								##Node for computing Euclidean distances
								# Placeholders for input
								lowerCAmelCase__      			=						tf.placeholder('''float'''     ,					[dim]       )
								lowerCAmelCase__      			=						tf.placeholder('''float'''     ,					[dim]       )
								lowerCAmelCase__      			=						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
								lowerCAmelCase__      			=						tf.placeholder('''float'''     ,					[noofclusters]       )
								lowerCAmelCase__      			=						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.
								lowerCAmelCase__      			=						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.
								lowerCAmelCase__      			=						1_00
								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__       )       ):
																lowerCAmelCase__      			=						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.
																lowerCAmelCase__      			=						[
																    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
																lowerCAmelCase__      			=						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
																lowerCAmelCase__      			=						[
																    vectors[i]
																    for i in range(len(lowercase__       )       )
																    if sess.run(assignments[i]       ) == cluster_n
																]
																# Compute new centroid location
																lowerCAmelCase__      			=						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
								lowerCAmelCase__      			=						sess.run(lowercase__       )
								lowerCAmelCase__      			=						sess.run(lowercase__       )
								return centroids, assignments













import doctest
import logging
import os
import unittest
from pathlib import Path
from typing import List, Union

import transformers
from transformers.testing_utils import require_tf, require_torch, slow


_UpperCAmelCase			:		List[Any]   				=    logging.getLogger()
@unittest.skip('Temporarily disable the doc tests.'					)
@require_torch
@require_tf
@slow
class  lowerCAmelCase_       (				unittest.TestCase					):




							def 						__snake_case					(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Path ,							SCREAMING_SNAKE_CASE_     :   Union[str, None] = None ,							SCREAMING_SNAKE_CASE_     :   Union[List[str], None] = None ,							SCREAMING_SNAKE_CASE_     :   Union[str, List[str], None] = None ,							SCREAMING_SNAKE_CASE_     :   bool = True ,							):
											lowerCAmelCase__      			=						[file for file in os.listdir(SCREAMING_SNAKE_CASE_	) if os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)	)]

											if identifier is not None:
															lowerCAmelCase__      			=						[file for file in files if identifier in file]

											if n_identifier is not None:
															if isinstance(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	):
																			for n_ in n_identifier:
																							lowerCAmelCase__      			=						[file for file in files if n_ not in file]
															else:
																			lowerCAmelCase__      			=						[file for file in files if n_identifier not in file]

											lowerCAmelCase__      			=						ignore_files or []
											ignore_files.append('''__init__.py'''	)
											lowerCAmelCase__      			=						[file for file in files if file not in ignore_files]

											for file in files:
															# Open all files
															print('''Testing''' ,							SCREAMING_SNAKE_CASE_	)

															if only_modules:
																			lowerCAmelCase__      			=						file.split('''.'''	)[0]
																			try:
																							lowerCAmelCase__      			=						getattr(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)
																							lowerCAmelCase__      			=						doctest.DocTestSuite(SCREAMING_SNAKE_CASE_	)
																							lowerCAmelCase__      			=						unittest.TextTestRunner().run(SCREAMING_SNAKE_CASE_	)
																							self.assertIs(len(result.failures	) ,							0	)
																			except AttributeError:
																							logger.info(f'{module_identifier} is not a module.'	)
															else:
																			lowerCAmelCase__      			=						doctest.testfile(str('''..''' / directory / file	) ,							optionflags=doctest.ELLIPSIS	)
																			self.assertIs(result.failed ,							0	)




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						Path('''src/transformers'''	)
											lowerCAmelCase__      			=						'''modeling'''
											lowerCAmelCase__      			=						[
											    '''modeling_ctrl.py''',
											    '''modeling_tf_ctrl.py''',
											]
											self.analyze_directory(SCREAMING_SNAKE_CASE_ ,							identifier=SCREAMING_SNAKE_CASE_ ,							ignore_files=SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Dict	):
											lowerCAmelCase__      			=						Path('''src/transformers'''	)
											lowerCAmelCase__      			=						'''tokenization'''
											self.analyze_directory(SCREAMING_SNAKE_CASE_ ,							identifier=SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Tuple	):
											lowerCAmelCase__      			=						Path('''src/transformers'''	)
											lowerCAmelCase__      			=						'''configuration'''
											self.analyze_directory(SCREAMING_SNAKE_CASE_ ,							identifier=SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						Path('''src/transformers'''	)
											lowerCAmelCase__      			=						['''configuration''', '''modeling''', '''tokenization''']
											self.analyze_directory(SCREAMING_SNAKE_CASE_ ,							n_identifier=SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Tuple	):
											lowerCAmelCase__      			=						Path('''docs/source'''	)
											lowerCAmelCase__      			=						['''favicon.ico''']
											self.analyze_directory(SCREAMING_SNAKE_CASE_ ,							ignore_files=SCREAMING_SNAKE_CASE_ ,							only_modules=SCREAMING_SNAKE_CASE_	)





