


'''simple docstring'''

from sklearn.metrics import mean_squared_error

import datasets


lowerCamelCase				:  Optional[int]    		=      '\\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n'

lowerCamelCase				:  int    		=      '\\nMean Squared Error(MSE) is the average of the square of difference between the predicted\nand actual values.\n'


lowerCamelCase				:  Union[str, Any]    		=      '\nArgs:\n    predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Estimated target values.\n    references: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Ground truth (correct) target values.\n    sample_weight: array-like of shape (n_samples,), default=None\n        Sample weights.\n    multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"\n        Defines aggregating of multiple output values. Array-like value defines weights used to average errors.\n\n        "raw_values" : Returns a full set of errors in case of multioutput input.\n\n        "uniform_average" : Errors of all outputs are averaged with uniform weight.\n\n    squared : bool, default=True\n        If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.\n\nReturns:\n    mse : mean squared error.\nExamples:\n\n    >>> mse_metric = datasets.load_metric("mse")\n    >>> predictions = [2.5, 0.0, 2, 8]\n    >>> references = [3, -0.5, 2, 7]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mse\': 0.375}\n    >>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)\n    >>> print(rmse_result)\n    {\'mse\': 0.6123724356957945}\n\n    If you\'re using multi-dimensional lists, then set the config as follows :\n\n    >>> mse_metric = datasets.load_metric("mse", "multilist")\n    >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]\n    >>> references = [[0, 2], [-1, 2], [8, -5]]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mse\': 0.7083333333333334}\n    >>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')\n    >>> print(results) # doctest: +NORMALIZE_WHITESPACE\n    {\'mse\': array([0.41666667, 1. ])}\n'
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION    ,	_KWARGS_DESCRIPTION	)
class     __lowerCAmelCase		(datasets.Metric	):





      '''simple docstring'''






      def  UpperCamelCase__						(self       :       Optional[Any]					):

             '''simple docstring'''







             return datasets.MetricInfo(
                 description=_DESCRIPTION  ,		citation=_CITATION  ,		inputs_description=_KWARGS_DESCRIPTION  ,		features=datasets.Features(self._get_feature_types()					)  ,		reference_urls=[
                     '''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html'''
                 ]  ,		)



      def  UpperCamelCase__						(self       :       str					):

             '''simple docstring'''







             if self.config_name == "multilist":
                    return {
                        "predictions": datasets.Sequence(datasets.Value('''float'''					)					),
                        "references": datasets.Sequence(datasets.Value('''float'''					)					),
                    }
             else:
                    return {
                        "predictions": datasets.Value('''float'''					),
                        "references": datasets.Value('''float'''					),
                    }






      def  UpperCamelCase__						(self       :       Optional[int]  ,		UpperCamelCase       :       str  ,		UpperCamelCase       :       Dict  ,		UpperCamelCase       :       Tuple=None  ,		UpperCamelCase       :       Optional[int]="uniform_average"  ,		UpperCamelCase       :       str=True					):

             '''simple docstring'''







             lowercase__      =					mean_squared_error(
                 UpperCamelCase  ,		UpperCamelCase  ,		sample_weight=UpperCamelCase  ,		multioutput=UpperCamelCase  ,		squared=UpperCamelCase					)

             return {"mse": mse}








'''simple docstring'''

import argparse

import torch

from diffusers.pipelines.stable_diffusion.convert_from_ckpt import download_from_original_stable_diffusion_ckpt


