



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''')

__UpperCAmelCase						  =     """K-MEANS-CLUST/ """





def 						__lowerCamelCase       (      __magic_name__	:  List[str]     , __magic_name__	:  Union[str, Any]     , __magic_name__	:  Union[str, Any]=None						):
							if seed is not None:  # useful for obtaining consistent results
														np.random.seed(__lowerCamelCase						)
							a__:       int											=data.shape[0]  # number of data points

							# Pick K indices from range [0, N).
							a__:       str											=np.random.randint(0     , __lowerCamelCase     , __lowerCamelCase						)

							# 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__:       Optional[int]											=data[rand_indices, :]

							return centroids





def 						__lowerCamelCase       (      __magic_name__	:  Optional[int]     , __magic_name__	:  Union[str, Any]						):
							return pairwise_distances(__lowerCamelCase     , __lowerCamelCase     , metric="euclidean"						)





def 						__lowerCamelCase       (      __magic_name__	:  int     , __magic_name__	:  str						):
							a__:       Optional[Any]											=centroid_pairwise_dist(__lowerCamelCase     , __lowerCamelCase						)

							# Compute cluster assignments for each data point:
							# Fill in the blank (RHS only)
							a__:       str											=np.argmin(__lowerCamelCase     , axis=1						)

							return cluster_assignment





def 						__lowerCamelCase       (      __magic_name__	:  int     , __magic_name__	:  Dict     , __magic_name__	:  List[str]						):
							a__:       Any											=[]
							for i in range(__lowerCamelCase						):
														# Select all data points that belong to cluster i. Fill in the blank (RHS only)
														a__:       Any											=data[cluster_assignment == i]
														# Compute the mean of the data points. Fill in the blank (RHS only)
														a__:       List[str]											=member_data_points.mean(axis=0						)
														new_centroids.append(__lowerCamelCase						)
							a__:       str											=np.array(__lowerCamelCase						)

							return new_centroids





def 						__lowerCamelCase       (      __magic_name__	:  Optional[Any]     , __magic_name__	:  Union[str, Any]     , __magic_name__	:  List[Any]     , __magic_name__	:  List[Any]						):
							a__:       Tuple											=0.0
							for i in range(__lowerCamelCase						):
														# Select all data points that belong to cluster i. Fill in the blank (RHS only)
														a__:       int											=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__:       Dict											=pairwise_distances(
																					    __lowerCamelCase     , [centroids[i]]     , metric="euclidean"						)
																					a__:       Optional[Any]											=distances**2
																					heterogeneity += np.sum(__lowerCamelCase						)

							return heterogeneity





def 						__lowerCamelCase       (      __magic_name__	:  Dict     , __magic_name__	:  Dict						):
							plt.figure(figsize=(7, 4)						)
							plt.plot(__lowerCamelCase     , 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       (      __magic_name__	:  List[Any]     , __magic_name__	:  str     , __magic_name__	:  Optional[int]     , __magic_name__	:  Optional[Any]=500     , __magic_name__	:  str=None     , __magic_name__	:  int=False						):
							a__:       Tuple											=initial_centroids[:]
							a__:       Union[str, Any]											=None

							for itr in range(__lowerCamelCase						):
														if verbose:
																					print(__lowerCamelCase     , end=""						)

														# 1. Make cluster assignments using nearest centroids
														a__:       Optional[int]											=assign_clusters(__lowerCamelCase     , __lowerCamelCase						)

														# 2. Compute a new centroid for each of the k clusters, averaging all data
														#    points assigned to that cluster.
														a__:       Any											=revise_centroids(__lowerCamelCase     , __lowerCamelCase     , __lowerCamelCase						)

														# 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__:       Tuple											=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(__lowerCamelCase     , __lowerCamelCase     , __lowerCamelCase     , __lowerCamelCase						)
																					record_heterogeneity.append(__lowerCamelCase						)

														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

		__UpperCAmelCase						  =     ds.load_iris()
		__UpperCAmelCase						  =     3
		__UpperCAmelCase						  =     []
		__UpperCAmelCase						  =     get_initial_centroids(dataset['''data'''], k, seed=0)
		__UpperCAmelCase						  =     kmeans(
		    dataset['''data'''],
		    k,
		    initial_centroids,
		    maxiter=4_00,
		    record_heterogeneity=heterogeneity,
		    verbose=True,
		)
		plot_heterogeneity(heterogeneity, k)





def 						__lowerCamelCase       (      __magic_name__	:  List[str]     , __magic_name__	:  Union[str, Any]     , __magic_name__	:  Optional[Any]=None						):
							# Fill missing values with given rules
							if fill_missing_report:
														a__:       Union[str, Any]											=df.fillna(value=__lowerCamelCase						)
							a__:       Union[str, Any]											=1
							a__:       str											=df.select_dtypes(np.number						).columns
							a__:       Optional[Any]											=(
							    df.groupby(["Cluster"]						)[  # construct report dataframe
							        numeric_cols
							    ]  # group by cluster number
							    .agg(
							        [
							            ("sum", np.sum),
							            ("mean_with_zeros", lambda __magic_name__						: np.mean(np.nan_to_num(__lowerCamelCase						)						)),
							            ("mean_without_zeros", lambda __magic_name__						: x.replace(0     , np.NaN						).mean()),
							            (
							                "mean_25-75",
							                lambda __magic_name__						: np.mean(
							                    np.nan_to_num(
							                        sorted(__lowerCamelCase						)[
							                            round(len(__lowerCamelCase						) * 25 / 100						) : round(len(__lowerCamelCase						) * 75 / 100						)
							                        ]						)						),
							            ),
							            ("mean_with_na", np.mean),
							            ("min", lambda __magic_name__						: x.min()),
							            ("5%", lambda __magic_name__						: x.quantile(0.05						)),
							            ("25%", lambda __magic_name__						: x.quantile(0.25						)),
							            ("50%", lambda __magic_name__						: x.quantile(0.50						)),
							            ("75%", lambda __magic_name__						: x.quantile(0.75						)),
							            ("95%", lambda __magic_name__						: x.quantile(0.95						)),
							            ("max", lambda __magic_name__						: x.max()),
							            ("count", lambda __magic_name__						: x.count()),
							            ("stdev", lambda __magic_name__						: x.std()),
							            ("mode", lambda __magic_name__						: x.mode()[0]),
							            ("median", lambda __magic_name__						: x.median()),
							            ("# > 0", lambda __magic_name__						: (x > 0).sum()),
							        ]						)
							    .T.reset_index()
							    .rename(index=__lowerCamelCase     , columns={"level_0": "Features", "level_1": "Type"}						)
							)  # rename columns
							# calculate the size of cluster(count of clientID's)
							a__:       Dict											=report[
							    (report["""Features"""] == """dummy""") & (report["""Type"""] == """count""")
							].copy()  # avoid SettingWithCopyWarning
							a__:       Dict											=(
							    """ClusterSize"""  # rename created cluster df to match report column names
							)
							a__:       Optional[Any]											="""# of Customers"""
							a__:       Any											=pd.DataFrame(
							    clustersize.iloc[:, 2:].values
							    / clustersize.iloc[:, 2:].values.sum()						)
							a__:       List[Any]											="""% of Customers"""  # rename created cluster df to match report column names
							a__:       str											="""ClusterProportion"""
							a__:       List[Any]											=clusterproportion.columns.tolist()
							a__:       Optional[int]											=cols[-2:] + cols[:-2]
							a__:       List[Any]											=clusterproportion[cols]  # rearrange columns to match report
							a__:       Dict											=report.columns
							a__:       str											=pd.DataFrame(
							    abs(
							        report[report["Type"] == "count"].iloc[:, 2:].values
							        - clustersize.iloc[:, 2:].values						)						)  # generating df with count of nan values
							a__:       List[str]											=0
							a__:       Dict											="""# of nan"""
							a__:       Tuple											=report[
							    report["""Type"""] == """count"""
							].Features.tolist()  # filling values in order to match report
							a__:       Tuple											=a.columns.tolist()
							a__:       str											=cols[-2:] + cols[:-2]
							a__:       Optional[int]											=a[cols]  # rearrange columns to match report
							a__:       Optional[Any]											=report.columns  # rename columns to match report
							a__:       Optional[Any]											=report.drop(
							    report[report.Type == "count"].index						)  # drop count values except cluster size
							a__:       str											=pd.concat(
							    [report, a, clustersize, clusterproportion]     , axis=0						)  # concat report with clustert size and nan values
							a__:       int											=report["""Features"""].isin(__lowerCamelCase						)
							a__:       Optional[int]											=report.columns.tolist()
							a__:       Optional[Any]											=cols[0:2] + cols[-1:] + cols[2:-1]
							a__:       Any											=report[cols]
							a__:       Optional[int]											={
							    """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__:       List[Any]											=(
							    report.assign(
							        Sortera=lambda __magic_name__						: x.Type.map(__lowerCamelCase						)     , Sortera=lambda __magic_name__						: list(reversed(range(len(__lowerCamelCase						)						)						)						)     , )
							    .sort_values(["Sorter1", "Mark", "Sorter2"]     , ascending=__lowerCamelCase						)
							    .drop(["Sorter1", "Sorter2"]     , axis=1						)
							)
							a__:       str											=""""""
							a__:       int											=report.reset_index()
							a__:       Any											=report.drop(columns=["index"]						)
							return report


if __name__ == "__main__":
		import doctest

		doctest.testmod()










from typing import Callable, List, Optional, Union

import torch

from ...models import UNetaDModel
from ...schedulers import CMStochasticIterativeScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput


__UpperCAmelCase						  =     logging.get_logger(__name__)  # pylint: disable=invalid-name


__UpperCAmelCase						  =     '''
    Examples:
        ```py
        >>> import torch

        >>> from diffusers import ConsistencyModelPipeline

        >>> device = "cuda"
        >>> # Load the cd_imagenet64_l2 checkpoint.
        >>> model_id_or_path = "openai/diffusers-cd_imagenet64_l2"
        >>> pipe = ConsistencyModelPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16)
        >>> pipe.to(device)

        >>> # Onestep Sampling
        >>> image = pipe(num_inference_steps=1).images[0]
        >>> image.save("cd_imagenet64_l2_onestep_sample.png")

        >>> # Onestep sampling, class-conditional image generation
        >>> # ImageNet-64 class label 145 corresponds to king penguins
        >>> image = pipe(num_inference_steps=1, class_labels=145).images[0]
        >>> image.save("cd_imagenet64_l2_onestep_sample_penguin.png")

        >>> # Multistep sampling, class-conditional image generation
        >>> # Timesteps can be explicitly specified; the particular timesteps below are from the original Github repo:
        >>> # https://github.com/openai/consistency_models/blob/main/scripts/launch.sh#L77
        >>> image = pipe(num_inference_steps=None, timesteps=[22, 0], class_labels=145).images[0]
        >>> image.save("cd_imagenet64_l2_multistep_sample_penguin.png")
        ```
