code: 
  
  
  
  
  
  
  """simple docstring"""
  
  import collections
  import inspect
  import unittest
  
  from transformers import DonutSwinConfig
  from transformers.testing_utils import require_torch, slow, torch_device
  from transformers.utils import is_torch_available
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_torch_available():
  					import torch
  					from torch import nn
  
  					from transformers import DonutSwinModel
  					from transformers.models.donut.modeling_donut_swin import DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST
  
  
  class 	__lowerCamelCase       :
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  		def __init__(     self							:			List[str]		,    a_							:			Tuple		,    a_							:			Any=13		,    a_							:			Dict=32		,    a_							:			Optional[Any]=2		,    a_							:			Dict=3		,    a_							:			int=16		,    a_							:			Tuple=[1, 2, 1]		,    a_							:			List[str]=[2, 2, 4]		,    a_							:			Union[str, Any]=2		,    a_							:			Optional[Any]=2.0		,    a_							:			Optional[int]=True		,    a_							:			Dict=0.0		,    a_							:			List[Any]=0.0		,    a_							:			Tuple=0.1		,    a_							:			int="gelu"		,    a_							:			str=False		,    a_							:			int=True		,    a_							:			Optional[Any]=0.02		,    a_							:			List[Any]=1e-5		,    a_							:			Any=True		,    a_							:			int=None		,    a_							:			List[Any]=True		,    a_							:			int=10		,    a_							:			Optional[Any]=8		,    ):
  				lowerCAmelCase_     :							Optional[int]             =    parent
  				lowerCAmelCase_     :							int             =    batch_size
  				lowerCAmelCase_     :							Any             =    image_size
  				lowerCAmelCase_     :							int             =    patch_size
  				lowerCAmelCase_     :							Union[str, Any]             =    num_channels
  				lowerCAmelCase_     :							Dict             =    embed_dim
  				lowerCAmelCase_     :							Dict             =    depths
  				lowerCAmelCase_     :							Any             =    num_heads
  				lowerCAmelCase_     :							int             =    window_size
  				lowerCAmelCase_     :							Optional[int]             =    mlp_ratio
  				lowerCAmelCase_     :							List[Any]             =    qkv_bias
  				lowerCAmelCase_     :							str             =    hidden_dropout_prob
  				lowerCAmelCase_     :							int             =    attention_probs_dropout_prob
  				lowerCAmelCase_     :							str             =    drop_path_rate
  				lowerCAmelCase_     :							Dict             =    hidden_act
  				lowerCAmelCase_     :							Any             =    use_absolute_embeddings
  				lowerCAmelCase_     :							Optional[int]             =    patch_norm
  				lowerCAmelCase_     :							Tuple             =    layer_norm_eps
  				lowerCAmelCase_     :							Any             =    initializer_range
  				lowerCAmelCase_     :							Optional[int]             =    is_training
  				lowerCAmelCase_     :							Union[str, Any]             =    scope
  				lowerCAmelCase_     :							List[Any]             =    use_labels
  				lowerCAmelCase_     :							Optional[Any]             =    type_sequence_label_size
  				lowerCAmelCase_     :							int             =    encoder_stride
  
  
  
  
  
  		def      lowerCamelCase (     self							:			Dict			):
  				lowerCAmelCase_     :							Tuple             =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)
  
  				lowerCAmelCase_     :							Tuple             =    None
  				if self.use_labels:
  						lowerCAmelCase_     :							Any             =    ids_tensor([self.batch_size]		,    self.type_sequence_label_size			)
  
  				lowerCAmelCase_     :							str             =    self.get_config()
  
  				return config, pixel_values, labels
  
  
  
  
  
  		def      lowerCamelCase (     self							:			Dict			):
  				return DonutSwinConfig(
  				    image_size=self.image_size		,    patch_size=self.patch_size		,    num_channels=self.num_channels		,    embed_dim=self.embed_dim		,    depths=self.depths		,    num_heads=self.num_heads		,    window_size=self.window_size		,    mlp_ratio=self.mlp_ratio		,    qkv_bias=self.qkv_bias		,    hidden_dropout_prob=self.hidden_dropout_prob		,    attention_probs_dropout_prob=self.attention_probs_dropout_prob		,    drop_path_rate=self.drop_path_rate		,    hidden_act=self.hidden_act		,    use_absolute_embeddings=self.use_absolute_embeddings		,    path_norm=self.patch_norm		,    layer_norm_eps=self.layer_norm_eps		,    initializer_range=self.initializer_range		,    encoder_stride=self.encoder_stride		,    )
  
  
  
  
  
  		def      lowerCamelCase (     self							:			Optional[Any]		,    a_							:			List[Any]		,    a_							:			Dict		,    a_							:			List[str]			):
  				lowerCAmelCase_     :							Union[str, Any]             =    DonutSwinModel(config=a_			)
  				model.to(a_			)
  				model.eval()
  				lowerCAmelCase_     :							List[Any]             =    model(a_			)
  
  				lowerCAmelCase_     :							Optional[int]             =    ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths			) - 1))
  				lowerCAmelCase_     :							List[str]             =    int(config.embed_dim * 2 ** (len(config.depths			) - 1)			)
  
  				self.parent.assertEqual(result.last_hidden_state.shape		,    (self.batch_size, expected_seq_len, expected_dim)			)
  
  
  
  
  
  		def      lowerCamelCase (     self							:			Optional[Any]			):
  				lowerCAmelCase_     :							Tuple             =    self.prepare_config_and_inputs()
  				(
  				    (
  				    lowerCAmelCase_
  				)       ,			(
  				    lowerCAmelCase_
  				)       ,			(
  				    lowerCAmelCase_
  				)       ,			
  				)     :							List[str]             =    config_and_inputs
  				lowerCAmelCase_     :							str             =    {"pixel_values": pixel_values}
  				return config, inputs_dict
  
  
  
  
  
  
  
  @require_torch
  class 	__lowerCamelCase       (				A__				,							A__				,							unittest.TestCase    ):
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  		a_			:       List[Any]      =							(DonutSwinModel,) if is_torch_available() else ()
  		a_			:       str      =							{"""feature-extraction""": DonutSwinModel} if is_torch_available() else {}
  		a_			:       List[str]      =							True
  
  		a_			:       Union[str, Any]      =							False
  		a_			:       Optional[Any]      =							False
  		a_			:       Optional[Any]      =							False
  
  
  
  
  
  		def      lowerCamelCase (     self							:			Optional[int]			):
  				lowerCAmelCase_     :							Dict             =    DonutSwinModelTester(self			)
  				lowerCAmelCase_     :							str             =    ConfigTester(self		,    config_class=a_		,    embed_dim=37			)
  
  
  
  
  
  		def      lowerCamelCase (     self							:			Dict			):
  				self.create_and_test_config_common_properties()
  				self.config_tester.create_and_test_config_to_json_string()
  				self.config_tester.create_and_test_config_to_json_file()
  				self.config_tester.create_and_test_config_from_and_save_pretrained()
  				self.config_tester.create_and_test_config_with_num_labels()
  				self.config_tester.check_config_can_be_init_without_params()
  				self.config_tester.check_config_arguments_init()
  
  
  
  
  
  		def      lowerCamelCase (     self							:			Optional[int]			):
  				return
  
  
  
  
  
  		def      lowerCamelCase (     self							:			List[str]			):
  				lowerCAmelCase_     :							Dict             =    self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_model(*a_			)
  
  
  
  
  
  		def      lowerCamelCase (     self							:			Union[str, Any]			):
  				# DonutSwin does not use inputs_embeds
  				pass
  
  
  
  
  
  		def      lowerCamelCase (     self							:			Tuple			):
  				lowerCAmelCase_       ,			lowerCAmelCase_     :							Optional[Any]             =    self.model_tester.prepare_config_and_inputs_for_common()
  
  				for model_class in self.all_model_classes:
  						lowerCAmelCase_     :							Optional[Any]             =    model_class(a_			)
  						self.assertIsInstance(model.get_input_embeddings()		,    (nn.Module)			)
  						lowerCAmelCase_     :							Dict             =    model.get_output_embeddings()
  						self.assertTrue(x is None or isinstance(a_		,    nn.Linear			)			)
  
  
  
  
  
  		def      lowerCamelCase (     self							:			int			):
  				lowerCAmelCase_       ,			lowerCAmelCase_     :							int             =    self.model_tester.prepare_config_and_inputs_for_common()
  
  				for model_class in self.all_model_classes:
  						lowerCAmelCase_     :							Any             =    model_class(a_			)
  						lowerCAmelCase_     :							Union[str, Any]             =    inspect.signature(model.forward			)
  						# signature.parameters is an OrderedDict => so arg_names order is deterministic
  						lowerCAmelCase_     :							List[Any]             =    [*signature.parameters.keys()]
  
  						lowerCAmelCase_     :							Union[str, Any]             =    ["pixel_values"]
  						self.assertListEqual(arg_names[:1]		,    a_			)
  
  
  
  
  
  		def      lowerCamelCase (     self							:			Dict			):
  				lowerCAmelCase_       ,			lowerCAmelCase_     :							Any             =    self.model_tester.prepare_config_and_inputs_for_common()
  				lowerCAmelCase_     :							Union[str, Any]             =    True
  
  				for model_class in self.all_model_classes:
  						lowerCAmelCase_     :							Any             =    True
  						lowerCAmelCase_     :							Optional[Any]             =    False
  						lowerCAmelCase_     :							Any             =    True
  						lowerCAmelCase_     :							int             =    model_class(a_			)
  						model.to(a_			)
  						model.eval()
  						with torch.no_grad():
  								lowerCAmelCase_     :							Any             =    model(**self._prepare_for_class(a_		,    a_			)			)
  						lowerCAmelCase_     :							Any             =    outputs.attentions
  						lowerCAmelCase_     :							int             =    len(self.model_tester.depths			)
  						self.assertEqual(len(a_			)		,    a_			)
  
  						# check that output_attentions also work using config
  						del inputs_dict["output_attentions"]
  						lowerCAmelCase_     :							Any             =    True
  						lowerCAmelCase_     :							Union[str, Any]             =    config.window_size**2
  						lowerCAmelCase_     :							Dict             =    model_class(a_			)
  						model.to(a_			)
  						model.eval()
  						with torch.no_grad():
  								lowerCAmelCase_     :							Union[str, Any]             =    model(**self._prepare_for_class(a_		,    a_			)			)
  						lowerCAmelCase_     :							Tuple             =    outputs.attentions
  						self.assertEqual(len(a_			)		,    a_			)
  
  						self.assertListEqual(
  						    list(attentions[0].shape[-3:]			)		,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,    )
  						lowerCAmelCase_     :							Union[str, Any]             =    len(a_			)
  
  						# Check attention is always last and order is fine
  						lowerCAmelCase_     :							Union[str, Any]             =    True
  						lowerCAmelCase_     :							Optional[Any]             =    True
  						lowerCAmelCase_     :							Union[str, Any]             =    model_class(a_			)
  						model.to(a_			)
  						model.eval()
  						with torch.no_grad():
  								lowerCAmelCase_     :							str             =    model(**self._prepare_for_class(a_		,    a_			)			)
  
  						if hasattr(self.model_tester		,    "num_hidden_states_types"			):
  								lowerCAmelCase_     :							Optional[Any]             =    self.model_tester.num_hidden_states_types
  						else:
  								# also another +1 for reshaped_hidden_states
  								lowerCAmelCase_     :							Union[str, Any]             =    2
  						self.assertEqual(out_len + added_hidden_states		,    len(a_			)			)
  
  						lowerCAmelCase_     :							List[Any]             =    outputs.attentions
  
  						self.assertEqual(len(a_			)		,    a_			)
  
  						self.assertListEqual(
  						    list(self_attentions[0].shape[-3:]			)		,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,    )
  
  
  
  
  
  		def      lowerCamelCase (     self							:			int		,    a_							:			Optional[int]		,    a_							:			str		,    a_							:			Union[str, Any]		,    a_							:			Dict			):
  				lowerCAmelCase_     :							List[Any]             =    model_class(a_			)
  				model.to(a_			)
  				model.eval()
  
  				with torch.no_grad():
  						lowerCAmelCase_     :							Optional[Any]             =    model(**self._prepare_for_class(a_		,    a_			)			)
  
  				lowerCAmelCase_     :							Tuple             =    outputs.hidden_states
  
  				lowerCAmelCase_     :							str             =    getattr(
  				    self.model_tester		,    "expected_num_hidden_layers"		,    len(self.model_tester.depths			) + 1			)
  				self.assertEqual(len(a_			)		,    a_			)
  
  				# DonutSwin has a different seq_length
  				lowerCAmelCase_     :							Optional[int]             =    (
  				    config.patch_size
  				    if isinstance(config.patch_size		,    collections.abc.Iterable			)
  				    else (config.patch_size, config.patch_size)
  				)
  
  				lowerCAmelCase_     :							str             =    (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
  
  				self.assertListEqual(
  				    list(hidden_states[0].shape[-2:]			)		,    [num_patches, self.model_tester.embed_dim]		,    )
  
  				lowerCAmelCase_     :							Dict             =    outputs.reshaped_hidden_states
  				self.assertEqual(len(a_			)		,    a_			)
  
  				lowerCAmelCase_       ,			lowerCAmelCase_       ,			lowerCAmelCase_       ,			lowerCAmelCase_     :							Dict             =    reshaped_hidden_states[0].shape
  				lowerCAmelCase_     :							List[str]             =    (
  				    reshaped_hidden_states[0].view(a_		,    a_		,    height * width			).permute(0		,    2		,    1			)
  				)
  				self.assertListEqual(
  				    list(reshaped_hidden_states.shape[-2:]			)		,    [num_patches, self.model_tester.embed_dim]		,    )
  
  
  
  
  
  		def      lowerCamelCase (     self							:			Any			):
  				lowerCAmelCase_       ,			lowerCAmelCase_     :							int             =    self.model_tester.prepare_config_and_inputs_for_common()
  
  				lowerCAmelCase_     :							int             =    (
  				    self.model_tester.image_size
  				    if isinstance(self.model_tester.image_size		,    collections.abc.Iterable			)
  				    else (self.model_tester.image_size, self.model_tester.image_size)
  				)
  
  				for model_class in self.all_model_classes:
  						lowerCAmelCase_     :							Any             =    True
  						self.check_hidden_states_output(a_		,    a_		,    a_		,    a_			)
  
  						# check that output_hidden_states also work using config
  						del inputs_dict["output_hidden_states"]
  						lowerCAmelCase_     :							Optional[Any]             =    True
  
  						self.check_hidden_states_output(a_		,    a_		,    a_		,    a_			)
  
  
  
  
  
  		def      lowerCamelCase (     self							:			Optional[Any]			):
  				lowerCAmelCase_       ,			lowerCAmelCase_     :							Dict             =    self.model_tester.prepare_config_and_inputs_for_common()
  				lowerCAmelCase_     :							int             =    3
  
  				lowerCAmelCase_     :							Dict             =    (
  				    self.model_tester.image_size
  				    if isinstance(self.model_tester.image_size		,    collections.abc.Iterable			)
  				    else (self.model_tester.image_size, self.model_tester.image_size)
  				)
  				lowerCAmelCase_     :							List[Any]             =    (
  				    config.patch_size
  				    if isinstance(config.patch_size		,    collections.abc.Iterable			)
  				    else (config.patch_size, config.patch_size)
  				)
  
  				lowerCAmelCase_     :							int             =    image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
  				lowerCAmelCase_     :							Any             =    image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])
  
  				for model_class in self.all_model_classes:
  						lowerCAmelCase_     :							Tuple             =    True
  						self.check_hidden_states_output(a_		,    a_		,    a_		,    (padded_height, padded_width)			)
  
  						# check that output_hidden_states also work using config
  						del inputs_dict["output_hidden_states"]
  						lowerCAmelCase_     :							int             =    True
  						self.check_hidden_states_output(a_		,    a_		,    a_		,    (padded_height, padded_width)			)
  
  
  
  
  
  		@slow
  		def      lowerCamelCase (     self							:			str			):
  				for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  						lowerCAmelCase_     :							List[str]             =    DonutSwinModel.from_pretrained(a_			)
  						self.assertIsNotNone(a_			)
  
  
  
  
  
  		def      lowerCamelCase (     self							:			str			):
  				lowerCAmelCase_       ,			lowerCAmelCase_     :							Optional[int]             =    self.model_tester.prepare_config_and_inputs_for_common()
  
  				lowerCAmelCase_     :							Union[str, Any]             =    _config_zero_init(a_			)
  				for model_class in self.all_model_classes:
  						lowerCAmelCase_     :							Union[str, Any]             =    model_class(config=a_			)
  						for name, param in model.named_parameters():
  								if "embeddings" not in name and param.requires_grad:
  										self.assertIn(
  										    ((param.data.mean() * 1e9).round() / 1e9).item()		,    [0.0, 1.0]		,    msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''		,    )
  
