





import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizer

from diffusers import (
    AltDiffusionImgaImgPipeline,
    AutoencoderKL,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()

class   A							(						unittest.TestCase    ):



      def 						lowerCAmelCase__     (						self:    Dict							)    ->     Union[str, Any]:
         '''simple docstring'''

         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()



      @property
      def 						lowerCAmelCase__     (						self:    Any							)    ->     Dict:
         '''simple docstring'''

         UpperCAmelCase_           =1
         UpperCAmelCase_           =3
         UpperCAmelCase_           =(32, 32)

         UpperCAmelCase_           =floats_tensor((batch_size, num_channels) + sizes		,	rng=random.Random(0							)							).to(_lowerCAmelCase							)
         return image



      @property
      def 						lowerCAmelCase__     (						self:    List[str]							)    ->     Dict:
         '''simple docstring'''

         torch.manual_seed(0							)
         UpperCAmelCase_           =UNetaDConditionModel(
             block_out_channels=(32, 64)		,	layers_per_block=2		,	sample_size=32		,	in_channels=4		,	out_channels=4		,	down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")		,	up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")		,	cross_attention_dim=32		,	)
         return model



      @property
      def 						lowerCAmelCase__     (						self:    Optional[int]							)    ->     int:
         '''simple docstring'''

         torch.manual_seed(0							)
         UpperCAmelCase_           =AutoencoderKL(
             block_out_channels=[32, 64]		,	in_channels=3		,	out_channels=3		,	down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]		,	up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]		,	latent_channels=4		,	)
         return model



      @property
      def 						lowerCAmelCase__     (						self:    List[str]							)    ->     List[str]:
         '''simple docstring'''

         torch.manual_seed(0							)
         UpperCAmelCase_           =RobertaSeriesConfig(
             hidden_size=32		,	project_dim=32		,	intermediate_size=37		,	layer_norm_eps=1e-05		,	num_attention_heads=4		,	num_hidden_layers=5		,	pad_token_id=1		,	vocab_size=5006		,	)
         return RobertaSeriesModelWithTransformation(_lowerCAmelCase							)



      @property
      def 						lowerCAmelCase__     (						self:    Union[str, Any]							)    ->     Union[str, Any]:
         '''simple docstring'''

         def extract(*_lowerCAmelCase:    List[Any]		,	**_lowerCAmelCase:    int							):

            class   A							:



                  def __init__(						self:    List[str]							)    ->     Dict:
                     '''simple docstring'''

                     UpperCAmelCase_           =torch.ones([0]							)






                  def 						lowerCAmelCase__     (						self:    List[str]		,	_lowerCAmelCase:    str							)    ->     Any:
                     '''simple docstring'''

                     self.pixel_values.to(_lowerCAmelCase							)
                     return self

            return Out()

         return extract



      def 						lowerCAmelCase__     (						self:    Dict							)    ->     Optional[int]:
         '''simple docstring'''

         UpperCAmelCase_           ="cpu"  # ensure determinism for the device-dependent torch.Generator
         UpperCAmelCase_           =self.dummy_cond_unet
         UpperCAmelCase_           =PNDMScheduler(skip_prk_steps=_lowerCAmelCase							)
         UpperCAmelCase_           =self.dummy_vae
         UpperCAmelCase_           =self.dummy_text_encoder
         UpperCAmelCase_           =XLMRobertaTokenizer.from_pretrained("hf-internal-testing/tiny-xlm-roberta"							)
         UpperCAmelCase_           =77

         UpperCAmelCase_           =self.dummy_image.to(_lowerCAmelCase							)
         UpperCAmelCase_           =init_image / 2 + 0.5

         # make sure here that pndm scheduler skips prk
         UpperCAmelCase_           =AltDiffusionImgaImgPipeline(
             unet=_lowerCAmelCase		,	scheduler=_lowerCAmelCase		,	vae=_lowerCAmelCase		,	text_encoder=_lowerCAmelCase		,	tokenizer=_lowerCAmelCase		,	safety_checker=_lowerCAmelCase		,	feature_extractor=self.dummy_extractor		,	)
         UpperCAmelCase_           =VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor		,	do_normalize=_lowerCAmelCase							)
         UpperCAmelCase_           =alt_pipe.to(_lowerCAmelCase							)
         alt_pipe.set_progress_bar_config(disable=_lowerCAmelCase							)

         UpperCAmelCase_           ="A painting of a squirrel eating a burger"
         UpperCAmelCase_           =torch.Generator(device=_lowerCAmelCase							).manual_seed(0							)
         UpperCAmelCase_           =alt_pipe(
             [prompt]		,	generator=_lowerCAmelCase		,	guidance_scale=6.0		,	num_inference_steps=2		,	output_type="np"		,	image=_lowerCAmelCase		,	)

         UpperCAmelCase_           =output.images

         UpperCAmelCase_           =torch.Generator(device=_lowerCAmelCase							).manual_seed(0							)
         UpperCAmelCase_           =alt_pipe(
             [prompt]		,	generator=_lowerCAmelCase		,	guidance_scale=6.0		,	num_inference_steps=2		,	output_type="np"		,	image=_lowerCAmelCase		,	return_dict=_lowerCAmelCase		,	)[0]

         UpperCAmelCase_           =image[0, -3:, -3:, -1]
         UpperCAmelCase_           =image_from_tuple[0, -3:, -3:, -1]

         assert image.shape == (1, 32, 32, 3)
         UpperCAmelCase_           =np.array([0.44_27, 0.37_31, 0.42_49, 0.49_41, 0.45_46, 0.41_48, 0.41_93, 0.46_66, 0.44_99]							)

         assert np.abs(image_slice.flatten() - expected_slice							).max() < 5e-3
         assert np.abs(image_from_tuple_slice.flatten() - expected_slice							).max() < 5e-3



      @unittest.skipIf(torch_device != "cuda"		,	"This test requires a GPU"							)
      def 						lowerCAmelCase__     (						self:    List[str]							)    ->     Optional[Any]:
         '''simple docstring'''

         UpperCAmelCase_           =self.dummy_cond_unet
         UpperCAmelCase_           =PNDMScheduler(skip_prk_steps=_lowerCAmelCase							)
         UpperCAmelCase_           =self.dummy_vae
         UpperCAmelCase_           =self.dummy_text_encoder
         UpperCAmelCase_           =XLMRobertaTokenizer.from_pretrained("hf-internal-testing/tiny-xlm-roberta"							)
         UpperCAmelCase_           =77

         UpperCAmelCase_           =self.dummy_image.to(_lowerCAmelCase							)

         # put models in fp16
         UpperCAmelCase_           =unet.half()
         UpperCAmelCase_           =vae.half()
         UpperCAmelCase_           =bert.half()

         # make sure here that pndm scheduler skips prk
         UpperCAmelCase_           =AltDiffusionImgaImgPipeline(
             unet=_lowerCAmelCase		,	scheduler=_lowerCAmelCase		,	vae=_lowerCAmelCase		,	text_encoder=_lowerCAmelCase		,	tokenizer=_lowerCAmelCase		,	safety_checker=_lowerCAmelCase		,	feature_extractor=self.dummy_extractor		,	)
         UpperCAmelCase_           =VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor		,	do_normalize=_lowerCAmelCase							)
         UpperCAmelCase_           =alt_pipe.to(_lowerCAmelCase							)
         alt_pipe.set_progress_bar_config(disable=_lowerCAmelCase							)

         UpperCAmelCase_           ="A painting of a squirrel eating a burger"
         UpperCAmelCase_           =torch.manual_seed(0							)
         UpperCAmelCase_           =alt_pipe(
             [prompt]		,	generator=_lowerCAmelCase		,	num_inference_steps=2		,	output_type="np"		,	image=_lowerCAmelCase		,	).images

         assert image.shape == (1, 32, 32, 3)






      @unittest.skipIf(torch_device != "cuda"		,	"This test requires a GPU"							)
      def 						lowerCAmelCase__     (						self:    List[str]							)    ->     Union[str, Any]:
         '''simple docstring'''

         UpperCAmelCase_           =load_image(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
             "/img2img/sketch-mountains-input.jpg"							)
         # resize to resolution that is divisible by 8 but not 16 or 32
         UpperCAmelCase_           =init_image.resize((760, 504)							)

         UpperCAmelCase_           ="BAAI/AltDiffusion"
         UpperCAmelCase_           =AltDiffusionImgaImgPipeline.from_pretrained(
             _lowerCAmelCase		,	safety_checker=_lowerCAmelCase		,	)
         pipe.to(_lowerCAmelCase							)
         pipe.set_progress_bar_config(disable=_lowerCAmelCase							)
         pipe.enable_attention_slicing()

         UpperCAmelCase_           ="A fantasy landscape, trending on artstation"

         UpperCAmelCase_           =torch.manual_seed(0							)
         UpperCAmelCase_           =pipe(
             prompt=_lowerCAmelCase		,	image=_lowerCAmelCase		,	strength=0.75		,	guidance_scale=7.5		,	generator=_lowerCAmelCase		,	output_type="np"		,	)
         UpperCAmelCase_           =output.images[0]

         UpperCAmelCase_           =image[255:258, 383:386, -1]

         assert image.shape == (504, 760, 3)
         UpperCAmelCase_           =np.array([0.93_58, 0.93_97, 0.95_99, 0.99_01, 1.00_00, 1.00_00, 0.98_82, 1.00_00, 1.00_00]							)

         assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-2

