




'''simple docstring'''


import json
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
    import torch

    if is_vision_available():
        from transformers import OneFormerImageProcessor
        from transformers.models.oneformer.image_processing_oneformer import binary_mask_to_rle
        from transformers.models.oneformer.modeling_oneformer import OneFormerForUniversalSegmentationOutput

if is_vision_available():
    from PIL import Image
def 	snake_case_					(UpperCamelCase :						Union[str, Any]				,		UpperCamelCase :						Any="shi-labs/oneformer_demo"   ):





       '''simple docstring'''


       with open(hf_hub_download(lowerCamelCase_				,		lowerCamelCase_				,		repo_type='''dataset'''   )				,		'''r'''   ) as f:
              _a			  =       json.load(lowerCamelCase_   )
       _a			  =       {}
       _a			  =       []
       _a			  =       []
       for key, info in class_info.items():
              _a			  =       info["""name"""]
              class_names.append(info['''name''']   )
              if info["isthing"]:
                     thing_ids.append(int(lowerCamelCase_   )   )
       _a			  =       thing_ids
       _a			  =       class_names
       return metadata

class     A					(	unittest.TestCase					):







       def __init__(						self :						Dict							,    lowerCAmelCase_ :						Union[str, Any]							,    lowerCAmelCase_ :						List[Any]=7							,    lowerCAmelCase_ :						Dict=3							,    lowerCAmelCase_ :						str=30							,    lowerCAmelCase_ :						List[str]=4_00							,    lowerCAmelCase_ :						int=None							,    lowerCAmelCase_ :						int=True							,    lowerCAmelCase_ :						Dict=True							,    lowerCAmelCase_ :						Dict=[0.5, 0.5, 0.5]							,    lowerCAmelCase_ :						Any=[0.5, 0.5, 0.5]							,    lowerCAmelCase_ :						str=10							,    lowerCAmelCase_ :						Any=False							,    lowerCAmelCase_ :						Union[str, Any]=2_55							,    lowerCAmelCase_ :						Optional[Any]="shi-labs/oneformer_demo"							,    lowerCAmelCase_ :						Tuple="ade20k_panoptic.json"							,    lowerCAmelCase_ :						int=10							,    )    ->							Tuple:


              """simple docstring"""


              _a			  =       parent
              _a			  =       batch_size
              _a			  =       num_channels
              _a			  =       min_resolution
              _a			  =       max_resolution
              _a			  =       do_resize
              _a			  =       {"""shortest_edge""": 32, """longest_edge""": 13_33} if size is None else size
              _a			  =       do_normalize
              _a			  =       image_mean
              _a			  =       image_std
              _a			  =       class_info_file
              _a			  =       prepare_metadata(lowerCamelCase_							,    lowerCamelCase_      )
              _a			  =       num_text
              _a			  =       repo_path

              # for the post_process_functions
              _a			  =       2
              _a			  =       10
              _a			  =       10
              _a			  =       3
              _a			  =       4
              _a			  =       num_labels
              _a			  =       do_reduce_labels
              _a			  =       ignore_index







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


              """simple docstring"""


              return {
                  "do_resize": self.do_resize,
                  "size": self.size,
                  "do_normalize": self.do_normalize,
                  "image_mean": self.image_mean,
                  "image_std": self.image_std,
                  "num_labels": self.num_labels,
                  "do_reduce_labels": self.do_reduce_labels,
                  "ignore_index": self.ignore_index,
                  "class_info_file": self.class_info_file,
                  "metadata": self.metadata,
                  "num_text": self.num_text,
              }







       def      __lowerCAmelCase    (						self :						Any							,    lowerCAmelCase_ :						Tuple							,    lowerCAmelCase_ :						Optional[int]=False      )    ->							str:


              """simple docstring"""


              if not batched:
                     _a			  =       image_inputs[0]
                     if isinstance(lowerCamelCase_							,    Image.Image      ):
                            _a			  =       image.size
                     else:
                            _a			  =       image.shape[1], image.shape[2]
                     if w < h:
                            _a			  =       int(self.size['''shortest_edge'''] * h / w      )
                            _a			  =       self.size["""shortest_edge"""]
                     elif w > h:
                            _a			  =       self.size["""shortest_edge"""]
                            _a			  =       int(self.size['''shortest_edge'''] * w / h      )
                     else:
                            _a			  =       self.size["""shortest_edge"""]
                            _a			  =       self.size["""shortest_edge"""]

              else:
                     _a			  =       []
                     for image in image_inputs:
                            _a			  =       self.get_expected_values([image]      )
                            expected_values.append((expected_height, expected_width)      )
                     _a			  =       max(lowerCamelCase_							,    key=lambda lowerCAmelCase_      : item[0]      )[0]
                     _a			  =       max(lowerCamelCase_							,    key=lambda lowerCAmelCase_      : item[1]      )[1]

              return expected_height, expected_width







       def      __lowerCAmelCase    (						self :						Dict      )    ->							Optional[Any]:


              """simple docstring"""


              return OneFormerForUniversalSegmentationOutput(
                  # +1 for null class
                  class_queries_logits=torch.randn((self.batch_size, self.num_queries, self.num_classes + 1)      )							,    masks_queries_logits=torch.randn((self.batch_size, self.num_queries, self.height, self.width)      )							,    )



