



"""simple docstring"""





from collections import defaultdict
class 				lowercase__       :







       '''simple docstring'''


       def __init__(							self      :  Optional[Any]		,    _UpperCAmelCase      :  Union[str, Any]		,    _UpperCAmelCase      :  str   )			->						List[str]:


             '''simple docstring'''




             UpperCAmelCase_      			=							total  # total no of tasks (N)

             # DP table will have a dimension of (2^M)*N
             # initially all values are set to -1
             UpperCAmelCase_      			=							[
                 [-1 for i in range(total + 1   )] for j in range(2 ** len(SCREAMING_SNAKE_CASE_   )   )
             ]

             UpperCAmelCase_      			=							defaultdict(SCREAMING_SNAKE_CASE_   )  # stores the list of persons for each task

             # final_mask is used to check if all persons are included by setting all bits
             # to 1
             UpperCAmelCase_      			=							(1 << len(SCREAMING_SNAKE_CASE_   )) - 1



       def 					lowercase__    (							self      :  Any		,    _UpperCAmelCase      :  Union[str, Any]		,    _UpperCAmelCase      :  str   )			->						Union[str, Any]:


             '''simple docstring'''




             if mask == self.final_mask:
                   return 1

             # if not everyone gets the task and no more tasks are available, return 0
             if task_no > self.total_tasks:
                   return 0

             # if case already considered
             if self.dp[mask][task_no] != -1:
                   return self.dp[mask][task_no]

             # Number of ways when we don't this task in the arrangement
             UpperCAmelCase_      			=							self.count_ways_until(SCREAMING_SNAKE_CASE_		,    task_no + 1   )

             # now assign the tasks one by one to all possible persons and recursively
             # assign for the remaining tasks.
             if task_no in self.task:
                   for p in self.task[task_no]:
                         # if p is already given a task
                         if mask & (1 << p):
                               continue

                         # assign this task to p and change the mask value. And recursively
                         # assign tasks with the new mask value.
                         total_ways_util += self.count_ways_until(mask | (1 << p)		,    task_no + 1   )

        # save the value.
             UpperCAmelCase_      			=							total_ways_util

             return self.dp[mask][task_no]







       def 					lowercase__    (							self      :  str		,    _UpperCAmelCase      :  Optional[int]   )			->						str:


             '''simple docstring'''




             for i in range(len(SCREAMING_SNAKE_CASE_   )   ):
                   for j in task_performed[i]:
                         self.task[j].append(SCREAMING_SNAKE_CASE_   )

        # call the function to fill the DP table, final answer is stored in dp[0][1]
             return self.count_ways_until(0		,    1   )


if __name__ == "__main__":
  lowerCamelCase       	=						5  # total no of tasks (the value of N)

  # the list of tasks that can be done by M persons.
  lowerCamelCase       	=						[[1, 3, 4], [1, 2, 5], [3, 4]]
  print(
      AssignmentUsingBitmask(task_performed, total_tasks).count_no_of_ways(
          task_performed
      )
  )









"""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        a__     (				lowerCAmelCase__     ,      lowerCAmelCase__				):
      UpperCAmelCase_      			=							checkpoint

      UpperCAmelCase_      			=							{}

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

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

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

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

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

      for i in range(lowerCAmelCase__				):
            UpperCAmelCase_      			=							[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:
                  UpperCAmelCase_      			=							vae_state_dict.pop(
                      f"""encoder.down.{i}.downsample.conv.weight"""				)
                  UpperCAmelCase_      			=							vae_state_dict.pop(
                      f"""encoder.down.{i}.downsample.conv.bias"""				)

            UpperCAmelCase_      			=							renew_vae_resnet_paths(lowerCAmelCase__				)
            UpperCAmelCase_      			=							{"old": f"""down.{i}.block""", "new": f"""down_blocks.{i}.resnets"""}
            assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)

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

            UpperCAmelCase_      			=							renew_vae_resnet_paths(lowerCAmelCase__				)
            UpperCAmelCase_      			=							{"old": f"""mid.block_{i}""", "new": f"""mid_block.resnets.{i - 1}"""}
            assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)

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

      for i in range(lowerCAmelCase__				):
            UpperCAmelCase_      			=							num_up_blocks - 1 - i
            UpperCAmelCase_      			=							[
                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:
                  UpperCAmelCase_      			=							vae_state_dict[
                      f"""decoder.up.{block_id}.upsample.conv.weight"""
                  ]
                  UpperCAmelCase_      			=							vae_state_dict[
                      f"""decoder.up.{block_id}.upsample.conv.bias"""
                  ]

            UpperCAmelCase_      			=							renew_vae_resnet_paths(lowerCAmelCase__				)
            UpperCAmelCase_      			=							{"old": f"""up.{block_id}.block""", "new": f"""up_blocks.{i}.resnets"""}
            assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)

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

            UpperCAmelCase_      			=							renew_vae_resnet_paths(lowerCAmelCase__				)
            UpperCAmelCase_      			=							{"old": f"""mid.block_{i}""", "new": f"""mid_block.resnets.{i - 1}"""}
            assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)

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

      UpperCAmelCase_      			=							OmegaConf.load(lowerCAmelCase__				)
      UpperCAmelCase_      			=							512
      UpperCAmelCase_      			=							"cuda" if torch.cuda.is_available() else "cpu"
      if checkpoint_path.endswith("safetensors"				):
            from safetensors import safe_open

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

      # Convert the VAE model.
      UpperCAmelCase_      			=							create_vae_diffusers_config(lowerCAmelCase__     ,      image_size=lowerCAmelCase__				)
      UpperCAmelCase_      			=							custom_convert_ldm_vae_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__				)

      UpperCAmelCase_      			=							AutoencoderKL(**lowerCAmelCase__				)
      vae.load_state_dict(lowerCAmelCase__				)
      vae.save_pretrained(lowerCAmelCase__				)


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)