@slow
@require_torch_gpu
class   A							(						unittest.TestCase    ):



      def 						lowerCAmelCase__     (						self:    Dict							)    ->     Optional[Any]:
         '''simple docstring'''

         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()






      def 						lowerCAmelCase__     (						self:    Dict							)    ->     Dict:
         '''simple docstring'''

         UpperCAmelCase_           =load_image(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
             "/img2img/sketch-mountains-input.jpg"							)
         UpperCAmelCase_           =init_image.resize((768, 512)							)
         UpperCAmelCase_           =load_numpy(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy"							)

         UpperCAmelCase_           ="BAAI/AltDiffusion"
         UpperCAmelCase_           =AltDiffusionImgaImgPipeline.from_pretrained(
             _lowerCAmelCase		,	safety_checker=_lowerCAmelCase		,	)
         pipe.to(_lowerCAmelCase							)
         pipe.set_progress_bar_config(disable=_lowerCAmelCase							)
         pipe.enable_attention_slicing()

         UpperCAmelCase_           ="A fantasy landscape, trending on artstation"

         UpperCAmelCase_           =torch.manual_seed(0							)
         UpperCAmelCase_           =pipe(
             prompt=_lowerCAmelCase		,	image=_lowerCAmelCase		,	strength=0.75		,	guidance_scale=7.5		,	generator=_lowerCAmelCase		,	output_type="np"		,	)
         UpperCAmelCase_           =output.images[0]

         assert image.shape == (512, 768, 3)
         # img2img is flaky across GPUs even in fp32, so using MAE here
         assert np.abs(expected_image - image							).max() < 1e-2






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


def A (__lowerCamelCase :int					,      __lowerCamelCase :Optional[Any]=1					,      __lowerCamelCase :List[Any]=256						):
						return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3						)						) + multiple_of - 1) // multiple_of)


