




'''simple docstring'''







import argparse

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    CLIPTokenizer,
    CLIPTokenizerFast,
    VideoMAEImageProcessor,
    XCLIPConfig,
    XCLIPModel,
    XCLIPProcessor,
    XCLIPTextConfig,
    XCLIPVisionConfig,
)





def 						snake_case_							(_a	:							Optional[Any]    ,   _a	:							int     ):
    UpperCAmelCase			       =		XCLIPTextConfig()

    # derive patch size from model name
    UpperCAmelCase			       =		model_name.find('''patch'''     )
    UpperCAmelCase			       =		int(model_name[start_idx + len('''patch'''     ) : start_idx + len('''patch'''     ) + 2]     )
    UpperCAmelCase			       =		XCLIPVisionConfig(patch_size=__SCREAMING_SNAKE_CASE    ,   num_frames=__SCREAMING_SNAKE_CASE     )

    if "large" in model_name:
        UpperCAmelCase			       =		7_6_8
        UpperCAmelCase			       =		3_0_7_2
        UpperCAmelCase			       =		1_2

        UpperCAmelCase			       =		1_0_2_4
        UpperCAmelCase			       =		4_0_9_6
        UpperCAmelCase			       =		1_6
        UpperCAmelCase			       =		2_4
        UpperCAmelCase			       =		7_6_8
        UpperCAmelCase			       =		3_0_7_2

    if model_name == "xclip-large-patch14-16-frames":
        UpperCAmelCase			       =		3_3_6

    UpperCAmelCase			       =		XCLIPConfig.from_text_vision_configs(__SCREAMING_SNAKE_CASE    ,   __SCREAMING_SNAKE_CASE     )

    if "large" in model_name:
        UpperCAmelCase			       =		7_6_8

    return config





def 						snake_case_							(_a	:							str     ):
    # text encoder
    if name == "token_embedding.weight":
        UpperCAmelCase			       =		name.replace('''token_embedding.weight'''    ,   '''text_model.embeddings.token_embedding.weight'''     )
    if name == "positional_embedding":
        UpperCAmelCase			       =		name.replace('''positional_embedding'''    ,   '''text_model.embeddings.position_embedding.weight'''     )
    if "ln_1" in name:
        UpperCAmelCase			       =		name.replace('''ln_1'''    ,   '''layer_norm1'''     )
    if "ln_2" in name:
        UpperCAmelCase			       =		name.replace('''ln_2'''    ,   '''layer_norm2'''     )
    if "c_fc" in name:
        UpperCAmelCase			       =		name.replace('''c_fc'''    ,   '''fc1'''     )
    if "c_proj" in name:
        UpperCAmelCase			       =		name.replace('''c_proj'''    ,   '''fc2'''     )
    if name.startswith('''transformer.resblocks'''     ):
        UpperCAmelCase			       =		name.replace('''transformer.resblocks'''    ,   '''text_model.encoder.layers'''     )
    if "attn.out_proj" in name and "message" not in name:
        UpperCAmelCase			       =		name.replace('''attn.out_proj'''    ,   '''self_attn.out_proj'''     )
    if "ln_final" in name:
        UpperCAmelCase			       =		name.replace('''ln_final'''    ,   '''text_model.final_layer_norm'''     )
    # visual encoder
    if name == "visual.class_embedding":
        UpperCAmelCase			       =		name.replace('''visual.class_embedding'''    ,   '''vision_model.embeddings.class_embedding'''     )
    if name == "visual.positional_embedding":
        UpperCAmelCase			       =		name.replace('''visual.positional_embedding'''    ,   '''vision_model.embeddings.position_embedding.weight'''     )
    if name.startswith('''visual.transformer.resblocks'''     ):
        UpperCAmelCase			       =		name.replace('''visual.transformer.resblocks'''    ,   '''vision_model.encoder.layers'''     )
    if "visual.conv1" in name:
        UpperCAmelCase			       =		name.replace('''visual.conv1'''    ,   '''vision_model.embeddings.patch_embedding'''     )
    if "visual.ln_pre" in name:
        UpperCAmelCase			       =		name.replace('''visual.ln_pre'''    ,   '''vision_model.pre_layernorm'''     )
    if "visual.ln_post" in name:
        UpperCAmelCase			       =		name.replace('''visual.ln_post'''    ,   '''vision_model.post_layernorm'''     )
    if "visual.proj" in name:
        UpperCAmelCase			       =		name.replace('''visual.proj'''    ,   '''visual_projection.weight'''     )
    if "text_projection" in name:
        UpperCAmelCase			       =		name.replace('''text_projection'''    ,   '''text_projection.weight'''     )
    # things on top
    if "prompts_visual_proj" in name:
        UpperCAmelCase			       =		name.replace('''prompts_visual_proj'''    ,   '''prompts_visual_projection'''     )
    if "prompts_visual_ln" in name:
        UpperCAmelCase			       =		name.replace('''prompts_visual_ln'''    ,   '''prompts_visual_layernorm'''     )
    # mit
    if name == "mit.positional_embedding":
        UpperCAmelCase			       =		name.replace('''positional'''    ,   '''position'''     )
    if name.startswith('''mit.resblocks'''     ):
        UpperCAmelCase			       =		name.replace('''mit.resblocks'''    ,   '''mit.encoder.layers'''     )
    # prompts generator
    if name.startswith('''prompts_generator.norm'''     ):
        UpperCAmelCase			       =		name.replace('''prompts_generator.norm'''    ,   '''prompts_generator.layernorm'''     )

    return name