@require_torch
@require_vision
class     A					(	lowercase_  ,unittest.TestCase					):
       lowercase_           =       OneFormerImageProcessor if (is_vision_available() and is_torch_available()) else None
       # only for test_image_processing_common.test_image_proc_to_json_string
       lowercase_           =       image_processing_class







       def      __lowerCAmelCase    (						self :						Union[str, Any]      )    ->							int:


              """simple docstring"""


              _a			  =       OneFormerImageProcessorTester(self      )







       @property
       def      __lowerCAmelCase    (						self :						List[Any]      )    ->							Optional[int]:


              """simple docstring"""


              return self.image_processing_tester.prepare_image_processor_dict()







       def      __lowerCAmelCase    (						self :						Dict      )    ->							Union[str, Any]:


              """simple docstring"""


              _a			  =       self.image_processing_class(**self.image_processor_dict      )
              self.assertTrue(hasattr(lowerCamelCase_							,    '''image_mean'''      )      )
              self.assertTrue(hasattr(lowerCamelCase_							,    '''image_std'''      )      )
              self.assertTrue(hasattr(lowerCamelCase_							,    '''do_normalize'''      )      )
              self.assertTrue(hasattr(lowerCamelCase_							,    '''do_resize'''      )      )
              self.assertTrue(hasattr(lowerCamelCase_							,    '''size'''      )      )
              self.assertTrue(hasattr(lowerCamelCase_							,    '''ignore_index'''      )      )
              self.assertTrue(hasattr(lowerCamelCase_							,    '''class_info_file'''      )      )
              self.assertTrue(hasattr(lowerCamelCase_							,    '''num_text'''      )      )
              self.assertTrue(hasattr(lowerCamelCase_							,    '''repo_path'''      )      )
              self.assertTrue(hasattr(lowerCamelCase_							,    '''metadata'''      )      )
              self.assertTrue(hasattr(lowerCamelCase_							,    '''do_reduce_labels'''      )      )







       def      __lowerCAmelCase    (						self :						Optional[int]      )    ->							int:


              """simple docstring"""


              pass







       def      __lowerCAmelCase    (						self :						List[str]      )    ->							int:


              """simple docstring"""


              _a			  =       self.image_processing_class(**self.image_processor_dict      )
              # create random PIL images
              _a			  =       prepare_image_inputs(self.image_processing_tester							,    equal_resolution=lowerCamelCase_      )
              for image in image_inputs:
                     self.assertIsInstance(lowerCamelCase_							,    Image.Image      )

              # Test not batched input
              _a			  =       image_processor(image_inputs[0]							,    ['''semantic''']							,    return_tensors='''pt'''      ).pixel_values

              _a			  =       self.image_processing_tester.get_expected_values(lowerCamelCase_      )

              self.assertEqual(
                  encoded_images.shape							,    (1, self.image_processing_tester.num_channels, expected_height, expected_width)							,    )

              # Test batched
              _a			  =       self.image_processing_tester.get_expected_values(lowerCamelCase_							,    batched=lowerCamelCase_      )

              _a			  =       image_processor(
                  lowerCamelCase_							,    ['''semantic'''] * len(lowerCamelCase_      )							,    return_tensors='''pt'''      ).pixel_values
              self.assertEqual(
                  encoded_images.shape							,    (
                      self.image_processing_tester.batch_size,
                      self.image_processing_tester.num_channels,
                      expected_height,
                      expected_width,
                  )							,    )







       def      __lowerCAmelCase    (						self :						str      )    ->							Any:


              """simple docstring"""


              _a			  =       self.image_processing_class(**self.image_processor_dict      )
              # create random numpy tensors
              _a			  =       prepare_image_inputs(self.image_processing_tester							,    equal_resolution=lowerCamelCase_							,    numpify=lowerCamelCase_      )
              for image in image_inputs:
                     self.assertIsInstance(lowerCamelCase_							,    np.ndarray      )

              # Test not batched input
              _a			  =       image_processor(image_inputs[0]							,    ['''semantic''']							,    return_tensors='''pt'''      ).pixel_values

              _a			  =       self.image_processing_tester.get_expected_values(lowerCamelCase_      )

              self.assertEqual(
                  encoded_images.shape							,    (1, self.image_processing_tester.num_channels, expected_height, expected_width)							,    )

              # Test batched
              _a			  =       self.image_processing_tester.get_expected_values(lowerCamelCase_							,    batched=lowerCamelCase_      )

              _a			  =       image_processor(
                  lowerCamelCase_							,    ['''semantic'''] * len(lowerCamelCase_      )							,    return_tensors='''pt'''      ).pixel_values
              self.assertEqual(
                  encoded_images.shape							,    (
                      self.image_processing_tester.batch_size,
                      self.image_processing_tester.num_channels,
                      expected_height,
                      expected_width,
                  )							,    )







       def      __lowerCAmelCase    (						self :						int      )    ->							str:


              """simple docstring"""


              _a			  =       self.image_processing_class(**self.image_processor_dict      )
              # create random PyTorch tensors
              _a			  =       prepare_image_inputs(self.image_processing_tester							,    equal_resolution=lowerCamelCase_							,    torchify=lowerCamelCase_      )
              for image in image_inputs:
                     self.assertIsInstance(lowerCamelCase_							,    torch.Tensor      )

              # Test not batched input
              _a			  =       image_processor(image_inputs[0]							,    ['''semantic''']							,    return_tensors='''pt'''      ).pixel_values

              _a			  =       self.image_processing_tester.get_expected_values(lowerCamelCase_      )

              self.assertEqual(
                  encoded_images.shape							,    (1, self.image_processing_tester.num_channels, expected_height, expected_width)							,    )

              # Test batched
              _a			  =       self.image_processing_tester.get_expected_values(lowerCamelCase_							,    batched=lowerCamelCase_      )

              _a			  =       image_processor(
                  lowerCamelCase_							,    ['''semantic'''] * len(lowerCamelCase_      )							,    return_tensors='''pt'''      ).pixel_values
              self.assertEqual(
                  encoded_images.shape							,    (
                      self.image_processing_tester.batch_size,
                      self.image_processing_tester.num_channels,
                      expected_height,
                      expected_width,
                  )							,    )







       def      __lowerCAmelCase    (						self :						int							,    lowerCAmelCase_ :						List[Any]=False							,    lowerCAmelCase_ :						Union[str, Any]=False							,    lowerCAmelCase_ :						Tuple="np"      )    ->							Dict:


              """simple docstring"""


              _a			  =       self.image_processing_class(**self.image_processor_dict      )
              # prepare image and target
              _a			  =       self.image_processing_tester.num_labels
              _a			  =       None
              _a			  =       None
              _a			  =       prepare_image_inputs(self.image_processing_tester							,    equal_resolution=lowerCamelCase_      )
              if with_segmentation_maps:
                     _a			  =       num_labels
                     if is_instance_map:
                            _a			  =       list(range(lowerCamelCase_      )      ) * 2
                            _a			  =       dict(enumerate(lowerCamelCase_      )      )
                     _a			  =       [
                         np.random.randint(0							,    high * 2							,    (img.size[1], img.size[0])      ).astype(np.uinta      ) for img in image_inputs
                     ]
                     if segmentation_type == "pil":
                            _a			  =       [Image.fromarray(lowerCamelCase_      ) for annotation in annotations]

              _a			  =       image_processor(
                  lowerCamelCase_							,    ['''semantic'''] * len(lowerCamelCase_      )							,    lowerCamelCase_							,    return_tensors='''pt'''							,    instance_id_to_semantic_id=lowerCamelCase_							,    pad_and_return_pixel_mask=lowerCamelCase_							,    )

              return inputs







       def      __lowerCAmelCase    (						self :						Tuple      )    ->							List[str]:


              """simple docstring"""


              pass







       def      __lowerCAmelCase    (						self :						Tuple      )    ->							Optional[Any]:


              """simple docstring"""


              def common(lowerCAmelCase_ :						List[str]=False							,    lowerCAmelCase_ :						int=None      ):
                     _a			  =       self.comm_get_image_processor_inputs(
                         with_segmentation_maps=lowerCamelCase_							,    is_instance_map=lowerCamelCase_							,    segmentation_type=lowerCamelCase_      )

                     _a			  =       inputs["""mask_labels"""]
                     _a			  =       inputs["""class_labels"""]
                     _a			  =       inputs["""pixel_values"""]
                     _a			  =       inputs["""text_inputs"""]

                     # check the batch_size
                     for mask_label, class_label, text_input in zip(lowerCamelCase_							,    lowerCamelCase_							,    lowerCamelCase_      ):
                            self.assertEqual(mask_label.shape[0]							,    class_label.shape[0]      )
                            # this ensure padding has happened
                            self.assertEqual(mask_label.shape[1:]							,    pixel_values.shape[2:]      )
                            self.assertEqual(len(lowerCamelCase_      )							,    self.image_processing_tester.num_text      )

              common()
              common(is_instance_map=lowerCamelCase_      )
              common(is_instance_map=lowerCamelCase_							,    segmentation_type='''pil'''      )
              common(is_instance_map=lowerCamelCase_							,    segmentation_type='''pil'''      )







       def      __lowerCAmelCase    (						self :						Tuple      )    ->							int:


              """simple docstring"""


              _a			  =       np.zeros((20, 50)      )
              _a			  =       1
              _a			  =       1
              _a			  =       1

              _a			  =       binary_mask_to_rle(lowerCamelCase_      )
              self.assertEqual(len(lowerCamelCase_      )							,    4      )
              self.assertEqual(rle[0]							,    21      )
              self.assertEqual(rle[1]							,    45      )







       def      __lowerCAmelCase    (						self :						str      )    ->							Tuple:


              """simple docstring"""


              _a			  =       self.image_processing_class(
                  num_labels=self.image_processing_tester.num_classes							,    max_seq_length=77							,    task_seq_length=77							,    class_info_file='''ade20k_panoptic.json'''							,    num_text=self.image_processing_tester.num_text							,    repo_path='''shi-labs/oneformer_demo'''							,    )
              _a			  =       self.image_processing_tester.get_fake_oneformer_outputs()

              _a			  =       fature_extractor.post_process_semantic_segmentation(lowerCamelCase_      )

              self.assertEqual(len(lowerCamelCase_      )							,    self.image_processing_tester.batch_size      )
              self.assertEqual(
                  segmentation[0].shape							,    (
                      self.image_processing_tester.height,
                      self.image_processing_tester.width,
                  )							,    )

              _a			  =       [(1, 4) for i in range(self.image_processing_tester.batch_size      )]
              _a			  =       fature_extractor.post_process_semantic_segmentation(lowerCamelCase_							,    target_sizes=lowerCamelCase_      )

              self.assertEqual(segmentation[0].shape							,    target_sizes[0]      )







       def      __lowerCAmelCase    (						self :						Optional[Any]      )    ->							Optional[Any]:


              """simple docstring"""


              _a			  =       self.image_processing_class(
                  num_labels=self.image_processing_tester.num_classes							,    max_seq_length=77							,    task_seq_length=77							,    class_info_file='''ade20k_panoptic.json'''							,    num_text=self.image_processing_tester.num_text							,    repo_path='''shi-labs/oneformer_demo'''							,    )
              _a			  =       self.image_processing_tester.get_fake_oneformer_outputs()
              _a			  =       image_processor.post_process_instance_segmentation(lowerCamelCase_							,    threshold=0      )

              self.assertTrue(len(lowerCamelCase_      ) == self.image_processing_tester.batch_size      )
              for el in segmentation:
                     self.assertTrue('''segmentation''' in el      )
                     self.assertTrue('''segments_info''' in el      )
                     self.assertEqual(type(el['''segments_info''']      )							,    lowerCamelCase_      )
                     self.assertEqual(
                         el['''segmentation'''].shape							,    (self.image_processing_tester.height, self.image_processing_tester.width)      )







       def      __lowerCAmelCase    (						self :						List[Any]      )    ->							Any:


              """simple docstring"""


              _a			  =       self.image_processing_class(
                  num_labels=self.image_processing_tester.num_classes							,    max_seq_length=77							,    task_seq_length=77							,    class_info_file='''ade20k_panoptic.json'''							,    num_text=self.image_processing_tester.num_text							,    repo_path='''shi-labs/oneformer_demo'''							,    )
              _a			  =       self.image_processing_tester.get_fake_oneformer_outputs()
              _a			  =       image_processor.post_process_panoptic_segmentation(lowerCamelCase_							,    threshold=0      )

              self.assertTrue(len(lowerCamelCase_      ) == self.image_processing_tester.batch_size      )
              for el in segmentation:
                     self.assertTrue('''segmentation''' in el      )
                     self.assertTrue('''segments_info''' in el      )
                     self.assertEqual(type(el['''segments_info''']      )							,    lowerCamelCase_      )
                     self.assertEqual(
                         el['''segmentation'''].shape							,    (self.image_processing_tester.height, self.image_processing_tester.width)      )