def A (__lowerCamelCase :Any						):
						with open(__lowerCamelCase					,      """r"""						) as f:
												return json.load(__lowerCamelCase						)


def A (__lowerCamelCase :List[Any]					,      __lowerCamelCase :int						):
						with open(__lowerCamelCase					,      """w"""						) as f:
												json.dump(__lowerCamelCase					,      __lowerCamelCase						)


def A (__lowerCamelCase :Optional[Any]					,      __lowerCamelCase :Tuple					,      __lowerCamelCase :Optional[Any]					,      __lowerCamelCase :Tuple=True						):
						os.makedirs(__lowerCamelCase					,      exist_ok=__lowerCamelCase						)
						_lowerCAmelCase    		=					os.path.join(__lowerCamelCase					,      """tmp"""						)
						os.makedirs(__lowerCamelCase					,      exist_ok=__lowerCamelCase						)

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

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

						# permute for sliced rotary
						def permute(__lowerCamelCase :Optional[int]					,      __lowerCamelCase :str=n_heads					,      __lowerCamelCase :str=dim					,      __lowerCamelCase :List[Any]=dim						):
												return w.view(__lowerCamelCase					,      dima // n_heads // 2					,      2					,      __lowerCamelCase						).transpose(1					,      2						).reshape(__lowerCamelCase					,      __lowerCamelCase						)

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

																		_lowerCAmelCase    		=					{
																		    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(),
																		}
																		_lowerCAmelCase    		=					permute(
																		    torch.cat(
																		        [
																		            loaded[i][f'layers.{layer_i}.attention.wq.weight'].view(__lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase						)
																		            for i in range(__lowerCamelCase						)
																		        ]					,      dim=0					,      ).reshape(__lowerCamelCase					,      __lowerCamelCase						)						)
																		_lowerCAmelCase    		=					permute(
																		    torch.cat(
																		        [
																		            loaded[i][f'layers.{layer_i}.attention.wk.weight'].view(
																		                __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase						)
																		            for i in range(__lowerCamelCase						)
																		        ]					,      dim=0					,      ).reshape(__lowerCamelCase					,      __lowerCamelCase						)					,      __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase					,      )
																		_lowerCAmelCase    		=					torch.cat(
																		    [
																		        loaded[i][f'layers.{layer_i}.attention.wv.weight'].view(
																		            __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase						)
																		        for i in range(__lowerCamelCase						)
																		    ]					,      dim=0					,      ).reshape(__lowerCamelCase					,      __lowerCamelCase						)

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

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

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

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

						# Write configs
						_lowerCAmelCase    		=					{"""total_size""": param_count * 2}
						write_json(__lowerCamelCase					,      os.path.join(__lowerCamelCase					,      """pytorch_model.bin.index.json"""						)						)
						_lowerCAmelCase    		=					params["""ffn_dim_multiplier"""] if """ffn_dim_multiplier""" in params else 1
						_lowerCAmelCase    		=					params["""multiple_of"""] if """multiple_of""" in params else 256
						_lowerCAmelCase    		=					LlamaConfig(
						    hidden_size=__lowerCamelCase					,      intermediate_size=compute_intermediate_size(__lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase						)					,      num_attention_heads=params["""n_heads"""]					,      num_hidden_layers=params["""n_layers"""]					,      rms_norm_eps=params["""norm_eps"""]					,      num_key_value_heads=__lowerCamelCase					,      )
						config.save_pretrained(__lowerCamelCase						)

						# 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."""						)
						_lowerCAmelCase    		=					LlamaForCausalLM.from_pretrained(__lowerCamelCase					,      torch_dtype=torch.floataa					,      low_cpu_mem_usage=__lowerCamelCase						)
						# Avoid saving this as part of the config.
						del model.config._name_or_path

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


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


def A ():
						_lowerCAmelCase    		=					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=__lowerCamelCase					,      help="""Whether or not to save using `safetensors`."""						)
						_lowerCAmelCase    		=					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					,      )
						_lowerCAmelCase    		=					os.path.join(args.input_dir					,      """tokenizer.model"""						)
						write_tokenizer(args.output_dir					,      __lowerCamelCase						)


if __name__ == "__main__":
						main()
