
"""simple docstring"""







import argparse
import json
import os

import torch
from transformers.file_utils import has_file

from diffusers import UNetaDConditionModel, UNetaDModel


_SCREAMING_SNAKE_CASE	       =      False
_SCREAMING_SNAKE_CASE	       =      True
_SCREAMING_SNAKE_CASE	       =      False


if __name__ == "__main__":
						_SCREAMING_SNAKE_CASE	       =      argparse.ArgumentParser()

						parser.add_argument(
						    """--repo_path""",
						    default=None,
						    type=str,
						    required=True,
						    help="""The config json file corresponding to the architecture.""",
						)

						parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""")

						_SCREAMING_SNAKE_CASE	       =      parser.parse_args()

						_SCREAMING_SNAKE_CASE	       =      {
						    "image_size": "sample_size",
						    "num_res_blocks": "layers_per_block",
						    "block_channels": "block_out_channels",
						    "down_blocks": "down_block_types",
						    "up_blocks": "up_block_types",
						    "downscale_freq_shift": "freq_shift",
						    "resnet_num_groups": "norm_num_groups",
						    "resnet_act_fn": "act_fn",
						    "resnet_eps": "norm_eps",
						    "num_head_channels": "attention_head_dim",
						}

						_SCREAMING_SNAKE_CASE	       =      {
						    "time_steps": "time_proj",
						    "mid": "mid_block",
						    "downsample_blocks": "down_blocks",
						    "upsample_blocks": "up_blocks",
						}

						_SCREAMING_SNAKE_CASE	       =      "" if has_file(args.repo_path, """config.json""") else "unet"

						with open(os.path.join(args.repo_path, subfolder, """config.json"""), """r""", encoding="""utf-8""") as reader:
												_SCREAMING_SNAKE_CASE	       =      reader.read()
												_SCREAMING_SNAKE_CASE	       =      json.loads(text)

						if do_only_config:
												for key in config_parameters_to_change.keys():
																		config.pop(key, None)

						if has_file(args.repo_path, """config.json"""):
												_SCREAMING_SNAKE_CASE	       =      UNetaDModel(**config)
						else:
												_SCREAMING_SNAKE_CASE	       =      UNetaDConditionModel if "ldm-text2im-large-256" in args.repo_path else UNetaDModel
												_SCREAMING_SNAKE_CASE	       =      class_name(**config)

						if do_only_config:
												model.save_config(os.path.join(args.repo_path, subfolder))

						_SCREAMING_SNAKE_CASE	       =      dict(model.config)

						if do_only_renaming:
												for key, value in config_parameters_to_change.items():
																		if key in config:
																								_SCREAMING_SNAKE_CASE	       =      config[key]
																								del config[key]

												_SCREAMING_SNAKE_CASE	       =      [k.replace("""UNetRes""", """""") for k in config["down_block_types"]]
												_SCREAMING_SNAKE_CASE	       =      [k.replace("""UNetRes""", """""") for k in config["up_block_types"]]

						if do_only_weights:
												_SCREAMING_SNAKE_CASE	       =      torch.load(os.path.join(args.repo_path, subfolder, """diffusion_pytorch_model.bin"""))

												_SCREAMING_SNAKE_CASE	       =      {}
												for param_key, param_value in state_dict.items():
																		if param_key.endswith(""".op.bias""") or param_key.endswith(""".op.weight"""):
																								continue
																		_SCREAMING_SNAKE_CASE	       =      False
																		for key, new_key in key_parameters_to_change.items():
																								if not has_changed and param_key.split(""".""")[0] == key:
																														_SCREAMING_SNAKE_CASE	       =      param_value
																														_SCREAMING_SNAKE_CASE	       =      True
																		if not has_changed:
																								_SCREAMING_SNAKE_CASE	       =      param_value

												model.load_state_dict(new_state_dict)
												model.save_pretrained(os.path.join(args.repo_path, subfolder))


"""simple docstring"""







from collections import UserDict
from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
		from PIL import Image

		from ..image_utils import load_image

if is_torch_available():
		from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING

if is_tf_available():
		from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
		from ..tf_utils import stable_softmax

_SCREAMING_SNAKE_CASE	       =      logging.get_logger(__name__)







@add_end_docstrings(lowercase__   )
class 							__magic_name__     (		lowercase__   ):





					def __init__(				self   :							Tuple							,						**snake_case_   :							str    ):
												super().__init__(**snake_case_    )

												requires_backends(self							,						"vision"    )
												self.check_model_type(
												    TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
												    if self.framework == "tf"
												    else MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING    )





					def __call__(				self   :							Optional[Any]							,						snake_case_   :							Union[str, List[str], "Image", List["Image"]]							,						**snake_case_   :							Optional[int]    ):
												return super().__call__(snake_case_							,						**snake_case_    )





					def 							lowerCAmelCase      (				self   :							Tuple							,						**snake_case_   :							Any    ):
												__snake_case     			=       {}
												if "candidate_labels" in kwargs:
																			__snake_case     			=       kwargs["candidate_labels"]
												if "hypothesis_template" in kwargs:
																			__snake_case     			=       kwargs["hypothesis_template"]

												return preprocess_params, {}, {}





					def 							lowerCAmelCase      (				self   :							int							,						snake_case_   :							List[str]							,						snake_case_   :							List[str]=None							,						snake_case_   :							int="This is a photo of {}."    ):
												__snake_case     			=       load_image(snake_case_    )
												__snake_case     			=       self.image_processor(images=[image]							,						return_tensors=self.framework    )
												__snake_case     			=       candidate_labels
												__snake_case     			=       [hypothesis_template.format(snake_case_    ) for x in candidate_labels]
												__snake_case     			=       self.tokenizer(snake_case_							,						return_tensors=self.framework							,						padding=snake_case_    )
												__snake_case     			=       [text_inputs]
												return inputs





					def 							lowerCAmelCase      (				self   :							Any							,						snake_case_   :							Dict    ):
												__snake_case     			=       model_inputs.pop("candidate_labels"    )
												__snake_case     			=       model_inputs.pop("text_inputs"    )
												if isinstance(text_inputs[0]							,						snake_case_    ):
																			__snake_case     			=       text_inputs[0]
												else:
																			# Batching case.
																			__snake_case     			=       text_inputs[0][0]

												__snake_case     			=       self.model(**snake_case_							,						**snake_case_    )

												__snake_case     			=       {
												    "candidate_labels": candidate_labels,
												    "logits": outputs.logits_per_image,
												}
												return model_outputs





					def 							lowerCAmelCase      (				self   :							Optional[int]							,						snake_case_   :							Any    ):
												__snake_case     			=       model_outputs.pop("candidate_labels"    )
												__snake_case     			=       model_outputs["logits"][0]
												if self.framework == "pt":
																			__snake_case     			=       logits.softmax(dim=-1    ).squeeze(-1    )
																			__snake_case     			=       probs.tolist()
																			if not isinstance(snake_case_							,						snake_case_    ):
																										__snake_case     			=       [scores]
												elif self.framework == "tf":
																			__snake_case     			=       stable_softmax(snake_case_							,						axis=-1    )
																			__snake_case     			=       probs.numpy().tolist()
												else:
																			raise ValueError(F'''Unsupported framework: {self.framework}'''    )

												__snake_case     			=       [
												    {"score": score, "label": candidate_label}
												    for score, candidate_label in sorted(zip(snake_case_							,						snake_case_    )							,						key=lambda snake_case_    : -x[0]    )
												]
												return result
