



"""simple docstring"""

import argparse

import torch

from diffusers.pipelines.stable_diffusion.convert_from_ckpt import download_from_original_stable_diffusion_ckpt


if __name__ == "__main__":
     lowercase__    :  List[str]							    =	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.''',
     )
     lowercase__    :  Optional[int]							    =	parser.parse_args()

     lowercase__    :  Dict							    =	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)









'''simple docstring'''







import argparse
import gc
import json
import os
import shutil
import warnings

import torch

from transformers import LlamaConfig, LlamaForCausalLM, LlamaTokenizer


try:
   from transformers import LlamaTokenizerFast
except ImportError as e:
   warnings.warn(e)
   warnings.warn(
       '''The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion'''
   )
   A__:    Dict					    =       None
A__:    Tuple					    =       {
    '''7B''': 1_1008,
    '''13B''': 1_3824,
    '''30B''': 1_7920,
    '''65B''': 2_2016,
    '''70B''': 2_8672,
}
A__:    Any					    =       {
    '''7B''': 1,
    '''7Bf''': 1,
    '''13B''': 2,
    '''13Bf''': 2,
    '''30B''': 4,
    '''65B''': 8,
    '''70B''': 8,
    '''70Bf''': 8,
}


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	Optional[int]    ,_UpperCAmelCase	:	Optional[int]=1    ,_UpperCAmelCase	:	List[str]=256  )  ->			Dict:
       return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3  )  ) + multiple_of - 1) // multiple_of)


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	List[Any]  )  ->			List[str]:
       with open(_UpperCAmelCase    ,"""r"""  ) as f:
              return json.load(_UpperCAmelCase  )


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	str    ,_UpperCAmelCase	:	Optional[Any]  )  ->			Tuple:
       with open(_UpperCAmelCase    ,"""w"""  ) as f:
              json.dump(_UpperCAmelCase    ,_UpperCAmelCase  )


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	str    ,_UpperCAmelCase	:	Optional[Any]    ,_UpperCAmelCase	:	int    ,_UpperCAmelCase	:	List[Any]=True  )  ->			Union[str, Any]:
       os.makedirs(_UpperCAmelCase    ,exist_ok=_UpperCAmelCase  )
       _a    : Union[str, Any]     					=os.path.join(_UpperCAmelCase    ,"""tmp"""  )
       os.makedirs(_UpperCAmelCase    ,exist_ok=_UpperCAmelCase  )

       _a    : int     					=read_json(os.path.join(_UpperCAmelCase    ,"""params.json"""  )  )
       _a    : int     					=NUM_SHARDS[model_size]
       _a    : Dict     					=params["""n_layers"""]
       _a    : Union[str, Any]     					=params["""n_heads"""]
       _a    : List[str]     					=n_heads // num_shards
       _a    : int     					=params["""dim"""]
       _a    : Union[str, Any]     					=dim // n_heads
       _a    : int     					=1_0_0_0_0.0
       _a    : str     					=1.0 / (base ** (torch.arange(0    ,_UpperCAmelCase    ,2  ).float() / dims_per_head))

       if "n_kv_heads" in params:
              _a    : str     					=params["""n_kv_heads"""]  # for GQA / MQA
              _a    : Optional[Any]     					=n_heads_per_shard // num_key_value_heads
              _a    : Optional[int]     					=dim // num_key_value_heads
       else:  # compatibility with other checkpoints
              _a    : str     					=n_heads
              _a    : Any     					=n_heads_per_shard
              _a    : str     					=dim

       # permute for sliced rotary
       def permute(_UpperCAmelCase	:	Tuple    ,_UpperCAmelCase	:	Optional[int]=n_heads    ,_UpperCAmelCase	:	Optional[int]=dim    ,_UpperCAmelCase	:	List[str]=dim  ):
              return w.view(_UpperCAmelCase    ,dima // n_heads // 2    ,2    ,_UpperCAmelCase  ).transpose(1    ,2  ).reshape(_UpperCAmelCase    ,_UpperCAmelCase  )

       print(F"Fetching all parameters from the checkpoint at {input_base_path}."  )
       # Load weights
       if model_size == "7B":
              # Not sharded
              # (The sharded implementation would also work, but this is simpler.)
              _a    : Any     					=torch.load(os.path.join(_UpperCAmelCase    ,"""consolidated.00.pth"""  )    ,map_location="""cpu"""  )
       else:
              # Sharded
              _a    : List[Any]     					=[
                  torch.load(os.path.join(_UpperCAmelCase    ,F"consolidated.{i:02d}.pth"  )    ,map_location="""cpu"""  )
                  for i in range(_UpperCAmelCase  )
              ]
       _a    : Any     					=0
       _a    : Optional[int]     					={"""weight_map""": {}}
       for layer_i in range(_UpperCAmelCase  ):
              _a    : List[str]     					=F"pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin"
              if model_size == "7B":
                     # Unsharded
                     _a    : List[str]     					={
                         F"model.layers.{layer_i}.self_attn.q_proj.weight": permute(
                             loaded[F"layers.{layer_i}.attention.wq.weight"]  ),
                         F"model.layers.{layer_i}.self_attn.k_proj.weight": permute(
                             loaded[F"layers.{layer_i}.attention.wk.weight"]  ),
                         F"model.layers.{layer_i}.self_attn.v_proj.weight": loaded[F"layers.{layer_i}.attention.wv.weight"],
                         F"model.layers.{layer_i}.self_attn.o_proj.weight": loaded[F"layers.{layer_i}.attention.wo.weight"],
                         F"model.layers.{layer_i}.mlp.gate_proj.weight": loaded[F"layers.{layer_i}.feed_forward.w1.weight"],
                         F"model.layers.{layer_i}.mlp.down_proj.weight": loaded[F"layers.{layer_i}.feed_forward.w2.weight"],
                         F"model.layers.{layer_i}.mlp.up_proj.weight": loaded[F"layers.{layer_i}.feed_forward.w3.weight"],
                         F"model.layers.{layer_i}.input_layernorm.weight": loaded[F"layers.{layer_i}.attention_norm.weight"],
                         F"model.layers.{layer_i}.post_attention_layernorm.weight": loaded[F"layers.{layer_i}.ffn_norm.weight"],
                     }
              else:
                     # Sharded
                     # Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share
                     # the same storage object, saving attention_norm and ffn_norm will save other weights too, which is
                     # redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned.

                     _a    : Tuple     					={
                         F"model.layers.{layer_i}.input_layernorm.weight": loaded[0][
                             F"layers.{layer_i}.attention_norm.weight"
                         ].clone(),
                         F"model.layers.{layer_i}.post_attention_layernorm.weight": loaded[0][
                             F"layers.{layer_i}.ffn_norm.weight"
                         ].clone(),
                     }
                     _a    : str     					=permute(
                         torch.cat(
                             [
                                 loaded[i][F"layers.{layer_i}.attention.wq.weight"].view(_UpperCAmelCase    ,_UpperCAmelCase    ,_UpperCAmelCase  )
                                 for i in range(_UpperCAmelCase  )
                             ]    ,dim=0    ,).reshape(_UpperCAmelCase    ,_UpperCAmelCase  )  )
                     _a    : Tuple     					=permute(
                         torch.cat(
                             [
                                 loaded[i][F"layers.{layer_i}.attention.wk.weight"].view(
                                     _UpperCAmelCase    ,_UpperCAmelCase    ,_UpperCAmelCase  )
                                 for i in range(_UpperCAmelCase  )
                             ]    ,dim=0    ,).reshape(_UpperCAmelCase    ,_UpperCAmelCase  )    ,_UpperCAmelCase    ,_UpperCAmelCase    ,_UpperCAmelCase    ,)
                     _a    : Any     					=torch.cat(
                         [
                             loaded[i][F"layers.{layer_i}.attention.wv.weight"].view(
                                 _UpperCAmelCase    ,_UpperCAmelCase    ,_UpperCAmelCase  )
                             for i in range(_UpperCAmelCase  )
                         ]    ,dim=0    ,).reshape(_UpperCAmelCase    ,_UpperCAmelCase  )

                     _a    : List[str]     					=torch.cat(
                         [loaded[i][F"layers.{layer_i}.attention.wo.weight"] for i in range(_UpperCAmelCase  )]    ,dim=1  )
                     _a    : Union[str, Any]     					=torch.cat(
                         [loaded[i][F"layers.{layer_i}.feed_forward.w1.weight"] for i in range(_UpperCAmelCase  )]    ,dim=0  )
                     _a    : Tuple     					=torch.cat(
                         [loaded[i][F"layers.{layer_i}.feed_forward.w2.weight"] for i in range(_UpperCAmelCase  )]    ,dim=1  )
                     _a    : Union[str, Any]     					=torch.cat(
                         [loaded[i][F"layers.{layer_i}.feed_forward.w3.weight"] for i in range(_UpperCAmelCase  )]    ,dim=0  )

              _a    : str     					=inv_freq
              for k, v in state_dict.items():
                     _a    : Any     					=filename
                     param_count += v.numel()
              torch.save(_UpperCAmelCase    ,os.path.join(_UpperCAmelCase    ,_UpperCAmelCase  )  )

       _a    : Union[str, Any]     					=F"pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin"
       if model_size == "7B":
              # Unsharded
              _a    : List[str]     					={
                  """model.embed_tokens.weight""": loaded["""tok_embeddings.weight"""],
                  """model.norm.weight""": loaded["""norm.weight"""],
                  """lm_head.weight""": loaded["""output.weight"""],
              }
       else:
              _a    : int     					={
                  """model.norm.weight""": loaded[0]["""norm.weight"""],
                  """model.embed_tokens.weight""": torch.cat(
                      [loaded[i]["""tok_embeddings.weight"""] for i in range(_UpperCAmelCase  )]    ,dim=1  ),
                  """lm_head.weight""": torch.cat([loaded[i]["""output.weight"""] for i in range(_UpperCAmelCase  )]    ,dim=0  ),
              }

       for k, v in state_dict.items():
              _a    : Dict     					=filename
              param_count += v.numel()
       torch.save(_UpperCAmelCase    ,os.path.join(_UpperCAmelCase    ,_UpperCAmelCase  )  )

       # Write configs
       _a    : Tuple     					={"""total_size""": param_count * 2}
       write_json(_UpperCAmelCase    ,os.path.join(_UpperCAmelCase    ,"""pytorch_model.bin.index.json"""  )  )
       _a    : Optional[Any]     					=params["""ffn_dim_multiplier"""] if """ffn_dim_multiplier""" in params else 1
       _a    : int     					=params["""multiple_of"""] if """multiple_of""" in params else 256
       _a    : List[Any]     					=LlamaConfig(
           hidden_size=_UpperCAmelCase    ,intermediate_size=compute_intermediate_size(_UpperCAmelCase    ,_UpperCAmelCase    ,_UpperCAmelCase  )    ,num_attention_heads=params["""n_heads"""]    ,num_hidden_layers=params["""n_layers"""]    ,rms_norm_eps=params["""norm_eps"""]    ,num_key_value_heads=_UpperCAmelCase    ,)
       config.save_pretrained(_UpperCAmelCase  )

       # Make space so we can load the model properly now.
       del state_dict
       del loaded
       gc.collect()

       print("""Loading the checkpoint in a Llama model."""  )
       _a    : Any     					=LlamaForCausalLM.from_pretrained(_UpperCAmelCase    ,torch_dtype=torch.floataa    ,low_cpu_mem_usage=_UpperCAmelCase  )
       # Avoid saving this as part of the config.
       del model.config._name_or_path

       print("""Saving in the Transformers format."""  )
       model.save_pretrained(_UpperCAmelCase    ,safe_serialization=_UpperCAmelCase  )
       shutil.rmtree(_UpperCAmelCase  )


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	int    ,_UpperCAmelCase	:	int  )  ->			Optional[Any]:
       # Initialize the tokenizer based on the `spm` model
       _a    : List[str]     					=LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
       print(F"Saving a {tokenizer_class.__name__} to {tokenizer_path}."  )
       _a    : List[Any]     					=tokenizer_class(_UpperCAmelCase  )
       tokenizer.save_pretrained(_UpperCAmelCase  )


def 	SCREAMING_SNAKE_CASE_					(  )  ->			Union[str, Any]:
       _a    : List[str]     					=argparse.ArgumentParser()
       parser.add_argument(
           """--input_dir"""    ,help="""Location of LLaMA weights, which contains tokenizer.model and model folders"""    ,)
       parser.add_argument(
           """--model_size"""    ,choices=["""7B""", """7Bf""", """13B""", """13Bf""", """30B""", """65B""", """70B""", """70Bf""", """tokenizer_only"""]    ,)
       parser.add_argument(
           """--output_dir"""    ,help="""Location to write HF model and tokenizer"""    ,)
       parser.add_argument("""--safe_serialization"""    ,type=_UpperCAmelCase    ,help="""Whether or not to save using `safetensors`."""  )
       _a    : Optional[Any]     					=parser.parse_args()
       if args.model_size != "tokenizer_only":
              write_model(
                  model_path=args.output_dir    ,input_base_path=os.path.join(args.input_dir    ,args.model_size  )    ,model_size=args.model_size    ,safe_serialization=args.safe_serialization    ,)
       _a    : List[Any]     					=os.path.join(args.input_dir    ,"""tokenizer.model"""  )
       write_tokenizer(args.output_dir    ,_UpperCAmelCase  )


if __name__ == "__main__":
   main()


