




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







def 				lowerCAmelCase_	(     snake_case_,snake_case_=1,snake_case_=256     ):
      return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3     )     ) + multiple_of - 1) // multiple_of)







def 				lowerCAmelCase_	(     snake_case_     ):
      with open(snake_case_,"""r"""     ) as f:
            return json.load(snake_case_     )







def 				lowerCAmelCase_	(     snake_case_,snake_case_     ):
      with open(snake_case_,"""w"""     ) as f:
            json.dump(snake_case_,snake_case_     )







def 				lowerCAmelCase_	(     snake_case_,snake_case_,snake_case_,snake_case_=True     ):
      os.makedirs(snake_case_,exist_ok=snake_case_     )
      _A							:     Tuple			=						os.path.join(snake_case_,"""tmp"""     )
      os.makedirs(snake_case_,exist_ok=snake_case_     )

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

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

      # permute for sliced rotary
      def permute(snake_case_,snake_case_=n_heads,snake_case_=dim,snake_case_=dim     ):
            return w.view(snake_case_,dima // n_heads // 2,2,snake_case_     ).transpose(1,2     ).reshape(snake_case_,snake_case_     )

      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							:     str			=						torch.load(os.path.join(snake_case_,"""consolidated.00.pth"""     ),map_location="""cpu"""     )
      else:
            # Sharded
            _A							:     int			=						[
                torch.load(os.path.join(snake_case_,f'''consolidated.{i:02d}.pth'''     ),map_location="""cpu"""     )
                for i in range(snake_case_     )
            ]
      _A							:     Optional[int]			=						0
      _A							:     Optional[Any]			=						{"""weight_map""": {}}
      for layer_i in range(snake_case_     ):
            _A							:     int			=						f'''pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin'''
            if model_size == "7B":
                  # Unsharded
                  _A							:     Union[str, Any]			=						{
                      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							:     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(),
                  }
                  _A							:     Union[str, Any]			=						permute(
                      torch.cat(
                          [
                              loaded[i][f'''layers.{layer_i}.attention.wq.weight'''].view(snake_case_,snake_case_,snake_case_     )
                              for i in range(snake_case_     )
                          ],dim=0,).reshape(snake_case_,snake_case_     )     )
                  _A							:     Optional[Any]			=						permute(
                      torch.cat(
                          [
                              loaded[i][f'''layers.{layer_i}.attention.wk.weight'''].view(
                                  snake_case_,snake_case_,snake_case_     )
                              for i in range(snake_case_     )
                          ],dim=0,).reshape(snake_case_,snake_case_     ),snake_case_,snake_case_,snake_case_,)
                  _A							:     Union[str, Any]			=						torch.cat(
                      [
                          loaded[i][f'''layers.{layer_i}.attention.wv.weight'''].view(
                              snake_case_,snake_case_,snake_case_     )
                          for i in range(snake_case_     )
                      ],dim=0,).reshape(snake_case_,snake_case_     )

                  _A							:     str			=						torch.cat(
                      [loaded[i][f'''layers.{layer_i}.attention.wo.weight'''] for i in range(snake_case_     )],dim=1     )
                  _A							:     Tuple			=						torch.cat(
                      [loaded[i][f'''layers.{layer_i}.feed_forward.w1.weight'''] for i in range(snake_case_     )],dim=0     )
                  _A							:     Dict			=						torch.cat(
                      [loaded[i][f'''layers.{layer_i}.feed_forward.w2.weight'''] for i in range(snake_case_     )],dim=1     )
                  _A							:     Any			=						torch.cat(
                      [loaded[i][f'''layers.{layer_i}.feed_forward.w3.weight'''] for i in range(snake_case_     )],dim=0     )

            _A							:     Any			=						inv_freq
            for k, v in state_dict.items():
                  _A							:     Dict			=						filename
                  param_count += v.numel()
            torch.save(snake_case_,os.path.join(snake_case_,snake_case_     )     )

      _A							:     Optional[Any]			=						f'''pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin'''
      if model_size == "7B":
            # Unsharded
            _A							:     Optional[Any]			=						{
                """model.embed_tokens.weight""": loaded["""tok_embeddings.weight"""],
                """model.norm.weight""": loaded["""norm.weight"""],
                """lm_head.weight""": loaded["""output.weight"""],
            }
      else:
            _A							:     Optional[int]			=						{
                """model.norm.weight""": loaded[0]["""norm.weight"""],
                """model.embed_tokens.weight""": torch.cat(
                    [loaded[i]["""tok_embeddings.weight"""] for i in range(snake_case_     )],dim=1     ),
                """lm_head.weight""": torch.cat([loaded[i]["""output.weight"""] for i in range(snake_case_     )],dim=0     ),
            }

      for k, v in state_dict.items():
            _A							:     List[str]			=						filename
            param_count += v.numel()
      torch.save(snake_case_,os.path.join(snake_case_,snake_case_     )     )

      # Write configs
      _A							:     Tuple			=						{"""total_size""": param_count * 2}
      write_json(snake_case_,os.path.join(snake_case_,"""pytorch_model.bin.index.json"""     )     )
      _A							:     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							:     str			=						LlamaConfig(
          hidden_size=snake_case_,intermediate_size=compute_intermediate_size(snake_case_,snake_case_,snake_case_     ),num_attention_heads=params["""n_heads"""],num_hidden_layers=params["""n_layers"""],rms_norm_eps=params["""norm_eps"""],num_key_value_heads=snake_case_,)
      config.save_pretrained(snake_case_     )

      # 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							:     Optional[Any]			=						LlamaForCausalLM.from_pretrained(snake_case_,torch_dtype=torch.floataa,low_cpu_mem_usage=snake_case_     )
      # Avoid saving this as part of the config.
      del model.config._name_or_path

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







def 				lowerCAmelCase_	(     snake_case_,snake_case_     ):
      # Initialize the tokenizer based on the `spm` model
      _A							:     Union[str, Any]			=						LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
      print(f'''Saving a {tokenizer_class.__name__} to {tokenizer_path}.'''     )
      _A							:     List[Any]			=						tokenizer_class(snake_case_     )
      tokenizer.save_pretrained(snake_case_     )







def 				lowerCAmelCase_	(     ):
      _A							:     Dict			=						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=snake_case_,help="""Whether or not to save using `safetensors`."""     )
      _A							:     Union[str, 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							:     int			=						os.path.join(args.input_dir,"""tokenizer.model"""     )
      write_tokenizer(args.output_dir,snake_case_     )


if __name__ == "__main__":
  main()







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

import numpy as np
import PIL
import torch
from transformers import CLIPImageProcessor, CLIPVisionModel

from ...models import PriorTransformer
from ...pipelines import DiffusionPipeline
from ...schedulers import HeunDiscreteScheduler
from ...utils import (
    BaseOutput,
    is_accelerate_available,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from .renderer import ShapERenderer


_snake_case										=       logging.get_logger(__name__)  # pylint: disable=invalid-name

_snake_case										=       "\n    Examples:\n        ```py\n        >>> from PIL import Image\n        >>> import torch\n        >>> from diffusers import DiffusionPipeline\n        >>> from diffusers.utils import export_to_gif, load_image\n\n        >>> device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n        >>> repo = \"openai/shap-e-img2img\"\n        >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16)\n        >>> pipe = pipe.to(device)\n\n        >>> guidance_scale = 3.0\n        >>> image_url = \"https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png\"\n        >>> image = load_image(image_url).convert(\"RGB\")\n\n        >>> images = pipe(\n        ...     image,\n        ...     guidance_scale=guidance_scale,\n        ...     num_inference_steps=64,\n        ...     frame_size=256,\n        ... ).images\n\n        >>> gif_path = export_to_gif(images[0], \"corgi_3d.gif\")\n        ```\n"







@dataclass
class 						lowercase							(   UpperCamelCase__		):
     _a							 =						42







class 						lowercase							(   UpperCamelCase__		):

     def __init__(  self		,     _a		,     _a		,     _a		,     _a		,     _a		,     )						->							List[Any]:
           super().__init__()

           self.register_modules(
               prior=_a		,     image_encoder=_a		,     image_processor=_a		,     scheduler=_a		,     renderer=_a		,     )

     def 					a__	(  self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a				)						->							str:
           if latents is None:
                 _A							:     str			=						randn_tensor(_a		,     generator=_a		,     device=_a		,     dtype=_a				)
           else:
                 if latents.shape != shape:
                       raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {shape}'''				)
                 _A							:     Union[str, Any]			=						latents.to(_a				)

           _A							:     int			=						latents * scheduler.init_noise_sigma
           return latents

     def 					a__	(  self		,     _a=0				)						->							Optional[Any]:
           if is_accelerate_available():
                 from accelerate import cpu_offload
           else:
                 raise ImportError("""Please install accelerate via `pip install accelerate`"""				)

           _A							:     str			=						torch.device(F'''cuda:{gpu_id}'''				)

           _A							:     Any			=						[self.image_encoder, self.prior]
           for cpu_offloaded_model in models:
                 if cpu_offloaded_model is not None:
                       cpu_offload(_a		,     _a				)

     @property
     def 					a__	(  self				)						->							List[Any]:
           if self.device != torch.device("""meta"""				) or not hasattr(self.image_encoder		,     """_hf_hook"""				):
                 return self.device
           for module in self.image_encoder.modules():
                 if (
                     hasattr(_a		,     """_hf_hook"""				)
                     and hasattr(module._hf_hook		,     """execution_device"""				)
                     and module._hf_hook.execution_device is not None
                 ):
                       return torch.device(module._hf_hook.execution_device				)
           return self.device

     def 					a__	(  self		,     _a		,     _a		,     _a		,     _a		,     )						->							Tuple:
           if isinstance(_a		,     _a				) and isinstance(image[0]		,     torch.Tensor				):
                 _A							:     int			=						torch.cat(_a		,     axis=0				) if image[0].ndim == 4 else torch.stack(_a		,     axis=0				)

           if not isinstance(_a		,     torch.Tensor				):
                 _A							:     Dict			=						self.image_processor(_a		,     return_tensors="""pt"""				).pixel_values[0].unsqueeze(0				)

           _A							:     int			=						image.to(dtype=self.image_encoder.dtype		,     device=_a				)

           _A							:     List[Any]			=						self.image_encoder(_a				)["""last_hidden_state"""]
           _A							:     List[Any]			=						image_embeds[:, 1:, :].contiguous()  # batch_size, dim, 256

           _A							:     Dict			=						image_embeds.repeat_interleave(_a		,     dim=0				)

           if do_classifier_free_guidance:
                 _A							:     str			=						torch.zeros_like(_a				)

                 # For classifier free guidance, we need to do two forward passes.
                 # Here we concatenate the unconditional and text embeddings into a single batch
                 # to avoid doing two forward passes
                 _A							:     List[str]			=						torch.cat([negative_image_embeds, image_embeds]				)

           return image_embeds



     @torch.no_grad()
     @replace_example_docstring(_a				)
     def __call__(  self		,     _a		,     _a = 1		,     _a = 25		,     _a = None		,     _a = None		,     _a = 4.0		,     _a = 64		,     _a = "pil"		,     _a = True		,     )						->							Union[str, Any]:

           if isinstance(_a		,     PIL.Image.Image				):
                 _A							:     List[Any]			=						1
           elif isinstance(_a		,     torch.Tensor				):
                 _A							:     Any			=						image.shape[0]
           elif isinstance(_a		,     _a				) and isinstance(image[0]		,     (torch.Tensor, PIL.Image.Image)				):
                 _A							:     Union[str, Any]			=						len(_a				)
           else:
                 raise ValueError(
                     F'''`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(_a				)}'''				)

           _A							:     Optional[int]			=						self._execution_device

           _A							:     Tuple			=						batch_size * num_images_per_prompt

           _A							:     List[Any]			=						guidance_scale > 1.0
           _A							:     Optional[Any]			=						self._encode_image(_a		,     _a		,     _a		,     _a				)

           # prior

           self.scheduler.set_timesteps(_a		,     device=_a				)
           _A							:     Optional[int]			=						self.scheduler.timesteps

           _A							:     List[str]			=						self.prior.config.num_embeddings
           _A							:     int			=						self.prior.config.embedding_dim

           _A							:     Optional[Any]			=						self.prepare_latents(
               (batch_size, num_embeddings * embedding_dim)		,     image_embeds.dtype		,     _a		,     _a		,     _a		,     self.scheduler		,     )

           # YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim
           _A							:     List[Any]			=						latents.reshape(latents.shape[0]		,     _a		,     _a				)

           for i, t in enumerate(self.progress_bar(_a				)				):
                 # expand the latents if we are doing classifier free guidance
                 _A							:     List[str]			=						torch.cat([latents] * 2				) if do_classifier_free_guidance else latents
                 _A							:     int			=						self.scheduler.scale_model_input(_a		,     _a				)

                 _A							:     Tuple			=						self.prior(
                     _a		,     timestep=_a		,     proj_embedding=_a		,     ).predicted_image_embedding

                 # remove the variance
                 _A			,   _A							:     Optional[Any]			=						noise_pred.split(
                     scaled_model_input.shape[2]		,     dim=2				)  # batch_size, num_embeddings, embedding_dim

                 if do_classifier_free_guidance is not None:
                       _A			,   _A							:     Dict			=						noise_pred.chunk(2				)
                       _A							:     Tuple			=						noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond)

                 _A							:     int			=						self.scheduler.step(
                     _a		,     timestep=_a		,     sample=_a		,     ).prev_sample

           if output_type == "latent":
                 return ShapEPipelineOutput(images=_a				)

           _A							:     List[str]			=						[]
           for i, latent in enumerate(_a				):
                 print()
                 _A							:     List[str]			=						self.renderer.decode(
                     latent[None, :]		,     _a		,     size=_a		,     ray_batch_size=4096		,     n_coarse_samples=64		,     n_fine_samples=128		,     )

                 images.append(_a				)

           _A							:     List[Any]			=						torch.stack(_a				)

           if output_type not in ["np", "pil"]:
                 raise ValueError(F'''Only the output types `pil` and `np` are supported not output_type={output_type}'''				)

           _A							:     List[str]			=						images.cpu().numpy()

           if output_type == "pil":
                 _A							:     List[Any]			=						[self.numpy_to_pil(_a				) for image in images]

           # Offload last model to CPU
           if hasattr(self		,     """final_offload_hook"""				) and self.final_offload_hook is not None:
                 self.final_offload_hook.offload()

           if not return_dict:
                 return (images,)

           return ShapEPipelineOutput(images=_a				)

