






'''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'
 )
 UpperCamelCase__			=      None
UpperCamelCase__			=      {
    '7B': 11008,
    '13B': 13824,
    '30B': 17920,
    '65B': 22016,
    '70B': 28672,
}
UpperCamelCase__			=      {
    '7B': 1,
    '7Bf': 1,
    '13B': 2,
    '13Bf': 2,
    '30B': 4,
    '65B': 8,
    '70B': 8,
    '70Bf': 8,
}




def 		__SCREAMING_SNAKE_CASE       (	_UpperCamelCase    ,		_UpperCamelCase=1    ,		_UpperCamelCase=256				):


   """simple docstring"""




   return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3				)				) + multiple_of - 1) // multiple_of)




def 		__SCREAMING_SNAKE_CASE       (	_UpperCamelCase				):


   """simple docstring"""




   with open(_UpperCamelCase    ,		"r"				) as f:
      return json.load(_UpperCamelCase				)




def 		__SCREAMING_SNAKE_CASE       (	_UpperCamelCase    ,		_UpperCamelCase				):


   """simple docstring"""




   with open(_UpperCamelCase    ,		"w"				) as f:
      json.dump(_UpperCamelCase    ,		_UpperCamelCase				)




def 		__SCREAMING_SNAKE_CASE       (	_UpperCamelCase    ,		_UpperCamelCase    ,		_UpperCamelCase    ,		_UpperCamelCase=True				):


   """simple docstring"""




   os.makedirs(_UpperCamelCase    ,		exist_ok=_UpperCamelCase				)
   lowercase_						:     str							     =  os.path.join(_UpperCamelCase    ,		"tmp"				)
   os.makedirs(_UpperCamelCase    ,		exist_ok=_UpperCamelCase				)

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

   if "n_kv_heads" in params:
      lowercase_						:     Tuple							     =  params["n_kv_heads"]  # for GQA / MQA
      lowercase_						:     str							     =  n_heads_per_shard // num_key_value_heads
      lowercase_						:     int							     =  dim // num_key_value_heads
   else:  # compatibility with other checkpoints
      lowercase_						:     Optional[int]							     =  n_heads
      lowercase_						:     List[Any]							     =  n_heads_per_shard
      lowercase_						:     List[Any]							     =  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.)
      lowercase_						:     Optional[Any]							     =  torch.load(os.path.join(_UpperCamelCase    ,		"consolidated.00.pth"				)    ,		map_location="cpu"				)
   else:
      # Sharded
      lowercase_						:     Any							     =  [
          torch.load(os.path.join(_UpperCamelCase    ,		F"""consolidated.{i:02d}.pth"""				)    ,		map_location="cpu"				)
          for i in range(_UpperCamelCase				)
      ]
   lowercase_						:     Any							     =  0
   lowercase_						:     Tuple							     =  {"weight_map": {}}
   for layer_i in range(_UpperCamelCase				):
      lowercase_						:     List[Any]							     =  F"""pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin"""
      if model_size == "7B":
         # Unsharded
         lowercase_						:     Optional[int]							     =  {
             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.

         lowercase_						:     Optional[Any]							     =  {
             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(),
         }
         lowercase_						:     Dict							     =  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				)				)
         lowercase_						:     int							     =  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    ,		)
         lowercase_						:     List[str]							     =  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				)

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

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

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

   # Write configs
   lowercase_						:     Dict							     =  {"total_size": param_count * 2}
   write_json(_UpperCamelCase    ,		os.path.join(_UpperCamelCase    ,		"pytorch_model.bin.index.json"				)				)
   lowercase_						:     Optional[Any]							     =  params["ffn_dim_multiplier"] if "ffn_dim_multiplier" in params else 1
   lowercase_						:     List[Any]							     =  params["multiple_of"] if "multiple_of" in params else 256
   lowercase_						:     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."				)
   lowercase_						:     int							     =  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    ,		_UpperCamelCase				):


   """simple docstring"""




   lowercase_						:     Optional[Any]							     =  LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
   print(F"""Saving a {tokenizer_class.__name__} to {tokenizer_path}."""				)
   lowercase_						:     Any							     =  tokenizer_class(_UpperCamelCase				)
   tokenizer.save_pretrained(_UpperCamelCase				)




def 		__SCREAMING_SNAKE_CASE       (	):


   """simple docstring"""




   lowercase_						:     Optional[Any]							     =  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`."				)
   lowercase_						:     str							     =  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    ,		)
   lowercase_						:     Tuple							     =  os.path.join(args.input_dir    ,		"tokenizer.model"				)
   write_tokenizer(args.output_dir    ,		_UpperCamelCase				)


if __name__ == "__main__":
 main()












'''simple docstring'''
import unittest

import numpy as np

from diffusers import OnnxStableDiffusionInpaintPipelineLegacy
from diffusers.utils.testing_utils import (
    is_onnx_available,
    load_image,
    load_numpy,
    nightly,
    require_onnxruntime,
    require_torch_gpu,
)


if is_onnx_available():
 import onnxruntime as ort


@nightly
@require_onnxruntime
@require_torch_gpu
class 							_UpperCAmelCase    (		unittest.TestCase      ):




    @property
    def 					lowerCAmelCase__					(      self	:							Union[str, Any]      ):






       '''simple docstring'''






       return (
           "CUDAExecutionProvider",
           {
               "gpu_mem_limit": "15000000000",  # 15GB
               "arena_extend_strategy": "kSameAsRequested",
           },
       )




    @property
    def 					lowerCAmelCase__					(      self	:							List[Any]      ):






       '''simple docstring'''






       lowercase_						:     Union[str, Any]							     =  ort.SessionOptions()
       lowercase_						:     Optional[int]							     =  False
       return options





    def 					lowerCAmelCase__					(      self	:							str      ):






       '''simple docstring'''






       lowercase_						:     List[Any]							     =  load_image(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
           "/in_paint/overture-creations-5sI6fQgYIuo.png"      )
       lowercase_						:     Tuple							     =  load_image(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
           "/in_paint/overture-creations-5sI6fQgYIuo_mask.png"      )
       lowercase_						:     List[str]							     =  load_numpy(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
           "/in_paint/red_cat_sitting_on_a_park_bench_onnx.npy"      )

       # using the PNDM scheduler by default
       lowercase_						:     List[Any]							     =  OnnxStableDiffusionInpaintPipelineLegacy.from_pretrained(
           "CompVis/stable-diffusion-v1-4"	,  revision="onnx"	,  safety_checker=a	,  feature_extractor=a	,  provider=self.gpu_provider	,  sess_options=self.gpu_options	,  )
       pipe.set_progress_bar_config(disable=a      )

       lowercase_						:     List[str]							     =  "A red cat sitting on a park bench"

       lowercase_						:     int							     =  np.random.RandomState(0      )
       lowercase_						:     int							     =  pipe(
           prompt=a	,  image=a	,  mask_image=a	,  strength=0.75	,  guidance_scale=7.5	,  num_inference_steps=1_5	,  generator=a	,  output_type="np"	,  )

       lowercase_						:     Tuple							     =  output.images[0]

       assert image.shape == (5_1_2, 5_1_2, 3)
       assert np.abs(expected_image - image      ).max() < 1e-2




