


'''simple docstring'''
from sklearn.metrics import matthews_corrcoef

import datasets


__snake_case							      =     '''
Compute the Matthews correlation coefficient (MCC)

The Matthews correlation coefficient is used in machine learning as a
measure of the quality of binary and multiclass classifications. It takes
into account true and false positives and negatives and is generally
regarded as a balanced measure which can be used even if the classes are of
very different sizes. The MCC is in essence a correlation coefficient value
between -1 and +1. A coefficient of +1 represents a perfect prediction, 0
an average random prediction and -1 an inverse prediction.  The statistic
is also known as the phi coefficient. [source: Wikipedia]
'''

__snake_case							      =     '''
Args:
    predictions (list of int): Predicted labels, as returned by a model.
    references (list of int): Ground truth labels.
    sample_weight (list of int, float, or bool): Sample weights. Defaults to `None`.
Returns:
    matthews_correlation (dict containing float): Matthews correlation.
Examples:
    Example 1, a basic example with only predictions and references as inputs:
        >>> matthews_metric = datasets.load_metric("matthews_correlation")
        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],
        ...                                     predictions=[1, 2, 2, 0, 3, 3])
        >>> print(round(results[\'matthews_correlation\'], 2))
        0.54

    Example 2, the same example as above, but also including sample weights:
        >>> matthews_metric = datasets.load_metric("matthews_correlation")
        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],
        ...                                     predictions=[1, 2, 2, 0, 3, 3],
        ...                                     sample_weight=[0.5, 3, 1, 1, 1, 2])
        >>> print(round(results[\'matthews_correlation\'], 2))
        0.1

    Example 3, the same example as above, but with sample weights that cause a negative correlation:
        >>> matthews_metric = datasets.load_metric("matthews_correlation")
        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],
        ...                                     predictions=[1, 2, 2, 0, 3, 3],
        ...                                     sample_weight=[0.5, 1, 0, 0, 0, 1])
        >>> print(round(results[\'matthews_correlation\'], 2))
        -0.25
'''

__snake_case							      =     '''\
@article{scikit-learn,
  title={Scikit-learn: Machine Learning in {P}ython},
  author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
  journal={Journal of Machine Learning Research},
  volume={12},
  pages={2825--2830},
  year={2011}
}
'''
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION	,		_KWARGS_DESCRIPTION					)
class    lowercase	(							datasets.Metric					):

		"""simple docstring"""

		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							return datasets.MetricInfo(
							    description=_DESCRIPTION    ,   citation=_CITATION    ,   inputs_description=_KWARGS_DESCRIPTION    ,   features=datasets.Features(
							        {
							            '''predictions''': datasets.Value('''int32'''							),
							            '''references''': datasets.Value('''int32'''							),
							        }							)    ,   reference_urls=[
							        '''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html'''
							    ]    ,   )




		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_=None							):

							'''simple docstring'''


							return {
							    "matthews_correlation": float(matthews_corrcoef(UpperCamelCase_    ,   UpperCamelCase_    ,   sample_weight=UpperCamelCase_							)							),
							}







"""simple docstring"""



import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetImgaImgPipeline,
    KandinskyVaaPriorEmbaEmbPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()





