

'''simple docstring'''







import argparse
import io

import requests
import torch
from omegaconf import OmegaConf

from diffusers import AutoencoderKL
from diffusers.pipelines.stable_diffusion.convert_from_ckpt import (
    assign_to_checkpoint,
    conv_attn_to_linear,
    create_vae_diffusers_config,
    renew_vae_attention_paths,
    renew_vae_resnet_paths,
)
def  UpperCAmelCase__      ( UpperCAmelCase__,    UpperCAmelCase__			)     ->     str:
       A_		   = checkpoint

       A_		   = {}

       A_		   = vae_state_dict["""encoder.conv_in.weight"""]
       A_		   = vae_state_dict["""encoder.conv_in.bias"""]
       A_		   = vae_state_dict["""encoder.conv_out.weight"""]
       A_		   = vae_state_dict["""encoder.conv_out.bias"""]
       A_		   = vae_state_dict["""encoder.norm_out.weight"""]
       A_		   = vae_state_dict["""encoder.norm_out.bias"""]

       A_		   = vae_state_dict["""decoder.conv_in.weight"""]
       A_		   = vae_state_dict["""decoder.conv_in.bias"""]
       A_		   = vae_state_dict["""decoder.conv_out.weight"""]
       A_		   = vae_state_dict["""decoder.conv_out.bias"""]
       A_		   = vae_state_dict["""decoder.norm_out.weight"""]
       A_		   = vae_state_dict["""decoder.norm_out.bias"""]

       A_		   = vae_state_dict["""quant_conv.weight"""]
       A_		   = vae_state_dict["""quant_conv.bias"""]
       A_		   = vae_state_dict["""post_quant_conv.weight"""]
       A_		   = vae_state_dict["""post_quant_conv.bias"""]

       # Retrieves the keys for the encoder down blocks only
       A_		   = len({""".""".join(layer.split("""."""			)[:3]			) for layer in vae_state_dict if """encoder.down""" in layer}			)
       A_		   = {
           layer_id: [key for key in vae_state_dict if F'''down.{layer_id}''' in key] for layer_id in range(UpperCAmelCase__			)
       }

       # Retrieves the keys for the decoder up blocks only
       A_		   = len({""".""".join(layer.split("""."""			)[:3]			) for layer in vae_state_dict if """decoder.up""" in layer}			)
       A_		   = {
           layer_id: [key for key in vae_state_dict if F'''up.{layer_id}''' in key] for layer_id in range(UpperCAmelCase__			)
       }

       for i in range(UpperCAmelCase__			):
              A_		   = [key for key in down_blocks[i] if F'''down.{i}''' in key and F'''down.{i}.downsample''' not in key]

              if F'''encoder.down.{i}.downsample.conv.weight''' in vae_state_dict:
                     A_		   = vae_state_dict.pop(
                         F'''encoder.down.{i}.downsample.conv.weight'''			)
                     A_		   = vae_state_dict.pop(
                         F'''encoder.down.{i}.downsample.conv.bias'''			)

              A_		   = renew_vae_resnet_paths(UpperCAmelCase__			)
              A_		   = {"""old""": F'''down.{i}.block''', """new""": F'''down_blocks.{i}.resnets'''}
              assign_to_checkpoint(UpperCAmelCase__,    UpperCAmelCase__,    UpperCAmelCase__,    additional_replacements=[meta_path],    config=UpperCAmelCase__			)

       A_		   = [key for key in vae_state_dict if """encoder.mid.block""" in key]
       A_		   = 2
       for i in range(1,    num_mid_res_blocks + 1			):
              A_		   = [key for key in mid_resnets if F'''encoder.mid.block_{i}''' in key]

              A_		   = renew_vae_resnet_paths(UpperCAmelCase__			)
              A_		   = {"""old""": F'''mid.block_{i}''', """new""": F'''mid_block.resnets.{i - 1}'''}
              assign_to_checkpoint(UpperCAmelCase__,    UpperCAmelCase__,    UpperCAmelCase__,    additional_replacements=[meta_path],    config=UpperCAmelCase__			)

       A_		   = [key for key in vae_state_dict if """encoder.mid.attn""" in key]
       A_		   = renew_vae_attention_paths(UpperCAmelCase__			)
       A_		   = {"""old""": """mid.attn_1""", """new""": """mid_block.attentions.0"""}
       assign_to_checkpoint(UpperCAmelCase__,    UpperCAmelCase__,    UpperCAmelCase__,    additional_replacements=[meta_path],    config=UpperCAmelCase__			)
       conv_attn_to_linear(UpperCAmelCase__			)

       for i in range(UpperCAmelCase__			):
              A_		   = num_up_blocks - 1 - i
              A_		   = [
                  key for key in up_blocks[block_id] if F'''up.{block_id}''' in key and F'''up.{block_id}.upsample''' not in key
              ]

              if F'''decoder.up.{block_id}.upsample.conv.weight''' in vae_state_dict:
                     A_		   = vae_state_dict[
                         F'''decoder.up.{block_id}.upsample.conv.weight'''
                     ]
                     A_		   = vae_state_dict[
                         F'''decoder.up.{block_id}.upsample.conv.bias'''
                     ]

              A_		   = renew_vae_resnet_paths(UpperCAmelCase__			)
              A_		   = {"""old""": F'''up.{block_id}.block''', """new""": F'''up_blocks.{i}.resnets'''}
              assign_to_checkpoint(UpperCAmelCase__,    UpperCAmelCase__,    UpperCAmelCase__,    additional_replacements=[meta_path],    config=UpperCAmelCase__			)

       A_		   = [key for key in vae_state_dict if """decoder.mid.block""" in key]
       A_		   = 2
       for i in range(1,    num_mid_res_blocks + 1			):
              A_		   = [key for key in mid_resnets if F'''decoder.mid.block_{i}''' in key]

              A_		   = renew_vae_resnet_paths(UpperCAmelCase__			)
              A_		   = {"""old""": F'''mid.block_{i}''', """new""": F'''mid_block.resnets.{i - 1}'''}
              assign_to_checkpoint(UpperCAmelCase__,    UpperCAmelCase__,    UpperCAmelCase__,    additional_replacements=[meta_path],    config=UpperCAmelCase__			)

       A_		   = [key for key in vae_state_dict if """decoder.mid.attn""" in key]
       A_		   = renew_vae_attention_paths(UpperCAmelCase__			)
       A_		   = {"""old""": """mid.attn_1""", """new""": """mid_block.attentions.0"""}
       assign_to_checkpoint(UpperCAmelCase__,    UpperCAmelCase__,    UpperCAmelCase__,    additional_replacements=[meta_path],    config=UpperCAmelCase__			)
       conv_attn_to_linear(UpperCAmelCase__			)
       return new_checkpoint
