


'''simple docstring'''


import os
import tempfile
import unittest

import numpy as np
import torch

from diffusers.models import ModelMixin, UNetaDConditionModel
from diffusers.models.attention_processor import AttnProcessor, LoRAAttnProcessor
from diffusers.utils import (
    floats_tensor,
    logging,
    skip_mps,
    torch_device,
)
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()

_UpperCamelCase          =     logging.get_logger(__name__)


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE = True       ):




     '''simple docstring'''





     __A  :					str						     =       {}
     for name in model.attn_processors.keys():
          __A  :					str						     =       name.endswith("attn2.processor"       ) and not (
              name.startswith("transformer_in"       ) or "temp_attentions" in name.split("."       )
          )
          __A  :					Optional[Any]						     =       model.config.cross_attention_dim if has_cross_attention else None
          if name.startswith("mid_block"       ):
               __A  :					Any						     =       model.config.block_out_channels[-1]
          elif name.startswith("up_blocks"       ):
               __A  :					List[str]						     =       int(name[len("up_blocks."       )]       )
               __A  :					Any						     =       list(reversed(model.config.block_out_channels       )       )[block_id]
          elif name.startswith("down_blocks"       ):
               __A  :					int						     =       int(name[len("down_blocks."       )]       )
               __A  :					Any						     =       model.config.block_out_channels[block_id]
          elif name.startswith("transformer_in"       ):
               # Note that the `8 * ...` comes from: https://github.com/huggingface/diffusers/blob/7139f0e874f10b2463caa8cbd585762a309d12d6/src/diffusers/models/unet_3d_condition.py#L148
               __A  :					Union[str, Any]						     =       8 * model.config.attention_head_dim

          __A  :					Optional[Any]						     =       LoRAAttnProcessor(hidden_size=SCREAMING_SNAKE_CASE					,				cross_attention_dim=SCREAMING_SNAKE_CASE       )
          __A  :					List[Any]						     =       lora_attn_procs[name].to(model.device       )

          if mock_weights:
               # add 1 to weights to mock trained weights
               with torch.no_grad():
                    lora_attn_procs[name].to_q_lora.up.weight += 1
                    lora_attn_procs[name].to_k_lora.up.weight += 1
                    lora_attn_procs[name].to_v_lora.up.weight += 1
                    lora_attn_procs[name].to_out_lora.up.weight += 1

     return lora_attn_procs







