




'''simple docstring'''


import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


_snake_case   :   List[Any]     							=	logging.get_logger(__name__)


_snake_case   :   str     							=	{'vocab_file': 'vocab.json', 'merges_file': 'merges.txt'}

# See all BART models at https://huggingface.co/models?filter=bart
_snake_case   :   List[str]     							=	{
    'vocab_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/vocab.json',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/vocab.json',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json',
    },
    'merges_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/merges.txt',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/merges.txt',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt',
    },
}

_snake_case   :   Optional[Any]     							=	{
    'facebook/bart-base': 1024,
    'facebook/bart-large': 1024,
    'facebook/bart-large-mnli': 1024,
    'facebook/bart-large-cnn': 1024,
    'facebook/bart-large-xsum': 1024,
    'yjernite/bart_eli5': 1024,
}
@lru_cache()
def 	snake_case_					():





       '''simple docstring'''


       _a			  =       (
           list(range(ord('''!'''   )				,		ord('''~'''   ) + 1   )   ) + list(range(ord('''¡'''   )				,		ord('''¬'''   ) + 1   )   ) + list(range(ord('''®'''   )				,		ord('''ÿ'''   ) + 1   )   )
       )
       _a			  =       bs[:]
       _a			  =       0
       for b in range(2**8   ):
              if b not in bs:
                     bs.append(UpperCamelCase   )
                     cs.append(2**8 + n   )
                     n += 1
       _a			  =       [chr(UpperCamelCase   ) for n in cs]
       return dict(zip(UpperCamelCase				,		UpperCamelCase   )   )
def 	snake_case_					(UpperCamelCase :						Optional[int]   ):





       '''simple docstring'''


       _a			  =       set()
       _a			  =       word[0]
       for char in word[1:]:
              pairs.add((prev_char, char)   )
              _a			  =       char
       return pairs