'''


class 	lowerCamelCase__ (		_a   ):


						def __init__( self						:  str      ,       _a						:  UNetaDModel      ,       _a						:  CMStochasticIterativeScheduler			):
													super().__init__()

													self.register_modules(
													    unet=_a      ,       scheduler=_a      ,       )

													a__:       Union[str, Any]											=None


						def   _lowerCamelCase			( self						:  List[Any]      ,       _a						:  Any=0			):
													if is_accelerate_available() and is_accelerate_version(">="      ,       "0.14.0"			):
																				from accelerate import cpu_offload
													else:
																				raise ImportError("`enable_sequential_cpu_offload` requires `accelerate v0.14.0` or higher"			)

													a__:       Optional[Any]											=torch.device(F"cuda:{gpu_id}"			)

													if self.device.type != "cpu":
																				self.to("cpu"      ,       silence_dtype_warnings=_a			)
																				torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

													for cpu_offloaded_model in [self.unet]:
																				cpu_offload(_a      ,       _a			)

													if self.safety_checker is not None:
																				cpu_offload(self.safety_checker      ,       execution_device=_a      ,       offload_buffers=_a			)


						def   _lowerCamelCase			( self						:  List[str]      ,       _a						:  Optional[int]=0			):
													if is_accelerate_available() and is_accelerate_version(">="      ,       "0.17.0.dev0"			):
																				from accelerate import cpu_offload_with_hook
													else:
																				raise ImportError("`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher."			)

													a__:       Union[str, Any]											=torch.device(F"cuda:{gpu_id}"			)

													if self.device.type != "cpu":
																				self.to("cpu"      ,       silence_dtype_warnings=_a			)
																				torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

													a__:       Optional[Any]											=None
													for cpu_offloaded_model in [self.unet]:
																				a__							,			a__:       Optional[Any]											=cpu_offload_with_hook(_a      ,       _a      ,       prev_module_hook=_a			)

													if self.safety_checker is not None:
																				a__							,			a__:       Optional[Any]											=cpu_offload_with_hook(self.safety_checker      ,       _a      ,       prev_module_hook=_a			)

													# We'll offload the last model manually.
													a__:       Optional[Any]											=hook


						@property
						# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
						def   _lowerCamelCase			( self						:  Tuple			):
													if not hasattr(self.unet      ,       "_hf_hook"			):
																				return self.device
													for module in self.unet.modules():
																				if (
																				    hasattr(_a      ,       "_hf_hook"			)
																				    and hasattr(module._hf_hook      ,       "execution_device"			)
																				    and module._hf_hook.execution_device is not None
																				):
																											return torch.device(module._hf_hook.execution_device			)
													return self.device


						def   _lowerCamelCase			( self						:  Dict      ,       _a						:  List[Any]      ,       _a						:  Optional[int]      ,       _a						:  Dict      ,       _a						:  List[Any]      ,       _a						:  List[str]      ,       _a						:  Union[str, Any]      ,       _a						:  str      ,       _a						:  int=None			):
													a__:       List[str]											=(batch_size, num_channels, height, width)
													if isinstance(_a      ,       _a			) and len(_a			) != batch_size:
																				raise ValueError(
																				    F"You have passed a list of generators of length {len(_a			)}, but requested an effective batch"
																				    F" size of {batch_size}. Make sure the batch size matches the length of the generators."			)

													if latents is None:
																				a__:       Dict											=randn_tensor(_a      ,       generator=_a      ,       device=_a      ,       dtype=_a			)
													else:
																				a__:       List[Any]											=latents.to(device=_a      ,       dtype=_a			)

													# scale the initial noise by the standard deviation required by the scheduler
													a__:       int											=latents * self.scheduler.init_noise_sigma
													return latents


						def   _lowerCamelCase			( self						:  Dict      ,       _a						:  torch.FloatTensor      ,       _a						:  str = "pil"			):
													if output_type not in ["pt", "np", "pil"]:
																				raise ValueError(
																				    F"output_type={output_type} is not supported. Make sure to choose one of ['pt', 'np', or 'pil']"			)

													# Equivalent to diffusers.VaeImageProcessor.denormalize
													a__:       Tuple											=(sample / 2 + 0.5).clamp(0      ,       1			)
													if output_type == "pt":
																				return sample

													# Equivalent to diffusers.VaeImageProcessor.pt_to_numpy
													a__:       Tuple											=sample.cpu().permute(0      ,       2      ,       3      ,       1			).numpy()
													if output_type == "np":
																				return sample

													# Output_type must be 'pil'
													a__:       List[Any]											=self.numpy_to_pil(_a			)
													return sample


						def   _lowerCamelCase			( self						:  Tuple      ,       _a						:  Dict      ,       _a						:  Optional[Any]      ,       _a						:  List[str]=None			):
													if self.unet.config.num_class_embeds is not None:
																				if isinstance(_a      ,       _a			):
																											a__:       List[str]											=torch.tensor(_a      ,       dtype=torch.int			)
																				elif isinstance(_a      ,       _a			):
																											assert batch_size == 1, "Batch size must be 1 if classes is an int"
																											a__:       List[str]											=torch.tensor([class_labels]      ,       dtype=torch.int			)
																				elif class_labels is None:
																											# Randomly generate batch_size class labels
																											# TODO: should use generator here? int analogue of randn_tensor is not exposed in ...utils
																											a__:       Union[str, Any]											=torch.randint(0      ,       self.unet.config.num_class_embeds      ,       size=(batch_size,)			)
																				a__:       Dict											=class_labels.to(_a			)
													else:
																				a__:       List[str]											=None
													return class_labels


						def   _lowerCamelCase			( self						:  Union[str, Any]      ,       _a						:  Optional[Any]      ,       _a						:  Optional[int]      ,       _a						:  List[Any]      ,       _a						:  List[str]      ,       _a						:  Optional[int]      ,       _a						:  Optional[Any]			):
													if num_inference_steps is None and timesteps is None:
																				raise ValueError("Exactly one of `num_inference_steps` or `timesteps` must be supplied."			)

													if num_inference_steps is not None and timesteps is not None:
																				logger.warning(
																				    F"Both `num_inference_steps`: {num_inference_steps} and `timesteps`: {timesteps} are supplied;"
																				    " `timesteps` will be used over `num_inference_steps`."			)

													if latents is not None:
																				a__:       Tuple											=(batch_size, 3, img_size, img_size)
																				if latents.shape != expected_shape:
																											raise ValueError(F"The shape of latents is {latents.shape} but is expected to be {expected_shape}."			)

													if (callback_steps is None) or (
													    callback_steps is not None and (not isinstance(_a      ,       _a			) or callback_steps <= 0)
													):
																				raise ValueError(
																				    F"`callback_steps` has to be a positive integer but is {callback_steps} of type"
																				    F" {type(_a			)}."			)







						@torch.no_grad()
						@replace_example_docstring(_a			)
						def __call__( self						:  Dict      ,       _a						:  int = 1      ,       _a						:  Optional[Union[torch.Tensor, List[int], int]] = None      ,       _a						:  int = 1      ,       _a						:  List[int] = None      ,       _a						:  Optional[Union[torch.Generator, List[torch.Generator]]] = None      ,       _a						:  Optional[torch.FloatTensor] = None      ,       _a						:  Optional[str] = "pil"      ,       _a						:  bool = True      ,       _a						:  Optional[Callable[[int, int, torch.FloatTensor], None]] = None      ,       _a						:  int = 1      ,       ):
													a__:       int											=self.unet.config.sample_size
													a__:       Union[str, Any]											=self._execution_device

													# 1. Check inputs
													self.check_inputs(_a      ,       _a      ,       _a      ,       _a      ,       _a      ,       _a			)

													# 2. Prepare image latents
													# Sample image latents x_0 ~ N(0, sigma_0^2 * I)
													a__:       Tuple											=self.prepare_latents(
													    batch_size=_a      ,       num_channels=self.unet.config.in_channels      ,       height=_a      ,       width=_a      ,       dtype=self.unet.dtype      ,       device=_a      ,       generator=_a      ,       latents=_a      ,       )

													# 3. Handle class_labels for class-conditional models
													a__:       int											=self.prepare_class_labels(_a      ,       _a      ,       class_labels=_a			)

													# 4. Prepare timesteps
													if timesteps is not None:
																				self.scheduler.set_timesteps(timesteps=_a      ,       device=_a			)
																				a__:       str											=self.scheduler.timesteps
																				a__:       List[str]											=len(_a			)
													else:
																				self.scheduler.set_timesteps(_a			)
																				a__:       Optional[int]											=self.scheduler.timesteps

													# 5. Denoising loop
													# Multistep sampling: implements Algorithm 1 in the paper
													with self.progress_bar(total=_a			) as progress_bar:
																				for i, t in enumerate(_a			):
																											a__:       Any											=self.scheduler.scale_model_input(_a      ,       _a			)
																											a__:       Dict											=self.unet(_a      ,       _a      ,       class_labels=_a      ,       return_dict=_a			)[0]

																											a__:       int											=self.scheduler.step(_a      ,       _a      ,       _a      ,       generator=_a			)[0]

																											# call the callback, if provided
																											progress_bar.update()
																											if callback is not None and i % callback_steps == 0:
																																		callback(_a      ,       _a      ,       _a			)

        # 6. Post-process image sample
													a__:       List[str]											=self.postprocess_image(_a      ,       output_type=_a			)

													# Offload last model to CPU
													if hasattr(self      ,       "final_offload_hook"			) and self.final_offload_hook is not None:
																				self.final_offload_hook.offload()

													if not return_dict:
																				return (image,)

													return ImagePipelineOutput(images=_a			)





