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   :     Union[str, Any]       =				None
A   :     List[Any]       =				{
    "7B": 1_10_08,
    "13B": 1_38_24,
    "30B": 1_79_20,
    "65B": 2_20_16,
    "70B": 2_86_72,
}
A   :     Optional[Any]       =				{
    "7B": 1,
    "7Bf": 1,
    "13B": 2,
    "13Bf": 2,
    "30B": 4,
    "65B": 8,
    "70B": 8,
    "70Bf": 8,
}


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase=1   ,					__UpperCamelCase=2_5_6 ):
      return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3 ) ) + multiple_of - 1) // multiple_of)


def    a__       (						__UpperCamelCase ):
      with open(__UpperCamelCase   ,					"r" ) as f:
            return json.load(__UpperCamelCase )


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase ):
      with open(__UpperCamelCase   ,					"w" ) as f:
            json.dump(__UpperCamelCase   ,					__UpperCamelCase )


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase=True ):
      os.makedirs(__UpperCamelCase   ,					exist_ok=__UpperCamelCase )
      SCREAMING_SNAKE_CASE_      =     os.path.join(__UpperCamelCase   ,					"tmp" )
      os.makedirs(__UpperCamelCase   ,					exist_ok=__UpperCamelCase )

      SCREAMING_SNAKE_CASE_      =     read_json(os.path.join(__UpperCamelCase   ,					"params.json" ) )
      SCREAMING_SNAKE_CASE_      =     NUM_SHARDS[model_size]
      SCREAMING_SNAKE_CASE_      =     params["n_layers"]
      SCREAMING_SNAKE_CASE_      =     params["n_heads"]
      SCREAMING_SNAKE_CASE_      =     n_heads // num_shards
      SCREAMING_SNAKE_CASE_      =     params["dim"]
      SCREAMING_SNAKE_CASE_      =     dim // n_heads
      SCREAMING_SNAKE_CASE_      =     10000.0
      SCREAMING_SNAKE_CASE_      =     1.0 / (base ** (torch.arange(0   ,					__UpperCamelCase   ,					2 ).float() / dims_per_head))

      if "n_kv_heads" in params:
            SCREAMING_SNAKE_CASE_      =     params["n_kv_heads"]  # for GQA / MQA
            SCREAMING_SNAKE_CASE_      =     n_heads_per_shard // num_key_value_heads
            SCREAMING_SNAKE_CASE_      =     dim // num_key_value_heads
      else:  # compatibility with other checkpoints
            SCREAMING_SNAKE_CASE_      =     n_heads
            SCREAMING_SNAKE_CASE_      =     n_heads_per_shard
            SCREAMING_SNAKE_CASE_      =     dim

      # permute for sliced rotary
      def permute(__UpperCamelCase   ,					__UpperCamelCase=n_heads   ,					__UpperCamelCase=dim   ,					__UpperCamelCase=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.)
            SCREAMING_SNAKE_CASE_      =     torch.load(os.path.join(__UpperCamelCase   ,					"consolidated.00.pth" )   ,					map_location="cpu" )
      else:
            # Sharded
            SCREAMING_SNAKE_CASE_      =     [
                torch.load(os.path.join(__UpperCamelCase   ,					F'''consolidated.{i:02d}.pth''' )   ,					map_location="cpu" )
                for i in range(__UpperCamelCase )
            ]
      SCREAMING_SNAKE_CASE_      =     0
      SCREAMING_SNAKE_CASE_      =     {"weight_map": {}}
      for layer_i in range(__UpperCamelCase ):
            SCREAMING_SNAKE_CASE_      =     F'''pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin'''
            if model_size == "7B":
                  # Unsharded
                  SCREAMING_SNAKE_CASE_      =     {
                      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.

                  SCREAMING_SNAKE_CASE_      =     {
                      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(),
                  }
                  SCREAMING_SNAKE_CASE_      =     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 ) )
                  SCREAMING_SNAKE_CASE_      =     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   ,					)
                  SCREAMING_SNAKE_CASE_      =     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 )

                  SCREAMING_SNAKE_CASE_      =     torch.cat(
                      [loaded[i][F'''layers.{layer_i}.attention.wo.weight'''] for i in range(__UpperCamelCase )]   ,					dim=1 )
                  SCREAMING_SNAKE_CASE_      =     torch.cat(
                      [loaded[i][F'''layers.{layer_i}.feed_forward.w1.weight'''] for i in range(__UpperCamelCase )]   ,					dim=0 )
                  SCREAMING_SNAKE_CASE_      =     torch.cat(
                      [loaded[i][F'''layers.{layer_i}.feed_forward.w2.weight'''] for i in range(__UpperCamelCase )]   ,					dim=1 )
                  SCREAMING_SNAKE_CASE_      =     torch.cat(
                      [loaded[i][F'''layers.{layer_i}.feed_forward.w3.weight'''] for i in range(__UpperCamelCase )]   ,					dim=0 )

            SCREAMING_SNAKE_CASE_      =     inv_freq
            for k, v in state_dict.items():
                  SCREAMING_SNAKE_CASE_      =     filename
                  param_count += v.numel()
            torch.save(__UpperCamelCase   ,					os.path.join(__UpperCamelCase   ,					__UpperCamelCase ) )

      SCREAMING_SNAKE_CASE_      =     F'''pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin'''
      if model_size == "7B":
            # Unsharded
            SCREAMING_SNAKE_CASE_      =     {
                "model.embed_tokens.weight": loaded["tok_embeddings.weight"],
                "model.norm.weight": loaded["norm.weight"],
                "lm_head.weight": loaded["output.weight"],
            }
      else:
            SCREAMING_SNAKE_CASE_      =     {
                "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():
            SCREAMING_SNAKE_CASE_      =     filename
            param_count += v.numel()
      torch.save(__UpperCamelCase   ,					os.path.join(__UpperCamelCase   ,					__UpperCamelCase ) )

      # Write configs
      SCREAMING_SNAKE_CASE_      =     {"total_size": param_count * 2}
      write_json(__UpperCamelCase   ,					os.path.join(__UpperCamelCase   ,					"pytorch_model.bin.index.json" ) )
      SCREAMING_SNAKE_CASE_      =     params["ffn_dim_multiplier"] if "ffn_dim_multiplier" in params else 1
      SCREAMING_SNAKE_CASE_      =     params["multiple_of"] if "multiple_of" in params else 2_5_6
      SCREAMING_SNAKE_CASE_      =     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." )
      SCREAMING_SNAKE_CASE_      =     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    a__       (						__UpperCamelCase   ,					__UpperCamelCase ):
      # Initialize the tokenizer based on the `spm` model
      SCREAMING_SNAKE_CASE_      =     LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
      print(F'''Saving a {tokenizer_class.__name__} to {tokenizer_path}.''' )
      SCREAMING_SNAKE_CASE_      =     tokenizer_class(__UpperCamelCase )
      tokenizer.save_pretrained(__UpperCamelCase )


def    a__       (						):
      SCREAMING_SNAKE_CASE_      =     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`." )
      SCREAMING_SNAKE_CASE_      =     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   ,					)
      SCREAMING_SNAKE_CASE_      =     os.path.join(args.input_dir   ,					"tokenizer.model" )
      write_tokenizer(args.output_dir   ,					__UpperCamelCase )


if __name__ == "__main__":
      main()



from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available


@dataclass
class      lowerCamelCase    (SCREAMING_SNAKE_CASE__    ):
  """simple docstring"""







  lowerCamelCase__   =  42
  lowerCamelCase__   =  42


if is_transformers_available() and is_torch_available():
      from .pipeline_semantic_stable_diffusion import SemanticStableDiffusionPipeline