class 					_UpperCAmelCase       ( _A   ,						unittest.TestCase							):
					SCREAMING_SNAKE_CASE_		:				Any							    =   KandinskyVaaControlnetImgaImgPipeline
					SCREAMING_SNAKE_CASE_		:				Optional[int]							    =   ["image_embeds", "negative_image_embeds", "image", "hint"]
					SCREAMING_SNAKE_CASE_		:				str							    =   ["image_embeds", "negative_image_embeds", "image", "hint"]
					SCREAMING_SNAKE_CASE_		:				Dict							    =   [
					    "generator",
					    "height",
					    "width",
					    "strength",
					    "guidance_scale",
					    "num_inference_steps",
					    "return_dict",
					    "guidance_scale",
					    "num_images_per_prompt",
					    "output_type",
					    "return_dict",
					]
					SCREAMING_SNAKE_CASE_		:				Dict							    =   False




					@property
					def   A  (				self     :						Any   )  ->  Any:
							return 32




					@property
					def   A  (				self     :						Optional[int]   )  ->  Any:
							return 32




					@property
					def   A  (				self     :						Dict   )  ->  int:
							return self.time_input_dim




					@property
					def   A  (				self     :						Tuple   )  ->  str:
							return self.time_input_dim * 4




					@property
					def   A  (				self     :						Any   )  ->  str:
							return 1_00




					@property
					def   A  (				self     :						str   )  ->  List[str]:
							torch.manual_seed(0   )

							lowercase_ : List[Any]							       =   {
							    '''in_channels''': 8,
							    # Out channels is double in channels because predicts mean and variance
							    '''out_channels''': 8,
							    '''addition_embed_type''': '''image_hint''',
							    '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
							    '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
							    '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
							    '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
							    '''layers_per_block''': 1,
							    '''encoder_hid_dim''': self.text_embedder_hidden_size,
							    '''encoder_hid_dim_type''': '''image_proj''',
							    '''cross_attention_dim''': self.cross_attention_dim,
							    '''attention_head_dim''': 4,
							    '''resnet_time_scale_shift''': '''scale_shift''',
							    '''class_embed_type''': None,
							}

							lowercase_ : Dict							       =   UNetaDConditionModel(**A   )
							return model




					@property
					def   A  (				self     :						Optional[Any]   )  ->  Union[str, Any]:
							return {
							    "block_out_channels": [32, 32, 64, 64],
							    "down_block_types": [
							        "DownEncoderBlock2D",
							        "DownEncoderBlock2D",
							        "DownEncoderBlock2D",
							        "AttnDownEncoderBlock2D",
							    ],
							    "in_channels": 3,
							    "latent_channels": 4,
							    "layers_per_block": 1,
							    "norm_num_groups": 8,
							    "norm_type": "spatial",
							    "num_vq_embeddings": 12,
							    "out_channels": 3,
							    "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
							    "vq_embed_dim": 4,
							}




					@property
					def   A  (				self     :						List[Any]   )  ->  Dict:
							torch.manual_seed(0   )
							lowercase_ : int							       =   VQModel(**self.dummy_movq_kwargs   )
							return model




					def   A  (				self     :						Union[str, Any]   )  ->  Optional[int]:
							lowercase_ : Tuple							       =   self.dummy_unet
							lowercase_ : int							       =   self.dummy_movq

							lowercase_ : List[Any]							       =   {
							    '''num_train_timesteps''': 10_00,
							    '''beta_schedule''': '''linear''',
							    '''beta_start''': 0.00085,
							    '''beta_end''': 0.012,
							    '''clip_sample''': False,
							    '''set_alpha_to_one''': False,
							    '''steps_offset''': 0,
							    '''prediction_type''': '''epsilon''',
							    '''thresholding''': False,
							}

							lowercase_ : str							       =   DDIMScheduler(**A   )

							lowercase_ : Tuple							       =   {
							    '''unet''': unet,
							    '''scheduler''': scheduler,
							    '''movq''': movq,
							}

							return components




					def   A  (				self     :						Optional[int]    ,						A     :						int    ,						A     :						List[str]=0   )  ->  int:
							lowercase_ : str							       =   floats_tensor((1, self.text_embedder_hidden_size)    ,						rng=random.Random(A   )   ).to(A   )
							lowercase_ : Tuple							       =   floats_tensor((1, self.text_embedder_hidden_size)    ,						rng=random.Random(seed + 1   )   ).to(
							    A   )
							# create init_image
							lowercase_ : Union[str, Any]							       =   floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(A   )   ).to(A   )
							lowercase_ : Any							       =   image.cpu().permute(0    ,						2    ,						3    ,						1   )[0]
							lowercase_ : Optional[Any]							       =   Image.fromarray(np.uinta(A   )   ).convert('''RGB'''   ).resize((2_56, 2_56)   )
							# create hint
							lowercase_ : Optional[int]							       =   floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(A   )   ).to(A   )

							if str(A   ).startswith('''mps'''   ):
									lowercase_ : Optional[Any]							       =   torch.manual_seed(A   )
							else:
									lowercase_ : List[Any]							       =   torch.Generator(device=A   ).manual_seed(A   )
							lowercase_ : Dict							       =   {
							    '''image''': init_image,
							    '''image_embeds''': image_embeds,
							    '''negative_image_embeds''': negative_image_embeds,
							    '''hint''': hint,
							    '''generator''': generator,
							    '''height''': 64,
							    '''width''': 64,
							    '''num_inference_steps''': 10,
							    '''guidance_scale''': 7.0,
							    '''strength''': 0.2,
							    '''output_type''': '''np''',
							}
							return inputs






					def   A  (				self     :						Any   )  ->  List[Any]:
							lowercase_ : List[str]							       =   '''cpu'''

							lowercase_ : Any							       =   self.get_dummy_components()

							lowercase_ : Any							       =   self.pipeline_class(**A   )
							lowercase_ : int							       =   pipe.to(A   )

							pipe.set_progress_bar_config(disable=A   )

							lowercase_ : Dict							       =   pipe(**self.get_dummy_inputs(A   )   )
							lowercase_ : str							       =   output.images

							lowercase_ : int							       =   pipe(
							    **self.get_dummy_inputs(A   )    ,						return_dict=A    ,						)[0]

							lowercase_ : Dict							       =   image[0, -3:, -3:, -1]
							lowercase_ : Union[str, Any]							       =   image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							lowercase_ : List[str]							       =   np.array(
							    [0.54985034, 0.55509365, 0.52561504, 0.5570494, 0.5593818, 0.5263979, 0.50285643, 0.5069846, 0.51196736]   )
							assert (
							    np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2
							), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}'''
							assert (
							    np.abs(image_from_tuple_slice.flatten() - expected_slice   ).max() < 1e-2
							), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'''





