code: 
  
  
  """simple docstring"""
  
  
  
  
  import warnings
  
  import numpy as np
  import pandas as pd
  from matplotlib import pyplot as plt
  from sklearn.metrics import pairwise_distances
  
  warnings.filterwarnings('ignore')
  
  __magic_name__	:   Optional[Any]          =							'K-MEANS-CLUST/ '
  
  
  
  
  
  def 			a_   (  lowercase__   :Optional[Any], lowercase__   :Optional[Any], lowercase__   :Union[str, Any]=None    ):
  			if seed is not None:  # useful for obtaining consistent results
  						np.random.seed(lowercase__    )
  			__lowerCamelCase        =			data.shape[0]  # number of data points
  
  			# Pick K indices from range [0, N).
  			__lowerCamelCase        =			np.random.randint(0, lowercase__, lowercase__    )
  
  			# Keep centroids as dense format, as many entries will be nonzero due to averaging.
  			# As long as at least one document in a cluster contains a word,
  			# it will carry a nonzero weight in the TF-IDF vector of the centroid.
  			__lowerCamelCase        =			data[rand_indices, :]
  
  			return centroids
  
  
  
  
  
  def 			a_   (  lowercase__   :Dict, lowercase__   :List[Any]    ):
  			return pairwise_distances(lowercase__, lowercase__, metric="""euclidean"""    )
  
  
  
  
  
  def 			a_   (  lowercase__   :Dict, lowercase__   :Optional[Any]    ):
  			# Compute distances between each data point and the set of centroids:
  			# Fill in the blank (RHS only)
  			__lowerCamelCase        =			centroid_pairwise_dist(lowercase__, lowercase__    )
  
  			# Compute cluster assignments for each data point:
  			# Fill in the blank (RHS only)
  			__lowerCamelCase        =			np.argmin(lowercase__, axis=1    )
  
  			return cluster_assignment
  
  
  
  
  
  def 			a_   (  lowercase__   :Dict, lowercase__   :Union[str, Any], lowercase__   :Optional[int]    ):
  			__lowerCamelCase        =			[]
  			for i in range(lowercase__    ):
  						# Select all data points that belong to cluster i. Fill in the blank (RHS only)
  						__lowerCamelCase        =			data[cluster_assignment == i]
  						# Compute the mean of the data points. Fill in the blank (RHS only)
  						__lowerCamelCase        =			member_data_points.mean(axis=0    )
  						new_centroids.append(lowercase__    )
  			__lowerCamelCase        =			np.array(lowercase__    )
  
  			return new_centroids
  
  
  
  
  
  def 			a_   (  lowercase__   :Optional[int], lowercase__   :Any, lowercase__   :List[str], lowercase__   :Dict    ):
  			__lowerCamelCase        =			0.0
  			for i in range(lowercase__    ):
  						# Select all data points that belong to cluster i. Fill in the blank (RHS only)
  						__lowerCamelCase        =			data[cluster_assignment == i, :]
  
  						if member_data_points.shape[0] > 0:  # check if i-th cluster is non-empty
  									# Compute distances from centroid to data points (RHS only)
  									__lowerCamelCase        =			pairwise_distances(
  									    lowercase__, [centroids[i]], metric="""euclidean"""    )
  									__lowerCamelCase        =			distances**2
  									heterogeneity += np.sum(lowercase__    )
  
  			return heterogeneity
  
  
  
  
  
  def 			a_   (  lowercase__   :Optional[int], lowercase__   :Optional[int]    ):
  			plt.figure(figsize=(7, 4)    )
  			plt.plot(lowercase__, linewidth=4    )
  			plt.xlabel("""# Iterations"""    )
  			plt.ylabel("""Heterogeneity"""    )
  			plt.title(f'Heterogeneity of clustering over time, K={k:d}'    )
  			plt.rcParams.update({"""font.size""": 16}    )
  			plt.show()
  
  
  
  
  
  def 			a_   (  lowercase__   :Dict, lowercase__   :Optional[Any], lowercase__   :List[Any], lowercase__   :int=500, lowercase__   :List[str]=None, lowercase__   :Any=False    ):
  			__lowerCamelCase        =			initial_centroids[:]
  			__lowerCamelCase        =			None
  
  			for itr in range(lowercase__    ):
  						if verbose:
  									print(lowercase__, end=""""""    )
  
  						# 1. Make cluster assignments using nearest centroids
  						__lowerCamelCase        =			assign_clusters(lowercase__, lowercase__    )
  
  						# 2. Compute a new centroid for each of the k clusters, averaging all data
  						#    points assigned to that cluster.
  						__lowerCamelCase        =			revise_centroids(lowercase__, lowercase__, lowercase__    )
  
  						# Check for convergence: if none of the assignments changed, stop
  						if (
  						    prev_cluster_assignment is not None
  						    and (prev_cluster_assignment == cluster_assignment).all()
  						):
  									break
  
  						# Print number of new assignments
  						if prev_cluster_assignment is not None:
  									__lowerCamelCase        =			np.sum(prev_cluster_assignment != cluster_assignment    )
  									if verbose:
  												print(
  												    f'    {num_changed:5d} elements changed their cluster assignment.'    )
  
          # Record heterogeneity convergence metric
  						if record_heterogeneity is not None:
  									# YOUR CODE HERE
  									__lowerCamelCase        =			compute_heterogeneity(lowercase__, lowercase__, lowercase__, lowercase__    )
  									record_heterogeneity.append(lowercase__    )
  
  						__lowerCamelCase        =			cluster_assignment[:]
  
  			return centroids, cluster_assignment
  
  
  # Mock test below
  if False:  # change to true to run this test case.
  					from sklearn import datasets as ds
  
  					__magic_name__	:   str          =							ds.load_iris()
  					__magic_name__	:   Optional[Any]          =							3
  					__magic_name__	:   Tuple          =							[]
  					__magic_name__	:   Any          =							get_initial_centroids(dataset['data'], k, seed=0)
  					__magic_name__     ,   __magic_name__	:   Any          =							kmeans(
  					    dataset['data'],
  					    k,
  					    initial_centroids,
  					    maxiter=4_0_0,
  					    record_heterogeneity=heterogeneity,
  					    verbose=True,
  					)
  					plot_heterogeneity(heterogeneity, k)
  
  
  
  
  
  def 			a_   (  lowercase__   :pd.DataFrame, lowercase__   :np.ndarray, lowercase__   :Optional[Any]=None    ):
  			# Fill missing values with given rules
  			if fill_missing_report:
  						__lowerCamelCase        =			df.fillna(value=lowercase__    )
  			__lowerCamelCase        =			1
  			__lowerCamelCase        =			df.select_dtypes(np.number    ).columns
  			__lowerCamelCase        =			(
  			    df.groupby(["""Cluster"""]    )[  # construct report dataframe
  			        numeric_cols
  			    ]  # group by cluster number
  			    .agg(
  			        [
  			            ("""sum""", np.sum),
  			            ("""mean_with_zeros""", lambda lowercase__    : np.mean(np.nan_to_num(lowercase__    )    )),
  			            ("""mean_without_zeros""", lambda lowercase__    : x.replace(0, np.NaN    ).mean()),
  			            (
  			                """mean_25-75""",
  			                lambda lowercase__    : np.mean(
  			                    np.nan_to_num(
  			                        sorted(lowercase__    )[
  			                            round(len(lowercase__    ) * 25 / 100    ) : round(len(lowercase__    ) * 75 / 100    )
  			                        ]    )    ),
  			            ),
  			            ("""mean_with_na""", np.mean),
  			            ("""min""", lambda lowercase__    : x.min()),
  			            ("""5%""", lambda lowercase__    : x.quantile(0.05    )),
  			            ("""25%""", lambda lowercase__    : x.quantile(0.25    )),
  			            ("""50%""", lambda lowercase__    : x.quantile(0.50    )),
  			            ("""75%""", lambda lowercase__    : x.quantile(0.75    )),
  			            ("""95%""", lambda lowercase__    : x.quantile(0.95    )),
  			            ("""max""", lambda lowercase__    : x.max()),
  			            ("""count""", lambda lowercase__    : x.count()),
  			            ("""stdev""", lambda lowercase__    : x.std()),
  			            ("""mode""", lambda lowercase__    : x.mode()[0]),
  			            ("""median""", lambda lowercase__    : x.median()),
  			            ("""# > 0""", lambda lowercase__    : (x > 0).sum()),
  			        ]    )
  			    .T.reset_index()
  			    .rename(index=lowercase__, columns={"""level_0""": """Features""", """level_1""": """Type"""}    )
  			)  # rename columns
  			# calculate the size of cluster(count of clientID's)
  			__lowerCamelCase        =			report[
  			    (report["""Features"""] == """dummy""") & (report["""Type"""] == """count""")
  			].copy()  # avoid SettingWithCopyWarning
  			__lowerCamelCase        =			(
  			    """ClusterSize"""  # rename created cluster df to match report column names
  			)
  			__lowerCamelCase        =			"""# of Customers"""
  			__lowerCamelCase        =			pd.DataFrame(
  			    clustersize.iloc[:, 2:].values
  			    / clustersize.iloc[:, 2:].values.sum()    )
  			__lowerCamelCase        =			"""% of Customers"""  # rename created cluster df to match report column names
  			__lowerCamelCase        =			"""ClusterProportion"""
  			__lowerCamelCase        =			clusterproportion.columns.tolist()
  			__lowerCamelCase        =			cols[-2:] + cols[:-2]
  			__lowerCamelCase        =			clusterproportion[cols]  # rearrange columns to match report
  			__lowerCamelCase        =			report.columns
  			__lowerCamelCase        =			pd.DataFrame(
  			    abs(
  			        report[report["""Type"""] == """count"""].iloc[:, 2:].values
  			        - clustersize.iloc[:, 2:].values    )    )  # generating df with count of nan values
  			__lowerCamelCase        =			0
  			__lowerCamelCase        =			"""# of nan"""
  			__lowerCamelCase        =			report[
  			    report["""Type"""] == """count"""
  			].Features.tolist()  # filling values in order to match report
  			__lowerCamelCase        =			a.columns.tolist()
  			__lowerCamelCase        =			cols[-2:] + cols[:-2]
  			__lowerCamelCase        =			a[cols]  # rearrange columns to match report
  			__lowerCamelCase        =			report.columns  # rename columns to match report
  			__lowerCamelCase        =			report.drop(
  			    report[report.Type == """count"""].index    )  # drop count values except cluster size
  			__lowerCamelCase        =			pd.concat(
  			    [report, a, clustersize, clusterproportion], axis=0    )  # concat report with clustert size and nan values
  			__lowerCamelCase        =			report["""Features"""].isin(lowercase__    )
  			__lowerCamelCase        =			report.columns.tolist()
  			__lowerCamelCase        =			cols[0:2] + cols[-1:] + cols[2:-1]
  			__lowerCamelCase        =			report[cols]
  			__lowerCamelCase        =			{
  			    """ClusterSize""": 9,
  			    """ClusterProportion""": 8,
  			    """mean_with_zeros""": 7,
  			    """mean_with_na""": 6,
  			    """max""": 5,
  			    """50%""": 4,
  			    """min""": 3,
  			    """25%""": 2,
  			    """75%""": 1,
  			    """# of nan""": 0,
  			    """# > 0""": -1,
  			    """sum_with_na""": -2,
  			}
  			__lowerCamelCase        =			(
  			    report.assign(
  			        Sortera=lambda lowercase__    : x.Type.map(lowercase__    ), Sortera=lambda lowercase__    : list(reversed(range(len(lowercase__    )    )    )    ), )
  			    .sort_values(["""Sorter1""", """Mark""", """Sorter2"""], ascending=lowercase__    )
  			    .drop(["""Sorter1""", """Sorter2"""], axis=1    )
  			)
  			__lowerCamelCase        =			""""""
  			__lowerCamelCase        =			report.reset_index()
  			__lowerCamelCase        =			report.drop(columns=["""index"""]    )
  			return report
  
  
  if __name__ == "__main__":
  					import doctest
  
  					doctest.testmod()
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available
  
  
  __magic_name__	:   Optional[Any]          =							{
      'configuration_flaubert': ['FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FlaubertConfig', 'FlaubertOnnxConfig'],
      'tokenization_flaubert': ['FlaubertTokenizer'],
  }
  
  try:
  					if not is_torch_available():
  										raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  					pass
  else:
  					__magic_name__	:   List[Any]          =							[
  					    'FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
  					    'FlaubertForMultipleChoice',
  					    'FlaubertForQuestionAnswering',
  					    'FlaubertForQuestionAnsweringSimple',
  					    'FlaubertForSequenceClassification',
  					    'FlaubertForTokenClassification',
  					    'FlaubertModel',
  					    'FlaubertWithLMHeadModel',
  					    'FlaubertPreTrainedModel',
  					]
  
  try:
  					if not is_tf_available():
  										raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  					pass
  else:
  					__magic_name__	:   Tuple          =							[
  					    'TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
  					    'TFFlaubertForMultipleChoice',
  					    'TFFlaubertForQuestionAnsweringSimple',
  					    'TFFlaubertForSequenceClassification',
  					    'TFFlaubertForTokenClassification',
  					    'TFFlaubertModel',
  					    'TFFlaubertPreTrainedModel',
  					    'TFFlaubertWithLMHeadModel',
  					]
  
  
  if TYPE_CHECKING:
  					from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig, FlaubertOnnxConfig
  					from .tokenization_flaubert import FlaubertTokenizer
  
  					try:
  										if not is_torch_available():
  															raise OptionalDependencyNotAvailable()
  					except OptionalDependencyNotAvailable:
  										pass
  					else:
  										from .modeling_flaubert import (
  										    FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
  										    FlaubertForMultipleChoice,
  										    FlaubertForQuestionAnswering,
  										    FlaubertForQuestionAnsweringSimple,
  										    FlaubertForSequenceClassification,
  										    FlaubertForTokenClassification,
  										    FlaubertModel,
  										    FlaubertPreTrainedModel,
  										    FlaubertWithLMHeadModel,
  										)
  
  					try:
  										if not is_tf_available():
  															raise OptionalDependencyNotAvailable()
  					except OptionalDependencyNotAvailable:
  										pass
  					else:
  										from .modeling_tf_flaubert import (
  										    TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
  										    TFFlaubertForMultipleChoice,
  										    TFFlaubertForQuestionAnsweringSimple,
  										    TFFlaubertForSequenceClassification,
  										    TFFlaubertForTokenClassification,
  										    TFFlaubertModel,
  										    TFFlaubertPreTrainedModel,
  										    TFFlaubertWithLMHeadModel,
  										)
  
  else:
  					import sys
  
  					__magic_name__	:   List[str]          =							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
  
  
  
  
  