def 						snake_case_							(_a	:							List[Any]    ,   _a	:							Any     ):
    for key in orig_state_dict.copy().keys():
        UpperCAmelCase			       =		orig_state_dict.pop(__SCREAMING_SNAKE_CASE     )

        if "attn.in_proj" in key:
            UpperCAmelCase			       =		key.split('''.'''     )
            if key.startswith('''visual'''     ):
                UpperCAmelCase			       =		key_split[3]
                UpperCAmelCase			       =		config.vision_config.hidden_size
                if "message_attn" in key:
                    if "weight" in key:
                        UpperCAmelCase			       =		val[
                            :dim, :
                        ]
                        UpperCAmelCase			       =		val[
                            dim : dim * 2, :
                        ]
                        UpperCAmelCase			       =		val[
                            -dim:, :
                        ]
                    else:
                        UpperCAmelCase			       =		val[
                            :dim
                        ]
                        UpperCAmelCase			       =		val[
                            dim : dim * 2
                        ]
                        UpperCAmelCase			       =		val[
                            -dim:
                        ]
                else:
                    if "weight" in key:
                        UpperCAmelCase			       =		val[
                            :dim, :
                        ]
                        UpperCAmelCase			       =		val[
                            dim : dim * 2, :
                        ]
                        UpperCAmelCase			       =		val[
                            -dim:, :
                        ]
                    else:
                        UpperCAmelCase			       =		val[:dim]
                        UpperCAmelCase			       =		val[
                            dim : dim * 2
                        ]
                        UpperCAmelCase			       =		val[-dim:]
            elif key.startswith('''mit'''     ):
                UpperCAmelCase			       =		key_split[2]
                UpperCAmelCase			       =		config.vision_config.mit_hidden_size
                if "weight" in key:
                    UpperCAmelCase			       =		val[:dim, :]
                    UpperCAmelCase			       =		val[dim : dim * 2, :]
                    UpperCAmelCase			       =		val[-dim:, :]
                else:
                    UpperCAmelCase			       =		val[:dim]
                    UpperCAmelCase			       =		val[dim : dim * 2]
                    UpperCAmelCase			       =		val[-dim:]
            else:
                UpperCAmelCase			       =		key_split[2]
                UpperCAmelCase			       =		config.text_config.hidden_size
                if "weight" in key:
                    UpperCAmelCase			       =		val[:dim, :]
                    UpperCAmelCase			       =		val[
                        dim : dim * 2, :
                    ]
                    UpperCAmelCase			       =		val[-dim:, :]
                else:
                    UpperCAmelCase			       =		val[:dim]
                    UpperCAmelCase			       =		val[
                        dim : dim * 2
                    ]
                    UpperCAmelCase			       =		val[-dim:]
        else:
            UpperCAmelCase			       =		rename_key(__SCREAMING_SNAKE_CASE     )
            if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
                UpperCAmelCase			       =		val.T
            UpperCAmelCase			       =		val

    return orig_state_dict





def 						snake_case_							(_a	:							Dict     ):
    if num_frames == 8:
        UpperCAmelCase			       =		'''eating_spaghetti_8_frames.npy'''
    elif num_frames == 1_6:
        UpperCAmelCase			       =		'''eating_spaghetti.npy'''
    elif num_frames == 3_2:
        UpperCAmelCase			       =		'''eating_spaghetti_32_frames.npy'''
    UpperCAmelCase			       =		hf_hub_download(
        repo_id='''hf-internal-testing/spaghetti-video'''    ,   filename=__SCREAMING_SNAKE_CASE    ,   repo_type='''dataset'''    ,   )
    UpperCAmelCase			       =		np.load(__SCREAMING_SNAKE_CASE     )
    return list(__SCREAMING_SNAKE_CASE     )