@skip_mps
class        __magic_name__  (					lowerCAmelCase						,		lowerCAmelCase						,		unittest.TestCase   ):

     """simple docstring"""






     lowerCamelCase__						=							UNetaDConditionModel
     lowerCamelCase__						=							'sample'


     @property
     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					str						     =       4
          __A  :					Optional[int]						     =       4
          __A  :					Optional[int]						     =       4
          __A  :					List[str]						     =       (32, 32)

          __A  :					Tuple						     =       floats_tensor((batch_size, num_channels, num_frames) + sizes		).to(lowerCamelCase		)
          __A  :					int						     =       torch.tensor([10]		).to(lowerCamelCase		)
          __A  :					Tuple						     =       floats_tensor((batch_size, 4, 32)		).to(lowerCamelCase		)

          return {"sample": noise, "timestep": time_step, "encoder_hidden_states": encoder_hidden_states}


     @property
     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          return (4, 4, 32, 32)


     @property
     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          return (4, 4, 32, 32)


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Any						     =       {
              "block_out_channels": (32, 64),
              "down_block_types": (
                  "CrossAttnDownBlock3D",
                  "DownBlock3D",
              ),
              "up_block_types": ("UpBlock3D", "CrossAttnUpBlock3D"),
              "cross_attention_dim": 32,
              "attention_head_dim": 8,
              "out_channels": 4,
              "in_channels": 4,
              "layers_per_block": 1,
              "sample_size": 32,
          }
          __A  :					Union[str, Any]						     =       self.dummy_input
          return init_dict, inputs_dict


     @unittest.skipIf(
         torch_device != "cuda" or not is_xformers_available() ,    reason="XFormers attention is only available with CUDA and `xformers` installed" ,    )
     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A     ,__A  :					int						     =       self.prepare_init_args_and_inputs_for_common()
          __A  :					List[str]						     =       self.model_class(**lowerCamelCase		)

          model.enable_xformers_memory_efficient_attention()

          assert (
              model.mid_block.attentions[0].transformer_blocks[0].attna.processor.__class__.__name__
              == "XFormersAttnProcessor"
          ), "xformers is not enabled"


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A     ,__A  :					Dict						     =       self.prepare_init_args_and_inputs_for_common()

          __A  :					Optional[int]						     =       32

          __A  :					Any						     =       self.model_class(**lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          with torch.no_grad():
               __A  :					Dict						     =       model(**lowerCamelCase		)

               if isinstance(lowerCamelCase ,    lowerCamelCase		):
                    __A  :					int						     =       output.sample

          self.assertIsNotNone(lowerCamelCase		)
          __A  :					Union[str, Any]						     =       inputs_dict["sample"].shape
          self.assertEqual(output.shape ,    lowerCamelCase ,    "Input and output shapes do not match"		)


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A     ,__A  :					List[Any]						     =       self.prepare_init_args_and_inputs_for_common()
          __A  :					Dict						     =       self.model_class(**lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          with torch.no_grad():
               # Warmup pass when using mps (see #372)
               if torch_device == "mps" and isinstance(lowerCamelCase ,    lowerCamelCase		):
                    model(**self.dummy_input		)

               __A  :					Tuple						     =       model(**lowerCamelCase		)
               if isinstance(lowerCamelCase ,    lowerCamelCase		):
                    __A  :					Optional[int]						     =       first.sample

               __A  :					Union[str, Any]						     =       model(**lowerCamelCase		)
               if isinstance(lowerCamelCase ,    lowerCamelCase		):
                    __A  :					Optional[Any]						     =       second.sample

          __A  :					int						     =       first.cpu().numpy()
          __A  :					Optional[Any]						     =       second.cpu().numpy()
          __A  :					Tuple						     =       out_a[~np.isnan(lowerCamelCase		)]
          __A  :					Union[str, Any]						     =       out_a[~np.isnan(lowerCamelCase		)]
          __A  :					Any						     =       np.amax(np.abs(out_a - out_a		)		)
          self.assertLessEqual(lowerCamelCase ,    1E-5		)


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A     ,__A  :					Optional[int]						     =       self.prepare_init_args_and_inputs_for_common()

          __A  :					str						     =       8

          __A  :					List[str]						     =       self.model_class(**lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          model.set_attention_slice("auto"		)
          with torch.no_grad():
               __A  :					Any						     =       model(**lowerCamelCase		)
          assert output is not None

          model.set_attention_slice("max"		)
          with torch.no_grad():
               __A  :					Union[str, Any]						     =       model(**lowerCamelCase		)
          assert output is not None

          model.set_attention_slice(2		)
          with torch.no_grad():
               __A  :					str						     =       model(**lowerCamelCase		)
          assert output is not None


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A     ,__A  :					Union[str, Any]						     =       self.prepare_init_args_and_inputs_for_common()

          __A  :					List[Any]						     =       8

          __A  :					List[Any]						     =       self.model_class(**lowerCamelCase		)
          model.to(lowerCamelCase		)

          with torch.no_grad():
               __A  :					Any						     =       model(**lowerCamelCase		).sample

          __A  :					int						     =       create_lora_layers(lowerCamelCase		)

          # make sure we can set a list of attention processors
          model.set_attn_processor(lowerCamelCase		)
          model.to(lowerCamelCase		)

          # test that attn processors can be set to itself
          model.set_attn_processor(model.attn_processors		)

          with torch.no_grad():
               __A  :					Optional[int]						     =       model(**lowerCamelCase ,    cross_attention_kwargs={"scale": 0.0}		).sample
               __A  :					Tuple						     =       model(**lowerCamelCase ,    cross_attention_kwargs={"scale": 0.5}		).sample
               __A  :					List[Any]						     =       model(**lowerCamelCase ,    cross_attention_kwargs={"scale": 0.5}		).sample

          assert (samplea - samplea).abs().max() < 3E-3
          assert (samplea - samplea).abs().max() < 3E-3

          # sample 2 and sample 3 should be different
          assert (samplea - samplea).abs().max() > 3E-3


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A     ,__A  :					Optional[Any]						     =       self.prepare_init_args_and_inputs_for_common()

          __A  :					Dict						     =       8

          torch.manual_seed(0		)
          __A  :					Optional[int]						     =       self.model_class(**lowerCamelCase		)
          model.to(lowerCamelCase		)

          with torch.no_grad():
               __A  :					int						     =       model(**lowerCamelCase		).sample

          __A  :					Any						     =       create_lora_layers(lowerCamelCase		)
          model.set_attn_processor(lowerCamelCase		)

          with torch.no_grad():
               __A  :					str						     =       model(**lowerCamelCase ,    cross_attention_kwargs={"scale": 0.5}		).sample

          with tempfile.TemporaryDirectory() as tmpdirname:
               model.save_attn_procs(lowerCamelCase		)
               self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase ,    "pytorch_lora_weights.bin"		)		)		)
               torch.manual_seed(0		)
               __A  :					Dict						     =       self.model_class(**lowerCamelCase		)
               new_model.to(lowerCamelCase		)
               new_model.load_attn_procs(lowerCamelCase		)

          with torch.no_grad():
               __A  :					Optional[int]						     =       new_model(**lowerCamelCase ,    cross_attention_kwargs={"scale": 0.5}		).sample

          assert (sample - new_sample).abs().max() < 1E-3

          # LoRA and no LoRA should NOT be the same
          assert (sample - old_sample).abs().max() > 1E-4


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A     ,__A  :					Any						     =       self.prepare_init_args_and_inputs_for_common()

          __A  :					Union[str, Any]						     =       8

          torch.manual_seed(0		)
          __A  :					Any						     =       self.model_class(**lowerCamelCase		)
          model.to(lowerCamelCase		)

          with torch.no_grad():
               __A  :					Optional[int]						     =       model(**lowerCamelCase		).sample

          __A  :					str						     =       create_lora_layers(lowerCamelCase		)
          model.set_attn_processor(lowerCamelCase		)

          with torch.no_grad():
               __A  :					int						     =       model(**lowerCamelCase ,    cross_attention_kwargs={"scale": 0.5}		).sample

          with tempfile.TemporaryDirectory() as tmpdirname:
               model.save_attn_procs(lowerCamelCase ,    safe_serialization=lowerCamelCase		)
               self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase ,    "pytorch_lora_weights.safetensors"		)		)		)
               torch.manual_seed(0		)
               __A  :					Dict						     =       self.model_class(**lowerCamelCase		)
               new_model.to(lowerCamelCase		)
               new_model.load_attn_procs(lowerCamelCase		)

          with torch.no_grad():
               __A  :					Optional[Any]						     =       new_model(**lowerCamelCase ,    cross_attention_kwargs={"scale": 0.5}		).sample

          assert (sample - new_sample).abs().max() < 3E-3

          # LoRA and no LoRA should NOT be the same
          assert (sample - old_sample).abs().max() > 1E-4


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A     ,__A  :					Any						     =       self.prepare_init_args_and_inputs_for_common()

          __A  :					str						     =       8

          torch.manual_seed(0		)
          __A  :					int						     =       self.model_class(**lowerCamelCase		)
          model.to(lowerCamelCase		)

          __A  :					str						     =       create_lora_layers(lowerCamelCase ,    mock_weights=lowerCamelCase		)
          model.set_attn_processor(lowerCamelCase		)
          # Saving as torch, properly reloads with directly filename
          with tempfile.TemporaryDirectory() as tmpdirname:
               model.save_attn_procs(lowerCamelCase		)
               self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase ,    "pytorch_lora_weights.bin"		)		)		)
               torch.manual_seed(0		)
               __A  :					str						     =       self.model_class(**lowerCamelCase		)
               new_model.to(lowerCamelCase		)
               new_model.load_attn_procs(lowerCamelCase ,    weight_name="pytorch_lora_weights.bin"		)


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A     ,__A  :					Optional[int]						     =       self.prepare_init_args_and_inputs_for_common()

          __A  :					str						     =       8

          torch.manual_seed(0		)
          __A  :					Union[str, Any]						     =       self.model_class(**lowerCamelCase		)
          model.to(lowerCamelCase		)

          __A  :					Optional[Any]						     =       create_lora_layers(lowerCamelCase ,    mock_weights=lowerCamelCase		)
          model.set_attn_processor(lowerCamelCase		)
          # Saving as torch, properly reloads with directly filename
          with tempfile.TemporaryDirectory() as tmpdirname:
               model.save_attn_procs(lowerCamelCase		)
               self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase ,    "pytorch_lora_weights.bin"		)		)		)
               torch.manual_seed(0		)
               __A  :					List[str]						     =       self.model_class(**lowerCamelCase		)
               new_model.to(lowerCamelCase		)
               with self.assertRaises(lowerCamelCase		) as e:
                    new_model.load_attn_procs(lowerCamelCase ,    use_safetensors=lowerCamelCase		)
               self.assertIn("Error no file named pytorch_lora_weights.safetensors" ,    str(e.exception		)		)


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A     ,__A  :					Optional[int]						     =       self.prepare_init_args_and_inputs_for_common()

          __A  :					str						     =       8

          torch.manual_seed(0		)
          __A  :					Any						     =       self.model_class(**lowerCamelCase		)
          model.to(lowerCamelCase		)

          with torch.no_grad():
               __A  :					int						     =       model(**lowerCamelCase		).sample

          __A  :					Optional[int]						     =       create_lora_layers(lowerCamelCase		)
          model.set_attn_processor(lowerCamelCase		)

          with torch.no_grad():
               __A  :					Tuple						     =       model(**lowerCamelCase ,    cross_attention_kwargs={"scale": 0.0}		).sample

          model.set_attn_processor(AttnProcessor()		)

          with torch.no_grad():
               __A  :					Optional[Any]						     =       model(**lowerCamelCase		).sample

          assert (sample - new_sample).abs().max() < 1E-4
          assert (sample - old_sample).abs().max() < 3E-3


     @unittest.skipIf(
         torch_device != "cuda" or not is_xformers_available() ,    reason="XFormers attention is only available with CUDA and `xformers` installed" ,    )
     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A     ,__A  :					str						     =       self.prepare_init_args_and_inputs_for_common()

          __A  :					List[Any]						     =       4

          torch.manual_seed(0		)
          __A  :					Optional[int]						     =       self.model_class(**lowerCamelCase		)
          model.to(lowerCamelCase		)
          __A  :					List[str]						     =       create_lora_layers(lowerCamelCase		)
          model.set_attn_processor(lowerCamelCase		)

          # default
          with torch.no_grad():
               __A  :					List[Any]						     =       model(**lowerCamelCase		).sample

               model.enable_xformers_memory_efficient_attention()
               __A  :					Tuple						     =       model(**lowerCamelCase		).sample

               model.disable_xformers_memory_efficient_attention()
               __A  :					Optional[Any]						     =       model(**lowerCamelCase		).sample

          assert (sample - on_sample).abs().max() < 1E-4
          assert (sample - off_sample).abs().max() < 1E-4


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A     ,__A  :					List[str]						     =       self.prepare_init_args_and_inputs_for_common()
          __A  :					List[Any]						     =       32

          __A  :					List[Any]						     =       self.model_class(**lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          with torch.no_grad():
               __A  :					Optional[Any]						     =       model(**lowerCamelCase		)[0]

          model.enable_forward_chunking()
          with torch.no_grad():
               __A  :					Optional[int]						     =       model(**lowerCamelCase		)[0]

          self.assertEqual(output.shape ,    output_a.shape ,    "Shape doesn't match"		)
          assert np.abs(output.cpu() - output_a.cpu()		).max() < 1E-2


# (todo: sayakpaul) implement SLOW tests.





'''simple docstring'''


from sklearn.metrics import accuracy_score

import datasets


_UpperCamelCase          =     """
Accuracy is the proportion of correct predictions among the total number of cases processed. It can be computed with:
Accuracy = (TP + TN) / (TP + TN + FP + FN)
 Where:
TP: True positive
TN: True negative
FP: False positive
FN: False negative
"""


_UpperCamelCase          =     """
Args:
    predictions (`list` of `int`): Predicted labels.
    references (`list` of `int`): Ground truth labels.
    normalize (`boolean`): If set to False, returns the number of correctly classified samples. Otherwise, returns the fraction of correctly classified samples. Defaults to True.
    sample_weight (`list` of `float`): Sample weights Defaults to None.

Returns:
    accuracy (`float` or `int`): Accuracy score. Minimum possible value is 0. Maximum possible value is 1.0, or the number of examples input, if `normalize` is set to `True`.. A higher score means higher accuracy.

Examples:

    Example 1-A simple example
        >>> accuracy_metric = datasets.load_metric(\"accuracy\")
        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0])
        >>> print(results)
        {'accuracy': 0.5}

    Example 2-The same as Example 1, except with `normalize` set to `False`.
        >>> accuracy_metric = datasets.load_metric(\"accuracy\")
        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], normalize=False)
        >>> print(results)
        {'accuracy': 3.0}

    Example 3-The same as Example 1, except with `sample_weight` set.
        >>> accuracy_metric = datasets.load_metric(\"accuracy\")
        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], sample_weight=[0.5, 2, 0.7, 0.5, 9, 0.4])
        >>> print(results)
        {'accuracy': 0.8778625954198473}
"""


_UpperCamelCase          =     """
@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        __magic_name__  (					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.Sequence(datasets.Value("int32"		)		),
                      "references": datasets.Sequence(datasets.Value("int32"		)		),
                  }
                  if self.config_name == "multilabel"
                  else {
                      "predictions": datasets.Value("int32"		),
                      "references": datasets.Value("int32"		),
                  }		) ,    reference_urls=["https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html"] ,    )


     def lowerCAmelCase__     (      self ,    lowerCamelCase ,    lowerCamelCase ,    lowerCamelCase=True ,    lowerCamelCase=None		):


          '''simple docstring'''





          return {
              "accuracy": float(
                  accuracy_score(lowerCamelCase ,    lowerCamelCase ,    normalize=lowerCamelCase ,    sample_weight=lowerCamelCase		)		)
          }