if __name__ == "__main__":
 lowerCamelCase				:  int    		=      argparse.ArgumentParser()

 parser.add_argument(
     '--checkpoint_path', default=None, type=str, required=True, help='Path to the checkpoint to convert.'
 )
 # !wget https://raw.githubusercontent.com/CompVis/stable-diffusion/main/configs/stable-diffusion/v1-inference.yaml
 parser.add_argument(
     '--original_config_file',
     default=None,
     type=str,
     help='The YAML config file corresponding to the original architecture.',
 )
 parser.add_argument(
     '--num_in_channels',
     default=None,
     type=int,
     help='The number of input channels. If `None` number of input channels will be automatically inferred.',
 )
 parser.add_argument(
     '--scheduler_type',
     default='pndm',
     type=str,
     help='Type of scheduler to use. Should be one of [\'pndm\', \'lms\', \'ddim\', \'euler\', \'euler-ancestral\', \'dpm\']',
 )
 parser.add_argument(
     '--pipeline_type',
     default=None,
     type=str,
     help=(
         'The pipeline type. One of \'FrozenOpenCLIPEmbedder\', \'FrozenCLIPEmbedder\', \'PaintByExample\''
         '. If `None` pipeline will be automatically inferred.'
     ),
 )
 parser.add_argument(
     '--image_size',
     default=None,
     type=int,
     help=(
         'The image size that the model was trained on. Use 512 for Stable Diffusion v1.X and Stable Siffusion v2'
         ' Base. Use 768 for Stable Diffusion v2.'
     ),
 )
 parser.add_argument(
     '--prediction_type',
     default=None,
     type=str,
     help=(
         'The prediction type that the model was trained on. Use \'epsilon\' for Stable Diffusion v1.X and Stable'
         ' Diffusion v2 Base. Use \'v_prediction\' for Stable Diffusion v2.'
     ),
 )
 parser.add_argument(
     '--extract_ema',
     action='store_true',
     help=(
         'Only relevant for checkpoints that have both EMA and non-EMA weights. Whether to extract the EMA weights'
         ' or not. Defaults to `False`. Add `--extract_ema` to extract the EMA weights. EMA weights usually yield'
         ' higher quality images for inference. Non-EMA weights are usually better to continue fine-tuning.'
     ),
 )
 parser.add_argument(
     '--upcast_attention',
     action='store_true',
     help=(
         'Whether the attention computation should always be upcasted. This is necessary when running stable'
         ' diffusion 2.1.'
     ),
 )
 parser.add_argument(
     '--from_safetensors',
     action='store_true',
     help='If `--checkpoint_path` is in `safetensors` format, load checkpoint with safetensors instead of PyTorch.',
 )
 parser.add_argument(
     '--to_safetensors',
     action='store_true',
     help='Whether to store pipeline in safetensors format or not.',
 )
 parser.add_argument('--dump_path', default=None, type=str, required=True, help='Path to the output model.')
 parser.add_argument('--device', type=str, help='Device to use (e.g. cpu, cuda:0, cuda:1, etc.)')
 parser.add_argument(
     '--stable_unclip',
     type=str,
     default=None,
     required=False,
     help='Set if this is a stable unCLIP model. One of \'txt2img\' or \'img2img\'.',
 )
 parser.add_argument(
     '--stable_unclip_prior',
     type=str,
     default=None,
     required=False,
     help='Set if this is a stable unCLIP txt2img model. Selects which prior to use. If `--stable_unclip` is set to `txt2img`, the karlo prior (https://huggingface.co/kakaobrain/karlo-v1-alpha/tree/main/prior) is selected by default.',
 )
 parser.add_argument(
     '--clip_stats_path',
     type=str,
     help='Path to the clip stats file. Only required if the stable unclip model\'s config specifies `model.params.noise_aug_config.params.clip_stats_path`.',
     required=False,
 )
 parser.add_argument(
     '--controlnet', action='store_true', default=None, help='Set flag if this is a controlnet checkpoint.'
 )
 parser.add_argument('--half', action='store_true', help='Save weights in half precision.')
 parser.add_argument(
     '--vae_path',
     type=str,
     default=None,
     required=False,
     help='Set to a path, hub id to an already converted vae to not convert it again.',
 )
 lowerCamelCase				:  str    		=      parser.parse_args()

 lowerCamelCase				:  Tuple    		=      download_from_original_stable_diffusion_ckpt(
     checkpoint_path=args.checkpoint_path,
     original_config_file=args.original_config_file,
     image_size=args.image_size,
     prediction_type=args.prediction_type,
     model_type=args.pipeline_type,
     extract_ema=args.extract_ema,
     scheduler_type=args.scheduler_type,
     num_in_channels=args.num_in_channels,
     upcast_attention=args.upcast_attention,
     from_safetensors=args.from_safetensors,
     device=args.device,
     stable_unclip=args.stable_unclip,
     stable_unclip_prior=args.stable_unclip_prior,
     clip_stats_path=args.clip_stats_path,
     controlnet=args.controlnet,
     vae_path=args.vae_path,
 )

 if args.half:
  pipe.to(torch_dtype=torch.floataa)

 if args.controlnet:
  # only save the controlnet model
  pipe.controlnet.save_pretrained(args.dump_path, safe_serialization=args.to_safetensors)
 else:
  pipe.save_pretrained(args.dump_path, safe_serialization=args.to_safetensors)