def 						snake_case_							(_a	:							Union[str, Any]    ,   _a	:							List[str]=None    ,   _a	:							Dict=False     ):
    UpperCAmelCase			       =		{
        # fully supervised kinetics-400 checkpoints
        '''xclip-base-patch32''': '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_8.pth''',
        '''xclip-base-patch32-16-frames''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_16.pth'''
        ),
        '''xclip-base-patch16''': '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_8.pth''',
        '''xclip-base-patch16-16-frames''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_16.pth'''
        ),
        '''xclip-large-patch14''': '''https://drive.google.com/u/0/uc?id=1NUOImq0o5DlQTST17iIP3vG7DgmHQuCx&amp;export=download&amp;confirm=t&amp;uuid=b26caedc-88e2-473e-830a-9d158b653cdb''',
        '''xclip-large-patch14-16-frames''': '''https://drive.google.com/u/0/uc?id=1FOYgnJc097OJ4lGwtRCCydQyVPJEOH7d&amp;export=download&amp;confirm=t&amp;uuid=538fa810-e671-4050-b385-9a623f89804f''',
        # fully supervised kinetics-600 checkpoints
        '''xclip-base-patch16-kinetics-600''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_8.pth'''
        ),
        '''xclip-base-patch16-kinetics-600-16-frames''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_16.pth'''
        ),
        '''xclip-large-patch14-kinetics-600''': '''https://drive.google.com/u/0/uc?id=1FV8C1INuM91sLAN4ImjzePLIlpMSihwV&amp;export=download&amp;confirm=t&amp;uuid=141d4977-4a65-44ae-864f-4b0c19f838be''',
        # few shot
        '''xclip-base-patch16-hmdb-2-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_2.pth'''
        ),
        '''xclip-base-patch16-hmdb-4-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_4.pth'''
        ),
        '''xclip-base-patch16-hmdb-8-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_8.pth'''
        ),
        '''xclip-base-patch16-hmdb-16-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_16.pth'''
        ),
        '''xclip-base-patch16-ucf-2-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_2.pth'''
        ),
        '''xclip-base-patch16-ucf-4-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_4.pth'''
        ),
        '''xclip-base-patch16-ucf-8-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_8.pth'''
        ),
        '''xclip-base-patch16-ucf-16-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_16.pth'''
        ),
        # zero shot
        '''xclip-base-patch16-zero-shot''': '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/zero.pth''',
    }

    UpperCAmelCase			       =		model_to_url[model_name]
    UpperCAmelCase			       =		8
    if "16-frames" in model_name:
        UpperCAmelCase			       =		1_6
    elif "shot" in model_name:
        UpperCAmelCase			       =		3_2

    UpperCAmelCase			       =		get_xclip_config(__SCREAMING_SNAKE_CASE    ,   __SCREAMING_SNAKE_CASE     )
    UpperCAmelCase			       =		XCLIPModel(__SCREAMING_SNAKE_CASE     )
    model.eval()

    if "drive" in checkpoint_url:
        UpperCAmelCase			       =		'''pytorch_model.bin'''
        gdown.cached_download(__SCREAMING_SNAKE_CASE    ,   __SCREAMING_SNAKE_CASE    ,   quiet=__SCREAMING_SNAKE_CASE     )
        UpperCAmelCase			       =		torch.load(__SCREAMING_SNAKE_CASE    ,   map_location='''cpu'''     )['''model''']
    else:
        UpperCAmelCase			       =		torch.hub.load_state_dict_from_url(__SCREAMING_SNAKE_CASE     )['''model''']

    UpperCAmelCase			       =		convert_state_dict(__SCREAMING_SNAKE_CASE    ,   __SCREAMING_SNAKE_CASE     )

    UpperCAmelCase			       =		XCLIPModel(__SCREAMING_SNAKE_CASE     )
    UpperCAmelCase       ,     UpperCAmelCase			       =		model.load_state_dict(__SCREAMING_SNAKE_CASE    ,   strict=__SCREAMING_SNAKE_CASE     )
    assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
    model.eval()

    UpperCAmelCase			       =		3_3_6 if model_name == '''xclip-large-patch14-16-frames''' else 2_2_4
    UpperCAmelCase			       =		VideoMAEImageProcessor(size=__SCREAMING_SNAKE_CASE     )
    UpperCAmelCase			       =		CLIPTokenizer.from_pretrained('''openai/clip-vit-base-patch32'''     )
    UpperCAmelCase			       =		CLIPTokenizerFast.from_pretrained('''openai/clip-vit-base-patch32'''     )
    UpperCAmelCase			       =		XCLIPProcessor(image_processor=__SCREAMING_SNAKE_CASE    ,   tokenizer=__SCREAMING_SNAKE_CASE     )

    UpperCAmelCase			       =		prepare_video(__SCREAMING_SNAKE_CASE     )
    UpperCAmelCase			       =		processor(
        text=['''playing sports''', '''eating spaghetti''', '''go shopping''']    ,   videos=__SCREAMING_SNAKE_CASE    ,   return_tensors='''pt'''    ,   padding=__SCREAMING_SNAKE_CASE     )

    print('''Shape of pixel values:'''    ,   inputs.pixel_values.shape     )

    with torch.no_grad():
        UpperCAmelCase			       =		model(**__SCREAMING_SNAKE_CASE     )

    # Verify outputs
    UpperCAmelCase			       =		outputs.logits_per_video
    UpperCAmelCase			       =		logits_per_video.softmax(dim=1     )
    print('''Probs:'''    ,   __SCREAMING_SNAKE_CASE     )
    # kinetics-400
    if model_name == "xclip-base-patch32":
        UpperCAmelCase			       =		torch.tensor([[0.0019, 0.9951, 0.0030]]     )
    elif model_name == "xclip-base-patch32-16-frames":
        UpperCAmelCase			       =		torch.tensor([[7.0999E-04, 9.9883E-01, 4.5580E-04]]     )
    elif model_name == "xclip-base-patch16":
        UpperCAmelCase			       =		torch.tensor([[0.0083, 0.9681, 0.0236]]     )
    elif model_name == "xclip-base-patch16-16-frames":
        UpperCAmelCase			       =		torch.tensor([[7.6937E-04, 9.9728E-01, 1.9473E-03]]     )
    elif model_name == "xclip-large-patch14":
        UpperCAmelCase			       =		torch.tensor([[0.0062, 0.9864, 0.0075]]     )
    elif model_name == "xclip-large-patch14-16-frames":
        UpperCAmelCase			       =		torch.tensor([[3.3877E-04, 9.9937E-01, 2.8888E-04]]     )
    # kinetics-600
    elif model_name == "xclip-base-patch16-kinetics-600":
        UpperCAmelCase			       =		torch.tensor([[0.0555, 0.8914, 0.0531]]     )
    elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
        UpperCAmelCase			       =		torch.tensor([[3.8554E-04, 9.9929E-01, 3.2754E-04]]     )
    elif model_name == "xclip-large-patch14-kinetics-600":
        UpperCAmelCase			       =		torch.tensor([[0.0036, 0.9920, 0.0045]]     )
    # few shot
    elif model_name == "xclip-base-patch16-hmdb-2-shot":
        UpperCAmelCase			       =		torch.tensor([[7.1890E-06, 9.9994E-01, 5.6559E-05]]     )
    elif model_name == "xclip-base-patch16-hmdb-4-shot":
        UpperCAmelCase			       =		torch.tensor([[1.0320E-05, 9.9993E-01, 6.2435E-05]]     )
    elif model_name == "xclip-base-patch16-hmdb-8-shot":
        UpperCAmelCase			       =		torch.tensor([[4.1377E-06, 9.9990E-01, 9.8386E-05]]     )
    elif model_name == "xclip-base-patch16-hmdb-16-shot":
        UpperCAmelCase			       =		torch.tensor([[4.1347E-05, 9.9962E-01, 3.3411E-04]]     )
    elif model_name == "xclip-base-patch16-ucf-2-shot":
        UpperCAmelCase			       =		torch.tensor([[8.5857E-05, 9.9928E-01, 6.3291E-04]]     )
    elif model_name == "xclip-base-patch16-ucf-4-shot":
        UpperCAmelCase			       =		torch.tensor([[8.5857E-05, 9.9928E-01, 6.3291E-04]]     )
    elif model_name == "xclip-base-patch16-ucf-8-shot":
        UpperCAmelCase			       =		torch.tensor([[0.0027, 0.9904, 0.0070]]     )
    elif model_name == "xclip-base-patch16-ucf-16-shot":
        UpperCAmelCase			       =		torch.tensor([[9.8219E-04, 9.9593E-01, 3.0863E-03]]     )
    # zero shot
    elif model_name == "xclip-base-patch16-zero-shot":
        UpperCAmelCase			       =		torch.tensor([[3.5082E-04, 9.9785E-01, 1.7966E-03]]     )
    else:
        raise ValueError(F"Model name {model_name} not supported"     )
    assert torch.allclose(__SCREAMING_SNAKE_CASE    ,   __SCREAMING_SNAKE_CASE    ,   atol=1E-3     )
    print('''Looks ok!'''     )

    if pytorch_dump_folder_path is not None:
        print(F"Saving model {model_name} to {pytorch_dump_folder_path}"     )
        model.save_pretrained(__SCREAMING_SNAKE_CASE     )

    if push_to_hub:
        print('''Pushing model, processor and slow tokenizer files to the hub...'''     )
        model.push_to_hub(__SCREAMING_SNAKE_CASE    ,   organization='''nielsr'''     )
        processor.push_to_hub(__SCREAMING_SNAKE_CASE    ,   organization='''nielsr'''     )
        slow_tokenizer.push_to_hub(__SCREAMING_SNAKE_CASE    ,   organization='''nielsr'''     )