@slow
@require_torch_gpu
class 					_UpperCAmelCase       ( unittest.TestCase							):




					def   A  (				self     :						Tuple   )  ->  str:
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()






					def   A  (				self     :						Any   )  ->  Optional[int]:
							lowercase_ : Dict							       =   load_numpy(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
							    '''/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy'''   )

							lowercase_ : Dict							       =   load_image(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png'''   )
							lowercase_ : Optional[int]							       =   init_image.resize((5_12, 5_12)   )

							lowercase_ : Dict							       =   load_image(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
							    '''/kandinskyv22/hint_image_cat.png'''   )
							lowercase_ : Optional[int]							       =   torch.from_numpy(np.array(A   )   ).float() / 255.0
							lowercase_ : Tuple							       =   hint.permute(2    ,						0    ,						1   ).unsqueeze(0   )

							lowercase_ : Optional[Any]							       =   '''A robot, 4k photo'''

							lowercase_ : Tuple							       =   KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
							    '''kandinsky-community/kandinsky-2-2-prior'''    ,						torch_dtype=torch.floataa   )
							pipe_prior.to(A   )

							lowercase_ : Dict							       =   KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
							    '''kandinsky-community/kandinsky-2-2-controlnet-depth'''    ,						torch_dtype=torch.floataa   )
							lowercase_ : int							       =   pipeline.to(A   )

							pipeline.set_progress_bar_config(disable=A   )

							lowercase_ : Tuple							       =   torch.Generator(device='''cpu'''   ).manual_seed(0   )

							lowercase_       ,					lowercase_ : int							       =   pipe_prior(
							    A    ,						image=A    ,						strength=0.85    ,						generator=A    ,						negative_prompt=''''''    ,						).to_tuple()

							lowercase_ : str							       =   pipeline(
							    image=A    ,						image_embeds=A    ,						negative_image_embeds=A    ,						hint=A    ,						generator=A    ,						num_inference_steps=1_00    ,						height=5_12    ,						width=5_12    ,						strength=0.5    ,						output_type='''np'''    ,						)

							lowercase_ : Optional[Any]							       =   output.images[0]

							assert image.shape == (5_12, 5_12, 3)

							assert_mean_pixel_difference(A    ,						A   )