style_context: 
  
  
  
  
  
  
  """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""")
  
  lowercase__      =				"""K-MEANS-CLUST/ """
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase=None )		->					Optional[Any]:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		if seed is not None:  # useful for obtaining consistent results
  				np.random.seed(__UpperCamelCase )
  		lowerCAmelCase_     :							List[Any]             =    data.shape[0]  # number of data points
  
  		# Pick K indices from range [0, N).
  		lowerCAmelCase_     :							Optional[Any]             =    np.random.randint(0   , __UpperCamelCase   , __UpperCamelCase )
  
  		# 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_     :							List[str]             =    data[rand_indices, :]
  
  		return centroids
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase )		->					Dict:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		return pairwise_distances(__UpperCamelCase   , __UpperCamelCase   , metric="euclidean" )
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase )		->					List[str]:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_     :							Optional[Any]             =    centroid_pairwise_dist(__UpperCamelCase   , __UpperCamelCase )
  
  		# Compute cluster assignments for each data point:
  		# Fill in the blank (RHS only)
  		lowerCAmelCase_     :							str             =    np.argmin(__UpperCamelCase   , axis=1 )
  
  		return cluster_assignment
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase )		->					Dict:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_     :							Tuple             =    []
  		for i in range(__UpperCamelCase ):
  				# Select all data points that belong to cluster i. Fill in the blank (RHS only)
  				lowerCAmelCase_     :							List[Any]             =    data[cluster_assignment == i]
  				# Compute the mean of the data points. Fill in the blank (RHS only)
  				lowerCAmelCase_     :							List[str]             =    member_data_points.mean(axis=0 )
  				new_centroids.append(__UpperCamelCase )
  		lowerCAmelCase_     :							Tuple             =    np.array(__UpperCamelCase )
  
  		return new_centroids
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase )		->					int:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_     :							Union[str, Any]             =    0.0
  		for i in range(__UpperCamelCase ):
  				# Select all data points that belong to cluster i. Fill in the blank (RHS only)
  				lowerCAmelCase_     :							List[str]             =    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_     :							int             =    pairwise_distances(
  						    __UpperCamelCase   , [centroids[i]]   , metric="euclidean" )
  						lowerCAmelCase_     :							Optional[int]             =    distances**2
  						heterogeneity += np.sum(__UpperCamelCase )
  
  		return heterogeneity
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase )		->					Dict:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		plt.figure(figsize=(7, 4) )
  		plt.plot(__UpperCamelCase   , 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			(						__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase=500   , __UpperCamelCase=None   , __UpperCamelCase=False )		->					List[Any]:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_     :							Dict             =    initial_centroids[:]
  		lowerCAmelCase_     :							Optional[int]             =    None
  
  		for itr in range(__UpperCamelCase ):
  				if verbose:
  						print(__UpperCamelCase   , end="" )
  
  				# 1. Make cluster assignments using nearest centroids
  				lowerCAmelCase_     :							Optional[Any]             =    assign_clusters(__UpperCamelCase   , __UpperCamelCase )
  
  				# 2. Compute a new centroid for each of the k clusters, averaging all data
  				#    points assigned to that cluster.
  				lowerCAmelCase_     :							Tuple             =    revise_centroids(__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase )
  
  				# 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_     :							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
  						lowerCAmelCase_     :							Tuple             =    compute_heterogeneity(__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase )
  						record_heterogeneity.append(__UpperCamelCase )
  
  				lowerCAmelCase_     :							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
  
  					lowercase__      =				ds.load_iris()
  					lowercase__      =				3
  					lowercase__      =				[]
  					lowercase__      =				get_initial_centroids(dataset["""data"""], k, seed=0)
  					lowercase__ ,     lowercase__      =				kmeans(
  					    dataset["""data"""],
  					    k,
  					    initial_centroids,
  					    maxiter=400,
  					    record_heterogeneity=heterogeneity,
  					    verbose=True,
  					)
  					plot_heterogeneity(heterogeneity, k)
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase=None )		->					pd.DataFrame:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		if fill_missing_report:
  				lowerCAmelCase_     :							str             =    df.fillna(value=__UpperCamelCase )
  		lowerCAmelCase_     :							Optional[int]             =    1
  		lowerCAmelCase_     :							Optional[int]             =    df.select_dtypes(np.number ).columns
  		lowerCAmelCase_     :							Dict             =    (
  		    df.groupby(["Cluster"] )[  # construct report dataframe
  		        numeric_cols
  		    ]  # group by cluster number
  		    .agg(
  		        [
  		            ("sum", np.sum),
  		            ("mean_with_zeros", lambda __UpperCamelCase : np.mean(np.nan_to_num(__UpperCamelCase ) )),
  		            ("mean_without_zeros", lambda __UpperCamelCase : x.replace(0   , np.NaN ).mean()),
  		            (
  		                "mean_25-75",
  		                lambda __UpperCamelCase : np.mean(
  		                    np.nan_to_num(
  		                        sorted(__UpperCamelCase )[
  		                            round(len(__UpperCamelCase ) * 25 / 100 ) : round(len(__UpperCamelCase ) * 75 / 100 )
  		                        ] ) ),
  		            ),
  		            ("mean_with_na", np.mean),
  		            ("min", lambda __UpperCamelCase : x.min()),
  		            ("5%", lambda __UpperCamelCase : x.quantile(0.05 )),
  		            ("25%", lambda __UpperCamelCase : x.quantile(0.25 )),
  		            ("50%", lambda __UpperCamelCase : x.quantile(0.50 )),
  		            ("75%", lambda __UpperCamelCase : x.quantile(0.75 )),
  		            ("95%", lambda __UpperCamelCase : x.quantile(0.95 )),
  		            ("max", lambda __UpperCamelCase : x.max()),
  		            ("count", lambda __UpperCamelCase : x.count()),
  		            ("stdev", lambda __UpperCamelCase : x.std()),
  		            ("mode", lambda __UpperCamelCase : x.mode()[0]),
  		            ("median", lambda __UpperCamelCase : x.median()),
  		            ("# > 0", lambda __UpperCamelCase : (x > 0).sum()),
  		        ] )
  		    .T.reset_index()
  		    .rename(index=__UpperCamelCase   , columns={"level_0": "Features", "level_1": "Type"} )
  		)  # rename columns
  		# calculate the size of cluster(count of clientID's)
  		lowerCAmelCase_     :							Optional[Any]             =    report[
  		    (report["Features"] == "dummy") & (report["Type"] == "count")
  		].copy()  # avoid SettingWithCopyWarning
  		lowerCAmelCase_     :							List[Any]             =    (
  		    "ClusterSize"  # rename created cluster df to match report column names
  		)
  		lowerCAmelCase_     :							Dict             =    "# of Customers"
  		lowerCAmelCase_     :							List[str]             =    pd.DataFrame(
  		    clustersize.iloc[:, 2:].values
  		    / clustersize.iloc[:, 2:].values.sum() )
  		lowerCAmelCase_     :							Optional[Any]             =    "% of Customers"  # rename created cluster df to match report column names
  		lowerCAmelCase_     :							Dict             =    "ClusterProportion"
  		lowerCAmelCase_     :							Optional[Any]             =    clusterproportion.columns.tolist()
  		lowerCAmelCase_     :							Optional[Any]             =    cols[-2:] + cols[:-2]
  		lowerCAmelCase_     :							Dict             =    clusterproportion[cols]  # rearrange columns to match report
  		lowerCAmelCase_     :							Union[str, Any]             =    report.columns
  		lowerCAmelCase_     :							Dict             =    pd.DataFrame(
  		    abs(
  		        report[report["Type"] == "count"].iloc[:, 2:].values
  		        - clustersize.iloc[:, 2:].values ) )  # generating df with count of nan values
  		lowerCAmelCase_     :							Union[str, Any]             =    0
  		lowerCAmelCase_     :							Any             =    "# of nan"
  		lowerCAmelCase_     :							Dict             =    report[
  		    report["Type"] == "count"
  		].Features.tolist()  # filling values in order to match report
  		lowerCAmelCase_     :							Optional[Any]             =    a.columns.tolist()
  		lowerCAmelCase_     :							Optional[Any]             =    cols[-2:] + cols[:-2]
  		lowerCAmelCase_     :							str             =    a[cols]  # rearrange columns to match report
  		lowerCAmelCase_     :							Tuple             =    report.columns  # rename columns to match report
  		lowerCAmelCase_     :							List[str]             =    report.drop(
  		    report[report.Type == "count"].index )  # drop count values except cluster size
  		lowerCAmelCase_     :							Tuple             =    pd.concat(
  		    [report, a, clustersize, clusterproportion]   , axis=0 )  # concat report with clustert size and nan values
  		lowerCAmelCase_     :							List[Any]             =    report["Features"].isin(__UpperCamelCase )
  		lowerCAmelCase_     :							Tuple             =    report.columns.tolist()
  		lowerCAmelCase_     :							List[str]             =    cols[0:2] + cols[-1:] + cols[2:-1]
  		lowerCAmelCase_     :							List[str]             =    report[cols]
  		lowerCAmelCase_     :							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,
  		}
  		lowerCAmelCase_     :							List[str]             =    (
  		    report.assign(
  		        Sortera=lambda __UpperCamelCase : x.Type.map(__UpperCamelCase )   , Sortera=lambda __UpperCamelCase : list(reversed(range(len(__UpperCamelCase ) ) ) )   , )
  		    .sort_values(["Sorter1", "Mark", "Sorter2"]   , ascending=__UpperCamelCase )
  		    .drop(["Sorter1", "Sorter2"]   , axis=1 )
  		)
  		lowerCAmelCase_     :							str             =    ""
  		lowerCAmelCase_     :							Any             =    report.reset_index()
  		lowerCAmelCase_     :							Any             =    report.drop(columns=["index"] )
  		return report
  
  
  if __name__ == "__main__":
  					import doctest
  
  					doctest.testmod()
  