class     A					(	_a					):
       lowercase_           =       VOCAB_FILES_NAMES
       lowercase_           =       PRETRAINED_VOCAB_FILES_MAP
       lowercase_           =       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       lowercase_           =       ['input_ids', 'attention_mask']







       def __init__(						self :						List[str]							,    lowerCAmelCase_ :						List[Any]							,    lowerCAmelCase_ :						int							,    lowerCAmelCase_ :						Union[str, Any]="replace"							,    lowerCAmelCase_ :						Dict="<s>"							,    lowerCAmelCase_ :						Tuple="</s>"							,    lowerCAmelCase_ :						Dict="</s>"							,    lowerCAmelCase_ :						str="<s>"							,    lowerCAmelCase_ :						Union[str, Any]="<unk>"							,    lowerCAmelCase_ :						Optional[int]="<pad>"							,    lowerCAmelCase_ :						Any="<mask>"							,    lowerCAmelCase_ :						Any=False							,    **lowerCAmelCase_ :						int							,    )    ->							int:


              """simple docstring"""


              _a			  =       AddedToken(lowerCAmelCase_							,    lstrip=lowerCAmelCase_							,    rstrip=lowerCAmelCase_      ) if isinstance(lowerCAmelCase_							,    lowerCAmelCase_      ) else bos_token
              _a			  =       AddedToken(lowerCAmelCase_							,    lstrip=lowerCAmelCase_							,    rstrip=lowerCAmelCase_      ) if isinstance(lowerCAmelCase_							,    lowerCAmelCase_      ) else eos_token
              _a			  =       AddedToken(lowerCAmelCase_							,    lstrip=lowerCAmelCase_							,    rstrip=lowerCAmelCase_      ) if isinstance(lowerCAmelCase_							,    lowerCAmelCase_      ) else sep_token
              _a			  =       AddedToken(lowerCAmelCase_							,    lstrip=lowerCAmelCase_							,    rstrip=lowerCAmelCase_      ) if isinstance(lowerCAmelCase_							,    lowerCAmelCase_      ) else cls_token
              _a			  =       AddedToken(lowerCAmelCase_							,    lstrip=lowerCAmelCase_							,    rstrip=lowerCAmelCase_      ) if isinstance(lowerCAmelCase_							,    lowerCAmelCase_      ) else unk_token
              _a			  =       AddedToken(lowerCAmelCase_							,    lstrip=lowerCAmelCase_							,    rstrip=lowerCAmelCase_      ) if isinstance(lowerCAmelCase_							,    lowerCAmelCase_      ) else pad_token

              # Mask token behave like a normal word, i.e. include the space before it
              _a			  =       AddedToken(lowerCAmelCase_							,    lstrip=lowerCAmelCase_							,    rstrip=lowerCAmelCase_      ) if isinstance(lowerCAmelCase_							,    lowerCAmelCase_      ) else mask_token

              super().__init__(
                  errors=lowerCAmelCase_							,    bos_token=lowerCAmelCase_							,    eos_token=lowerCAmelCase_							,    unk_token=lowerCAmelCase_							,    sep_token=lowerCAmelCase_							,    cls_token=lowerCAmelCase_							,    pad_token=lowerCAmelCase_							,    mask_token=lowerCAmelCase_							,    add_prefix_space=lowerCAmelCase_							,    **lowerCAmelCase_							,    )

              with open(lowerCAmelCase_							,    encoding='''utf-8'''      ) as vocab_handle:
                     _a			  =       json.load(lowerCAmelCase_      )
              _a			  =       {v: k for k, v in self.encoder.items()}
              _a			  =       errors  # how to handle errors in decoding
              _a			  =       bytes_to_unicode()
              _a			  =       {v: k for k, v in self.byte_encoder.items()}
              with open(lowerCAmelCase_							,    encoding='''utf-8'''      ) as merges_handle:
                     _a			  =       merges_handle.read().split('''\n'''      )[1:-1]
              _a			  =       [tuple(merge.split()      ) for merge in bpe_merges]
              _a			  =       dict(zip(lowerCAmelCase_							,    range(len(lowerCAmelCase_      )      )      )      )
              _a			  =       {}
              _a			  =       add_prefix_space

              # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
              _a			  =       re.compile(R'''\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+'''      )







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


              """simple docstring"""


              return len(self.encoder      )







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


              """simple docstring"""


              return dict(self.encoder							,    **self.added_tokens_encoder      )







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


              """simple docstring"""


              if token in self.cache:
                     return self.cache[token]
              _a			  =       tuple(lowerCAmelCase_      )
              _a			  =       get_pairs(lowerCAmelCase_      )

              if not pairs:
                     return token

              while True:
                     _a			  =       min(lowerCAmelCase_							,    key=lambda lowerCAmelCase_      : self.bpe_ranks.get(lowerCAmelCase_							,    float('''inf'''      )      )      )
                     if bigram not in self.bpe_ranks:
                            break
                     _a  ,							_a			  =       bigram
                     _a			  =       []
                     _a			  =       0
                     while i < len(lowerCAmelCase_      ):
                            try:
                                   _a			  =       word.index(lowerCAmelCase_							,    lowerCAmelCase_      )
                            except ValueError:
                                   new_word.extend(word[i:]      )
                                   break
                            else:
                                   new_word.extend(word[i:j]      )
                                   _a			  =       j

                            if word[i] == first and i < len(lowerCAmelCase_      ) - 1 and word[i + 1] == second:
                                   new_word.append(first + second      )
                                   i += 2
                            else:
                                   new_word.append(word[i]      )
                                   i += 1
                     _a			  =       tuple(lowerCAmelCase_      )
                     _a			  =       new_word
                     if len(lowerCAmelCase_      ) == 1:
                            break
                     else:
                            _a			  =       get_pairs(lowerCAmelCase_      )
              _a			  =       ''' '''.join(lowerCAmelCase_      )
              _a			  =       word
              return word







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


              """simple docstring"""


              _a			  =       []
              for token in re.findall(self.pat							,    lowerCAmelCase_      ):
                     _a			  =       ''''''.join(
                         self.byte_encoder[b] for b in token.encode('''utf-8'''      )      )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
                     bpe_tokens.extend(bpe_token for bpe_token in self.bpe(lowerCAmelCase_      ).split(''' '''      )      )
              return bpe_tokens







       def      __lowerCAmelCase    (						self :						Optional[int]							,    lowerCAmelCase_ :						Any      )    ->							List[Any]:


              """simple docstring"""


              return self.encoder.get(lowerCAmelCase_							,    self.encoder.get(self.unk_token      )      )







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


              """simple docstring"""


              return self.decoder.get(lowerCAmelCase_      )







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


              """simple docstring"""


              _a			  =       ''''''.join(lowerCAmelCase_      )
              _a			  =       bytearray([self.byte_decoder[c] for c in text]      ).decode('''utf-8'''							,    errors=self.errors      )
              return text







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


              """simple docstring"""


              if not os.path.isdir(lowerCAmelCase_      ):
                     logger.error(F'Vocabulary path ({save_directory}) should be a directory'      )
                     return
              _a			  =       os.path.join(
                  lowerCAmelCase_							,    (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']      )
              _a			  =       os.path.join(
                  lowerCAmelCase_							,    (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file''']      )

              with open(lowerCAmelCase_							,    '''w'''							,    encoding='''utf-8'''      ) as f:
                     f.write(json.dumps(self.encoder							,    indent=2							,    sort_keys=lowerCAmelCase_							,    ensure_ascii=lowerCAmelCase_      ) + '''\n'''      )

              _a			  =       0
              with open(lowerCAmelCase_							,    '''w'''							,    encoding='''utf-8'''      ) as writer:
                     writer.write('''#version: 0.2\n'''      )
                     for bpe_tokens, token_index in sorted(self.bpe_ranks.items()							,    key=lambda lowerCAmelCase_      : kv[1]      ):
                            if index != token_index:
                                   logger.warning(
                                       F'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'
                                       ''' Please check that the tokenizer is not corrupted!'''      )
                                   _a			  =       token_index
                            writer.write(''' '''.join(lowerCAmelCase_      ) + '''\n'''      )
                            index += 1

              return vocab_file, merge_file







       def      __lowerCAmelCase    (						self :						List[str]							,    lowerCAmelCase_ :						List[int]							,    lowerCAmelCase_ :						Optional[List[int]] = None      )    ->							List[int]:


              """simple docstring"""


              if token_ids_a is None:
                     return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
              _a			  =       [self.cls_token_id]
              _a			  =       [self.sep_token_id]
              return cls + token_ids_a + sep + sep + token_ids_a + sep







       def      __lowerCAmelCase    (						self :						Any							,    lowerCAmelCase_ :						List[int]							,    lowerCAmelCase_ :						Optional[List[int]] = None							,    lowerCAmelCase_ :						bool = False      )    ->							List[int]:


              """simple docstring"""


              if already_has_special_tokens:
                     return super().get_special_tokens_mask(
                         token_ids_a=lowerCAmelCase_							,    token_ids_a=lowerCAmelCase_							,    already_has_special_tokens=lowerCAmelCase_      )

              if token_ids_a is None:
                     return [1] + ([0] * len(lowerCAmelCase_      )) + [1]
              return [1] + ([0] * len(lowerCAmelCase_      )) + [1, 1] + ([0] * len(lowerCAmelCase_      )) + [1]







       def      __lowerCAmelCase    (						self :						Dict							,    lowerCAmelCase_ :						List[int]							,    lowerCAmelCase_ :						Optional[List[int]] = None      )    ->							List[int]:


              """simple docstring"""


              _a			  =       [self.sep_token_id]
              _a			  =       [self.cls_token_id]

              if token_ids_a is None:
                     return len(cls + token_ids_a + sep      ) * [0]
              return len(cls + token_ids_a + sep + sep + token_ids_a + sep      ) * [0]







       def      __lowerCAmelCase    (						self :						Union[str, Any]							,    lowerCAmelCase_ :						Any							,    lowerCAmelCase_ :						Any=False							,    **lowerCAmelCase_ :						List[str]      )    ->							int:


              """simple docstring"""


              _a			  =       kwargs.pop('''add_prefix_space'''							,    self.add_prefix_space      )
              if (is_split_into_words or add_prefix_space) and (len(lowerCAmelCase_      ) > 0 and not text[0].isspace()):
                     _a			  =       ''' ''' + text
              return (text, kwargs)







'''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()