def  UpperCAmelCase__      ( UpperCAmelCase__,    UpperCAmelCase__,    )     ->     Optional[int]:
       # Only support V1
       A_		   = requests.get(
           """ https://raw.githubusercontent.com/CompVis/stable-diffusion/main/configs/stable-diffusion/v1-inference.yaml"""			)
       A_		   = io.BytesIO(r.content			)

       A_		   = OmegaConf.load(UpperCAmelCase__			)
       A_		   = 5_12
       A_		   = """cuda""" if torch.cuda.is_available() else """cpu"""
       if checkpoint_path.endswith("""safetensors"""			):
              from safetensors import safe_open

              A_		   = {}
              with safe_open(UpperCAmelCase__,    framework="""pt""",    device="""cpu"""			) as f:
                     for key in f.keys():
                            A_		   = f.get_tensor(UpperCAmelCase__			)
       else:
              A_		   = torch.load(UpperCAmelCase__,    map_location=UpperCAmelCase__			)["""state_dict"""]

       # Convert the VAE model.
       A_		   = create_vae_diffusers_config(UpperCAmelCase__,    image_size=UpperCAmelCase__			)
       A_		   = custom_convert_ldm_vae_checkpoint(UpperCAmelCase__,    UpperCAmelCase__			)

       A_		   = AutoencoderKL(**UpperCAmelCase__			)
       vae.load_state_dict(UpperCAmelCase__			)
       vae.save_pretrained(UpperCAmelCase__			)


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

      parser.add_argument('''--vae_pt_path''', default=None, type=str, required=True, help='''Path to the VAE.pt to convert.''')
      parser.add_argument('''--dump_path''', default=None, type=str, required=True, help='''Path to the VAE.pt to convert.''')

      __lowerCamelCase						    =      parser.parse_args()

      vae_pt_to_vae_diffuser(args.vae_pt_path, args.dump_path)



'''simple docstring'''







def  UpperCAmelCase__      ( UpperCAmelCase__ = 1_00			)     ->     int:
       A_		   = n * (n + 1) * (2 * n + 1) / 6
       A_		   = (n * (n + 1) / 2) ** 2
       return int(square_of_sum - sum_of_squares			)


if __name__ == "__main__":
      print(f"""{solution() = }""")