'''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'
				)
				_snake_case   :   int     							=	None
_snake_case   :   Tuple     							=	{
    '7B': 11008,
    '13B': 13824,
    '30B': 17920,
    '65B': 22016,
    '70B': 28672,
}
_snake_case   :   int     							=	{
    '7B': 1,
    '7Bf': 1,
    '13B': 2,
    '13Bf': 2,
    '30B': 4,
    '65B': 8,
    '70B': 8,
    '70Bf': 8,
}
def 	snake_case_					(UpperCamelCase :						Union[str, Any]				,		UpperCamelCase :						Optional[Any]=1				,		UpperCamelCase :						Optional[Any]=256   ):





							'''simple docstring'''


							return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3   )   ) + multiple_of - 1) // multiple_of)
def 	snake_case_					(UpperCamelCase :						Optional[int]   ):





							'''simple docstring'''


							with open(UpperCamelCase				,		'''r'''   ) as f:
														return json.load(UpperCamelCase   )
def 	snake_case_					(UpperCamelCase :						str				,		UpperCamelCase :						str   ):





							'''simple docstring'''


							with open(UpperCamelCase				,		'''w'''   ) as f:
														json.dump(UpperCamelCase				,		UpperCamelCase   )
def 	snake_case_					(UpperCamelCase :						Optional[Any]				,		UpperCamelCase :						List[str]				,		UpperCamelCase :						Union[str, Any]				,		UpperCamelCase :						str=True   ):





							'''simple docstring'''


							os.makedirs(UpperCamelCase				,		exist_ok=UpperCamelCase   )
							_a			  =       os.path.join(UpperCamelCase				,		'''tmp'''   )
							os.makedirs(UpperCamelCase				,		exist_ok=UpperCamelCase   )

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

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

							# permute for sliced rotary
							def permute(UpperCamelCase :						List[str]				,		UpperCamelCase :						str=n_heads				,		UpperCamelCase :						int=dim				,		UpperCamelCase :						Optional[Any]=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			  =       torch.load(os.path.join(UpperCamelCase				,		'''consolidated.00.pth'''   )				,		map_location='''cpu'''   )
							else:
														# Sharded
														_a			  =       [
														    torch.load(os.path.join(UpperCamelCase				,		f'consolidated.{i:02d}.pth'   )				,		map_location='''cpu'''   )
														    for i in range(UpperCamelCase   )
														]
							_a			  =       0
							_a			  =       {'''weight_map''': {}}
							for layer_i in range(UpperCamelCase   ):
														_a			  =       f'pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin'
														if model_size == "7B":
																					# Unsharded
																					_a			  =       {
																					    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			  =       {
																					    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			  =       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			  =       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			  =       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			  =       torch.cat(
																					    [loaded[i][f'layers.{layer_i}.attention.wo.weight'] for i in range(UpperCamelCase   )]				,		dim=1   )
																					_a			  =       torch.cat(
																					    [loaded[i][f'layers.{layer_i}.feed_forward.w1.weight'] for i in range(UpperCamelCase   )]				,		dim=0   )
																					_a			  =       torch.cat(
																					    [loaded[i][f'layers.{layer_i}.feed_forward.w2.weight'] for i in range(UpperCamelCase   )]				,		dim=1   )
																					_a			  =       torch.cat(
																					    [loaded[i][f'layers.{layer_i}.feed_forward.w3.weight'] for i in range(UpperCamelCase   )]				,		dim=0   )

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

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

							# Write configs
							_a			  =       {'''total_size''': param_count * 2}
							write_json(UpperCamelCase				,		os.path.join(UpperCamelCase				,		'''pytorch_model.bin.index.json'''   )   )
							_a			  =       params['''ffn_dim_multiplier'''] if '''ffn_dim_multiplier''' in params else 1
							_a			  =       params['''multiple_of'''] if '''multiple_of''' in params else 256
							_a			  =       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			  =       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 	snake_case_					(UpperCamelCase :						Optional[int]				,		UpperCamelCase :						Tuple   ):





							'''simple docstring'''


							_a			  =       LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
							print(f'Saving a {tokenizer_class.__name__} to {tokenizer_path}.'   )
							_a			  =       tokenizer_class(UpperCamelCase   )
							tokenizer.save_pretrained(UpperCamelCase   )
def 	snake_case_					():





							'''simple docstring'''


							_a			  =       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			  =       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			  =       os.path.join(args.input_dir				,		'''tokenizer.model'''   )
							write_tokenizer(args.output_dir				,		UpperCamelCase   )


if __name__ == "__main__":
				main()

