


import argparse

import torch

from diffusers.pipelines.stable_diffusion.convert_from_ckpt import download_from_original_stable_diffusion_ckpt


if __name__ == "__main__":
		snake_case__			 =						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.''',
		)
		snake_case__			 =						parser.parse_args()

		snake_case__			 =						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)






import datasets

from .evaluate import evaluate


snake_case__			 =						'''\
@inproceedings{Rajpurkar2016SQuAD10,
  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},
  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},
  booktitle={EMNLP},
  year={2016}
}
'''

snake_case__			 =						'''
This metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).

Stanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by
crowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,
from the corresponding reading passage, or the question might be unanswerable.
'''

snake_case__			 =						'''
Computes SQuAD scores (F1 and EM).
Args:
    predictions: List of question-answers dictionaries with the following key-values:
        - \'id\': id of the question-answer pair as given in the references (see below)
        - \'prediction_text\': the text of the answer
    references: List of question-answers dictionaries with the following key-values:
        - \'id\': id of the question-answer pair (see above),
        - \'answers\': a Dict in the SQuAD dataset format
            {
                \'text\': list of possible texts for the answer, as a list of strings
                \'answer_start\': list of start positions for the answer, as a list of ints
            }
            Note that answer_start values are not taken into account to compute the metric.
Returns:
    \'exact_match\': Exact match (the normalized answer exactly match the gold answer)
    \'f1\': The F-score of predicted tokens versus the gold answer
Examples:

    >>> predictions = [{\'prediction_text\': \'1976\', \'id\': \'56e10a3be3433e1400422b22\'}]
    >>> references = [{\'answers\': {\'answer_start\': [97], \'text\': [\'1976\']}, \'id\': \'56e10a3be3433e1400422b22\'}]
    >>> squad_metric = datasets.load_metric("squad")
    >>> results = squad_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'exact_match\': 100.0, \'f1\': 100.0}
'''


@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION			,_KWARGS_DESCRIPTION)
class 					lowerCAmelCase_ (       datasets.Metric):




						def  _snake_case					(	self						:   List[str]						)      ->Union[str, Any]:






									"""simple docstring"""






									return datasets.MetricInfo(
									    description=_DESCRIPTION   ,     citation=_CITATION   ,     inputs_description=_KWARGS_DESCRIPTION   ,     features=datasets.Features(
									        {
									            "predictions": {"id": datasets.Value("string"						), "prediction_text": datasets.Value("string"						)},
									            "references": {
									                "id": datasets.Value("string"						),
									                "answers": datasets.features.Sequence(
									                    {
									                        "text": datasets.Value("string"						),
									                        "answer_start": datasets.Value("int32"						),
									                    }						),
									            },
									        }						)   ,     codebase_urls=["https://rajpurkar.github.io/SQuAD-explorer/"]   ,     reference_urls=["https://rajpurkar.github.io/SQuAD-explorer/"]   ,     )






						def  _snake_case					(	self						:   Dict   ,     __A						:   List[Any]   ,     __A						:   Optional[int]						)      ->str:






									"""simple docstring"""






									a__ :Optional[int]						  =    {prediction["id"]: prediction["prediction_text"] for prediction in predictions}
									a__ :Optional[Any]						  =    [
									    {
									        "paragraphs": [
									            {
									                "qas": [
									                    {
									                        "answers": [{"text": answer_text} for answer_text in ref["answers"]["text"]],
									                        "id": ref["id"],
									                    }
									                    for ref in references
									                ]
									            }
									        ]
									    }
									]
									a__ :Union[str, Any]						  =    evaluate(dataset=__A   ,     predictions=__A						)
									return score