if __name__ == "__main__":
   A     =argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '--model_name',
       default='xclip-base-patch32',
       type=str,
       help='Name of the model.',
   )
   parser.add_argument(
       '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
   )
   parser.add_argument(
       '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
   )

   A     =parser.parse_args()
   convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from pathlib import Path

import torch

from ...utils import is_npu_available, is_xpu_available
from .config_args import ClusterConfig, default_json_config_file
from .config_utils import SubcommandHelpFormatter


UpperCAmelCase	      = '''Create a default config file for Accelerate with only a few flags set.'''






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE="no" ,							__SCREAMING_SNAKE_CASE = default_json_config_file ,							__SCREAMING_SNAKE_CASE = False							):
	lowercase       =    Path(__SCREAMING_SNAKE_CASE							)
	path.parent.mkdir(parents=__SCREAMING_SNAKE_CASE ,							exist_ok=__SCREAMING_SNAKE_CASE							)
	if path.exists():
		print(
		    F'''Configuration already exists at {save_location}, will not override. Run `accelerate config` manually or pass a different `save_location`.'''							)
		return False
	lowercase       =    mixed_precision.lower()
	if mixed_precision not in ["no", "fp16", "bf16", "fp8"]:
		raise ValueError(
		    F'''`mixed_precision` should be one of \'no\', \'fp16\', \'bf16\', or \'fp8\'. Received {mixed_precision}'''							)
	lowercase       =    {
	    'compute_environment': 'LOCAL_MACHINE',
	    'mixed_precision': mixed_precision,
	}
	if torch.cuda.is_available():
		lowercase       =    torch.cuda.device_count()
		lowercase       =    num_gpus
		lowercase       =    False
		if num_gpus > 1:
			lowercase       =    'MULTI_GPU'
		else:
			lowercase       =    'NO'
	elif is_xpu_available() and use_xpu:
		lowercase       =    torch.xpu.device_count()
		lowercase       =    num_xpus
		lowercase       =    False
		if num_xpus > 1:
			lowercase       =    'MULTI_XPU'
		else:
			lowercase       =    'NO'
	elif is_npu_available():
		lowercase       =    torch.npu.device_count()
		lowercase       =    num_npus
		lowercase       =    False
		if num_npus > 1:
			lowercase       =    'MULTI_NPU'
		else:
			lowercase       =    'NO'
	else:
		lowercase       =    0
		lowercase       =    True
		lowercase       =    1
		lowercase       =    'NO'
	lowercase       =    ClusterConfig(**__SCREAMING_SNAKE_CASE							)
	config.to_json_file(__SCREAMING_SNAKE_CASE							)
	return path






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE ,							__SCREAMING_SNAKE_CASE							):
	lowercase       =    parser.add_parser('default' ,							parents=__SCREAMING_SNAKE_CASE ,							help=__SCREAMING_SNAKE_CASE ,							formatter_class=__SCREAMING_SNAKE_CASE							)
	parser.add_argument(
	    '--config_file' ,							default=__SCREAMING_SNAKE_CASE ,							help=(
	        'The path to use to store the config file. Will default to a file named default_config.yaml in the cache '
	        'location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have '
	        'such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed '
	        'with \'huggingface\'.'
	    ) ,							dest='save_location' ,							)

	parser.add_argument(
	    '--mixed_precision' ,							choices=['no', 'fp16', 'bf16'] ,							type=__SCREAMING_SNAKE_CASE ,							help='Whether or not to use mixed precision training. '
	    'Choose between FP16 and BF16 (bfloat16) training. '
	    'BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later.' ,							default='no' ,							)
	parser.set_defaults(func=__SCREAMING_SNAKE_CASE							)
	return parser






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE							):
	lowercase       =    write_basic_config(args.mixed_precision ,							args.save_location							)
	if config_file:
		print(F'''accelerate configuration saved at {config_file}'''							)

