code: 
  
  
  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")
  
  SCREAMING_SNAKE_CASE : str          =    """K-MEANS-CLUST/ """
  
  
  
  
  
  def 						_lowerCamelCase	(							SCREAMING_SNAKE_CASE_				: Optional[int]	,	SCREAMING_SNAKE_CASE_				: List[Any]	,	SCREAMING_SNAKE_CASE_				: int=None      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							if seed is not None:  # useful for obtaining consistent results
  														np.random.seed(SCREAMING_SNAKE_CASE_      )
  							a_       :   Optional[Any]			=	data.shape[0]  # number of data points
  
  							# Pick K indices from range [0, N).
  							a_       :   Optional[int]			=	np.random.randint(0	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_      )
  
  							# 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_       :   Tuple			=	data[rand_indices, :]
  
  							return centroids
  
  
  
  
  
  def 						_lowerCamelCase	(							SCREAMING_SNAKE_CASE_				: Any	,	SCREAMING_SNAKE_CASE_				: Optional[Any]      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							return pairwise_distances(SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	metric="""euclidean"""      )
  
  
  
  
  
  def 						_lowerCamelCase	(							SCREAMING_SNAKE_CASE_				: List[str]	,	SCREAMING_SNAKE_CASE_				: int      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							a_       :   Union[str, Any]			=	centroid_pairwise_dist(SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_      )
  
  							# Compute cluster assignments for each data point:
  							# Fill in the blank (RHS only)
  							a_       :   Dict			=	np.argmin(SCREAMING_SNAKE_CASE_	,	axis=1      )
  
  							return cluster_assignment
  
  
  
  
  
  def 						_lowerCamelCase	(							SCREAMING_SNAKE_CASE_				: List[Any]	,	SCREAMING_SNAKE_CASE_				: Dict	,	SCREAMING_SNAKE_CASE_				: Optional[int]      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							a_       :   str			=	[]
  							for i in range(SCREAMING_SNAKE_CASE_      ):
  														# Select all data points that belong to cluster i. Fill in the blank (RHS only)
  														a_       :   Tuple			=	data[cluster_assignment == i]
  														# Compute the mean of the data points. Fill in the blank (RHS only)
  														a_       :   Any			=	member_data_points.mean(axis=0      )
  														new_centroids.append(SCREAMING_SNAKE_CASE_      )
  							a_       :   List[Any]			=	np.array(SCREAMING_SNAKE_CASE_      )
  
  							return new_centroids
  
  
  
  
  
  def 						_lowerCamelCase	(							SCREAMING_SNAKE_CASE_				: Union[str, Any]	,	SCREAMING_SNAKE_CASE_				: List[Any]	,	SCREAMING_SNAKE_CASE_				: Union[str, Any]	,	SCREAMING_SNAKE_CASE_				: Optional[int]      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							a_       :   Tuple			=	0.0
  							for i in range(SCREAMING_SNAKE_CASE_      ):
  														# Select all data points that belong to cluster i. Fill in the blank (RHS only)
  														a_       :   Optional[Any]			=	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_       :   int			=	pairwise_distances(
  																					    SCREAMING_SNAKE_CASE_	,	[centroids[i]]	,	metric="""euclidean"""      )
  																					a_       :   int			=	distances**2
  																					heterogeneity += np.sum(SCREAMING_SNAKE_CASE_      )
  
  							return heterogeneity
  
  
  
  
  
  def 						_lowerCamelCase	(							SCREAMING_SNAKE_CASE_				: Optional[Any]	,	SCREAMING_SNAKE_CASE_				: Union[str, Any]      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							plt.figure(figsize=(7, 4)      )
  							plt.plot(SCREAMING_SNAKE_CASE_	,	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 						_lowerCamelCase	(							SCREAMING_SNAKE_CASE_				: List[Any]	,	SCREAMING_SNAKE_CASE_				: Tuple	,	SCREAMING_SNAKE_CASE_				: Any	,	SCREAMING_SNAKE_CASE_				: List[Any]=5_00	,	SCREAMING_SNAKE_CASE_				: Optional[Any]=None	,	SCREAMING_SNAKE_CASE_				: Union[str, Any]=False      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							a_       :   Optional[int]			=	initial_centroids[:]
  							a_       :   List[str]			=	None
  
  							for itr in range(SCREAMING_SNAKE_CASE_      ):
  														if verbose:
  																					print(SCREAMING_SNAKE_CASE_	,	end=""""""      )
  
  														# 1. Make cluster assignments using nearest centroids
  														a_       :   Optional[Any]			=	assign_clusters(SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_      )
  
  														# 2. Compute a new centroid for each of the k clusters, averaging all data
  														#    points assigned to that cluster.
  														a_       :   Union[str, Any]			=	revise_centroids(SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_      )
  
  														# 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_       :   Union[str, Any]			=	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_       :   str			=	compute_heterogeneity(SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_      )
  																					record_heterogeneity.append(SCREAMING_SNAKE_CASE_      )
  
  														a_       :   str			=	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
  
  	SCREAMING_SNAKE_CASE : Optional[Any]          =    ds.load_iris()
  	SCREAMING_SNAKE_CASE : int          =    3
  	SCREAMING_SNAKE_CASE : List[str]          =    []
  	SCREAMING_SNAKE_CASE : int          =    get_initial_centroids(dataset["data"], k, seed=0)
  	SCREAMING_SNAKE_CASE : Union[str, Any]          =    kmeans(
  	    dataset["data"],
  	    k,
  	    initial_centroids,
  	    maxiter=4_00,
  	    record_heterogeneity=heterogeneity,
  	    verbose=True,
  	)
  	plot_heterogeneity(heterogeneity, k)
  
  
  
  
  
  def 						_lowerCamelCase	(							SCREAMING_SNAKE_CASE_				: int	,	SCREAMING_SNAKE_CASE_				: Optional[int]	,	SCREAMING_SNAKE_CASE_				: List[str]=None      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							if fill_missing_report:
  														a_       :   int			=	df.fillna(value=SCREAMING_SNAKE_CASE_      )
  							a_       :   Any			=	1
  							a_       :   Any			=	df.select_dtypes(np.number      ).columns
  							a_       :   List[Any]			=	(
  							    df.groupby(["""Cluster"""]      )[  # construct report dataframe
  							        numeric_cols
  							    ]  # group by cluster number
  							    .agg(
  							        [
  							            ("""sum""", np.sum),
  							            ("""mean_with_zeros""", lambda SCREAMING_SNAKE_CASE_      : np.mean(np.nan_to_num(SCREAMING_SNAKE_CASE_      )      )),
  							            ("""mean_without_zeros""", lambda SCREAMING_SNAKE_CASE_      : x.replace(0	,	np.NaN      ).mean()),
  							            (
  							                """mean_25-75""",
  							                lambda SCREAMING_SNAKE_CASE_      : np.mean(
  							                    np.nan_to_num(
  							                        sorted(SCREAMING_SNAKE_CASE_      )[
  							                            round(len(SCREAMING_SNAKE_CASE_      ) * 25 / 1_00      ) : round(len(SCREAMING_SNAKE_CASE_      ) * 75 / 1_00      )
  							                        ]      )      ),
  							            ),
  							            ("""mean_with_na""", np.mean),
  							            ("""min""", lambda SCREAMING_SNAKE_CASE_      : x.min()),
  							            ("""5%""", lambda SCREAMING_SNAKE_CASE_      : x.quantile(0.05      )),
  							            ("""25%""", lambda SCREAMING_SNAKE_CASE_      : x.quantile(0.25      )),
  							            ("""50%""", lambda SCREAMING_SNAKE_CASE_      : x.quantile(0.50      )),
  							            ("""75%""", lambda SCREAMING_SNAKE_CASE_      : x.quantile(0.75      )),
  							            ("""95%""", lambda SCREAMING_SNAKE_CASE_      : x.quantile(0.95      )),
  							            ("""max""", lambda SCREAMING_SNAKE_CASE_      : x.max()),
  							            ("""count""", lambda SCREAMING_SNAKE_CASE_      : x.count()),
  							            ("""stdev""", lambda SCREAMING_SNAKE_CASE_      : x.std()),
  							            ("""mode""", lambda SCREAMING_SNAKE_CASE_      : x.mode()[0]),
  							            ("""median""", lambda SCREAMING_SNAKE_CASE_      : x.median()),
  							            ("""# > 0""", lambda SCREAMING_SNAKE_CASE_      : (x > 0).sum()),
  							        ]      )
  							    .T.reset_index()
  							    .rename(index=SCREAMING_SNAKE_CASE_	,	columns={"""level_0""": """Features""", """level_1""": """Type"""}      )
  							)  # rename columns
  							# calculate the size of cluster(count of clientID's)
  							a_       :   str			=	report[
  							    (report["Features"] == "dummy") & (report["Type"] == "count")
  							].copy()  # avoid SettingWithCopyWarning
  							a_       :   int			=	(
  							    "ClusterSize"  # rename created cluster df to match report column names
  							)
  							a_       :   List[str]			=	"# of Customers"
  							a_       :   int			=	pd.DataFrame(
  							    clustersize.iloc[:, 2:].values
  							    / clustersize.iloc[:, 2:].values.sum()      )
  							a_       :   Dict			=	"% of Customers"  # rename created cluster df to match report column names
  							a_       :   Any			=	"ClusterProportion"
  							a_       :   int			=	clusterproportion.columns.tolist()
  							a_       :   int			=	cols[-2:] + cols[:-2]
  							a_       :   Optional[int]			=	clusterproportion[cols]  # rearrange columns to match report
  							a_       :   Union[str, Any]			=	report.columns
  							a_       :   int			=	pd.DataFrame(
  							    abs(
  							        report[report["""Type"""] == """count"""].iloc[:, 2:].values
  							        - clustersize.iloc[:, 2:].values      )      )  # generating df with count of nan values
  							a_       :   Optional[int]			=	0
  							a_       :   Tuple			=	"# of nan"
  							a_       :   Any			=	report[
  							    report["Type"] == "count"
  							].Features.tolist()  # filling values in order to match report
  							a_       :   int			=	a.columns.tolist()
  							a_       :   Tuple			=	cols[-2:] + cols[:-2]
  							a_       :   List[str]			=	a[cols]  # rearrange columns to match report
  							a_       :   int			=	report.columns  # rename columns to match report
  							a_       :   List[Any]			=	report.drop(
  							    report[report.Type == """count"""].index      )  # drop count values except cluster size
  							a_       :   Optional[Any]			=	pd.concat(
  							    [report, a, clustersize, clusterproportion]	,	axis=0      )  # concat report with clustert size and nan values
  							a_       :   Any			=	report["Features"].isin(SCREAMING_SNAKE_CASE_      )
  							a_       :   Tuple			=	report.columns.tolist()
  							a_       :   str			=	cols[0:2] + cols[-1:] + cols[2:-1]
  							a_       :   int			=	report[cols]
  							a_       :   str			=	{
  							    "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_       :   int			=	(
  							    report.assign(
  							        Sortera=lambda SCREAMING_SNAKE_CASE_      : x.Type.map(SCREAMING_SNAKE_CASE_      )	,	Sortera=lambda SCREAMING_SNAKE_CASE_      : list(reversed(range(len(SCREAMING_SNAKE_CASE_      )      )      )      )	,	)
  							    .sort_values(["""Sorter1""", """Mark""", """Sorter2"""]	,	ascending=SCREAMING_SNAKE_CASE_      )
  							    .drop(["""Sorter1""", """Sorter2"""]	,	axis=1      )
  							)
  							a_       :   List[str]			=	""
  							a_       :   Any			=	report.reset_index()
  							a_       :   Any			=	report.drop(columns=["""index"""]      )
  							return report
  
  
  if __name__ == "__main__":
  	import doctest
  
  	doctest.testmod()
  
  
  
style_context: 
  
  
  import copy
  from typing import Dict, Optional
  
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  from ..auto import CONFIG_MAPPING
  
  
  SCREAMING_SNAKE_CASE : List[str]          =    logging.get_logger(__name__)
  
  SCREAMING_SNAKE_CASE : List[Any]          =    {
      "shi-labs/oneformer_ade20k_swin_tiny": (
          "https://huggingface.co/shi-labs/oneformer_ade20k_swin_tiny/blob/main/config.json"
      ),
      # See all OneFormer models at https://huggingface.co/models?filter=oneformer
  }
  
  
  
  
  
  class 					snake_case__  ( __A       ):
  	UpperCAmelCase   :							Tuple         = """oneformer"""
  	UpperCAmelCase   :							Union[str, Any]         = {"""hidden_size""": """hidden_dim"""}
  
  
  
  
  
  	def __init__(  self				,    UpperCamelCase_ = None				,    UpperCamelCase_ = 255				,    UpperCamelCase_ = 150				,    UpperCamelCase_ = 0.1				,    UpperCamelCase_ = 2.0				,    UpperCamelCase_ = 5.0				,    UpperCamelCase_ = 5.0				,    UpperCamelCase_ = 0.5				,    UpperCamelCase_ = 0.07				,    UpperCamelCase_ = 12544				,    UpperCamelCase_ = 3.0				,    UpperCamelCase_ = 0.75				,    UpperCamelCase_ = 0.02				,    UpperCamelCase_ = 1.0				,    UpperCamelCase_ = 1e-05				,    UpperCamelCase_ = False				,    UpperCamelCase_ = True				,    UpperCamelCase_ = True				,    UpperCamelCase_ = [4, 8, 16, 32]				,    UpperCamelCase_ = 77				,    UpperCamelCase_ = 256				,    UpperCamelCase_ = 77				,    UpperCamelCase_ = 6				,    UpperCamelCase_ = 49408				,    UpperCamelCase_ = 2				,    UpperCamelCase_ = 16				,    UpperCamelCase_ = 256				,    UpperCamelCase_ = 256				,    UpperCamelCase_ = 256				,    UpperCamelCase_ = 1024				,    UpperCamelCase_ = "GN"				,    UpperCamelCase_ = 6				,    UpperCamelCase_ = 10				,    UpperCamelCase_ = True				,    UpperCamelCase_ = 8				,    UpperCamelCase_ = 0.1				,    UpperCamelCase_ = 2048				,    UpperCamelCase_ = False				,    UpperCamelCase_ = False				,    UpperCamelCase_ = 2				,    UpperCamelCase_ = 4				,    **UpperCamelCase_				,    )		->			List[Any]:
  								"""simple docstring"""
  
  
  
  
  
  
  								if backbone_config is None:
  															logger.info("""`backbone_config` is unset. Initializing the config with the default `Swin` backbone."""							)
  															a_       :   Tuple			=	CONFIG_MAPPING["""swin"""](
  															    image_size=224				,    in_channels=3				,    patch_size=4				,    embed_dim=96				,    depths=[2, 2, 6, 2]				,    num_heads=[3, 6, 12, 24]				,    window_size=7				,    drop_path_rate=0.3				,    use_absolute_embeddings=UpperCamelCase_				,    out_features=["""stage1""", """stage2""", """stage3""", """stage4"""]				,    )
  								elif isinstance(UpperCamelCase_				,    UpperCamelCase_							):
  															a_       :   str			=	backbone_config.get("""model_type"""							)
  															a_       :   Optional[Any]			=	CONFIG_MAPPING[backbone_model_type]
  															a_       :   List[Any]			=	config_class.from_dict(UpperCamelCase_							)
  
  								a_       :   str			=	backbone_config
  
  								a_       :   List[str]			=	ignore_value
  								a_       :   Optional[int]			=	num_queries
  								a_       :   Optional[Any]			=	no_object_weight
  								a_       :   List[Any]			=	class_weight
  								a_       :   Union[str, Any]			=	mask_weight
  								a_       :   Union[str, Any]			=	dice_weight
  								a_       :   Optional[Any]			=	contrastive_weight
  								a_       :   Any			=	contrastive_temperature
  								a_       :   Optional[int]			=	train_num_points
  								a_       :   Tuple			=	oversample_ratio
  								a_       :   str			=	importance_sample_ratio
  								a_       :   List[Any]			=	init_std
  								a_       :   int			=	init_xavier_std
  								a_       :   List[Any]			=	layer_norm_eps
  								a_       :   Optional[int]			=	is_training
  								a_       :   List[Any]			=	use_auxiliary_loss
  								a_       :   str			=	output_auxiliary_logits
  								a_       :   Dict			=	strides
  								a_       :   List[Any]			=	task_seq_len
  								a_       :   int			=	text_encoder_width
  								a_       :   List[Any]			=	text_encoder_context_length
  								a_       :   List[str]			=	text_encoder_num_layers
  								a_       :   Union[str, Any]			=	text_encoder_vocab_size
  								a_       :   Optional[Any]			=	text_encoder_proj_layers
  								a_       :   Optional[int]			=	text_encoder_n_ctx
  								a_       :   Optional[Any]			=	conv_dim
  								a_       :   str			=	mask_dim
  								a_       :   Optional[Any]			=	hidden_dim
  								a_       :   Any			=	encoder_feedforward_dim
  								a_       :   Dict			=	norm
  								a_       :   List[Any]			=	encoder_layers
  								a_       :   int			=	decoder_layers
  								a_       :   Any			=	use_task_norm
  								a_       :   Union[str, Any]			=	num_attention_heads
  								a_       :   List[str]			=	dropout
  								a_       :   List[Any]			=	dim_feedforward
  								a_       :   Union[str, Any]			=	pre_norm
  								a_       :   Dict			=	enforce_input_proj
  								a_       :   Tuple			=	query_dec_layers
  								a_       :   Any			=	common_stride
  								a_       :   List[str]			=	decoder_layers
  
  								super().__init__(**UpperCamelCase_							)
  
  
  
  
  
  	def     A				(  self							)		->			Dict[str, any]:
  								"""simple docstring"""
  
  
  
  
  
  
  								a_       :   Dict			=	copy.deepcopy(self.__dict__							)
  								a_       :   Any			=	self.backbone_config.to_dict()
  								a_       :   Union[str, Any]			=	self.__class__.model_type
  								return output
  
  
  