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""")
  
  lowerCamelCase_     :     Optional[int]  		=						"""K-MEANS-CLUST/ """
  def _A		(		lowercase ,					lowercase ,					lowercase=None	):
  
  
  
  
  
  
  
      """simple docstring"""
      if seed is not None:  # useful for obtaining consistent results
          np.random.seed(lowercase	)
      a					=data.shape[0]  # number of data points
  
      # Pick K indices from range [0, N).
      a					=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.
      a					=data[rand_indices, :]
  
      return centroids
  def _A		(		lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      return pairwise_distances(lowercase ,					lowercase ,					metric='''euclidean'''	)
  def _A		(		lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      a					=centroid_pairwise_dist(lowercase ,					lowercase	)
  
      # Compute cluster assignments for each data point:
      # Fill in the blank (RHS only)
      a					=np.argmin(lowercase ,					axis=1	)
  
      return cluster_assignment
  def _A		(		lowercase ,					lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      a					=[]
      for i in range(lowercase	):
          # Select all data points that belong to cluster i. Fill in the blank (RHS only)
          a					=data[cluster_assignment == i]
          # Compute the mean of the data points. Fill in the blank (RHS only)
          a					=member_data_points.mean(axis=0	)
          new_centroids.append(lowercase	)
      a					=np.array(lowercase	)
  
      return new_centroids
  def _A		(		lowercase ,					lowercase ,					lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      a					=0.0
      for i in range(lowercase	):
          # Select all data points that belong to cluster i. Fill in the blank (RHS only)
          a					=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)
              a					=pairwise_distances(
                  lowercase ,					[centroids[i]] ,					metric='''euclidean'''	)
              a					=distances**2
              heterogeneity += np.sum(lowercase	)
  
      return heterogeneity
  def _A		(		lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      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 ,					lowercase ,					lowercase ,					lowercase=5_00 ,					lowercase=None ,					lowercase=False	):
  
  
  
  
  
  
  
      """simple docstring"""
      a					=initial_centroids[:]
      a					=None
  
      for itr in range(lowercase	):
          if verbose:
              print(lowercase ,					end=''''''	)
  
          # 1. Make cluster assignments using nearest centroids
          a					=assign_clusters(lowercase ,					lowercase	)
  
          # 2. Compute a new centroid for each of the k clusters, averaging all data
          #    points assigned to that cluster.
          a					=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:
              a					=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
              a					=compute_heterogeneity(lowercase ,					lowercase ,					lowercase ,					lowercase	)
              record_heterogeneity.append(lowercase	)
  
          a					=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
  
         lowerCamelCase_     :     Optional[Any]  		=						ds.load_iris()
         lowerCamelCase_     :     Optional[Any]  		=						3
         lowerCamelCase_     :     int  		=						[]
         lowerCamelCase_     :     int  		=						get_initial_centroids(dataset["""data"""], k, seed=0)
         lowerCamelCase_     :     Any  		=						kmeans(
             dataset["""data"""],
             k,
             initial_centroids,
             maxiter=4_0_0,
             record_heterogeneity=heterogeneity,
             verbose=True,
         )
         plot_heterogeneity(heterogeneity, k)
  def _A		(		lowercase ,					lowercase ,					lowercase=None	):
  
  
  
  
  
  
  
      """simple docstring"""
      # Fill missing values with given rules
      if fill_missing_report:
          a					=df.fillna(value=lowercase	)
      a					=1
      a					=df.select_dtypes(np.number	).columns
      a					=(
          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 / 1_00	) : round(len(lowercase	) * 75 / 1_00	)
                              ]	)	),
                  ),
                  ('''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)
      a					=report[
          (report['''Features'''] == '''dummy''') & (report['''Type'''] == '''count''')
      ].copy()  # avoid SettingWithCopyWarning
      a					=(
          '''ClusterSize'''  # rename created cluster df to match report column names
      )
      a					='''# of Customers'''
      a					=pd.DataFrame(
          clustersize.iloc[:, 2:].values
          / clustersize.iloc[:, 2:].values.sum()	)
      a					='''% of Customers'''  # rename created cluster df to match report column names
      a					='''ClusterProportion'''
      a					=clusterproportion.columns.tolist()
      a					=cols[-2:] + cols[:-2]
      a					=clusterproportion[cols]  # rearrange columns to match report
      a					=report.columns
      a					=pd.DataFrame(
          abs(
              report[report['''Type'''] == '''count'''].iloc[:, 2:].values
              - clustersize.iloc[:, 2:].values	)	)  # generating df with count of nan values
      a					=0
      a					='''# of nan'''
      a					=report[
          report['''Type'''] == '''count'''
      ].Features.tolist()  # filling values in order to match report
      a					=a.columns.tolist()
      a					=cols[-2:] + cols[:-2]
      a					=a[cols]  # rearrange columns to match report
      a					=report.columns  # rename columns to match report
      a					=report.drop(
          report[report.Type == '''count'''].index	)  # drop count values except cluster size
      a					=pd.concat(
          [report, a, clustersize, clusterproportion] ,					axis=0	)  # concat report with clustert size and nan values
      a					=report['''Features'''].isin(lowercase	)
      a					=report.columns.tolist()
      a					=cols[0:2] + cols[-1:] + cols[2:-1]
      a					=report[cols]
      a					={
          '''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,
      }
      a					=(
          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	)
      )
      a					=''''''
      a					=report.reset_index()
      a					=report.drop(columns=['''index''']	)
      return report
  
  
  if __name__ == "__main__":
         import doctest
  
         doctest.testmod()
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  
  
  
  import copy
  
  from transformers.configuration_utils import PretrainedConfig
  from transformers.utils import logging
  
  
  lowerCamelCase_     :     int    		=						logging.get_logger(__name__)
  
  
  
  
  
  
  class    __A       ( _SCREAMING_SNAKE_CASE    ):
  
  
  
  
  
  
   """simple docstring"""
  
  
  
  
   __lowerCAmelCase				      =						"hybrid-clip"
   __lowerCAmelCase				      =						True
  
  
   def __init__(	self				,					__A=512				,					**__A		)      ->  Any:
       super().__init__(**__A		)
  
       if "text_config" not in kwargs:
           raise ValueError('''`text_config` can not be `None`.'''		)
  
       if "vision_config" not in kwargs:
           raise ValueError('''`vision_config` can not be `None`.'''		)
  
       a					=kwargs.pop('''text_config'''		)
       a					=kwargs.pop('''vision_config'''		)
  
       a					=text_config.pop('''model_type'''		)
       a					=vision_config.pop('''model_type'''		)
  
       from transformers import AutoConfig
  
       a					=AutoConfig.for_model(__A				,					**__A		)
  
       if vision_model_type == "clip":
           a					=AutoConfig.for_model(__A				,					**__A		).vision_config
       elif vision_model_type == "clip_vision_model":
           from transformers import CLIPVisionConfig
  
           a					=CLIPVisionConfig(**__A		)
       else:
           a					=AutoConfig.for_model(__A				,					**__A		)
  
       a					=projection_dim
       a					=1.0
  
  
   @classmethod
   def    SCREAMING_SNAKE_CASE							(	cls				,					__A				,					__A				,					**__A		)      ->  Tuple:
       return cls(text_config=text_config.to_dict()				,					vision_config=vision_config.to_dict()				,					**__A		)
  
  
  
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  Optional[int]:
       a					=copy.deepcopy(self.__dict__		)
       a					=self.text_config.to_dict()
       a					=self.vision_config.to_dict()
       a					=self.__class__.model_type
       return output