


import glob
import os
from typing import Dict, List, Union

import torch

from diffusers.utils import is_safetensors_available


if is_safetensors_available():
					import safetensors.torch

from huggingface_hub import snapshot_download

from diffusers import DiffusionPipeline, __version__
from diffusers.schedulers.scheduling_utils import SCHEDULER_CONFIG_NAME
from diffusers.utils import CONFIG_NAME, DIFFUSERS_CACHE, ONNX_WEIGHTS_NAME, WEIGHTS_NAME

class     __snake_case							(      _UpperCAmelCase):
					def __init__(	self					:	Dict     )       ->				int:



											'''simple docstring'''





											self.register_to_config()
											super().__init__()
					def   a (	self					:	str  ,			_lowerCAmelCase					:	Union[str, Any]  ,			_lowerCAmelCase					:	Any     )       ->				Optional[Any]:



											'''simple docstring'''





											if dicta == dicta:
																	return True
											else:
																	__magic_name__		,			__magic_name__ 		=			self._remove_meta_keys(_lowerCAmelCase     )
																	__magic_name__		,			__magic_name__ 		=			self._remove_meta_keys(_lowerCAmelCase     )
																	if configa == configa:
																							print(F'''Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}.'''     )
																							return True
											return False
					def   a (	self					:	Union[str, Any]  ,			_lowerCAmelCase					:	Dict     )       ->				List[Any]:



											'''simple docstring'''





											__magic_name__ 		=			[]
											__magic_name__ 		=			config_dict.copy()
											for key in config_dict.keys():
																	if key.startswith('_'     ):
																							temp_dict.pop(_lowerCAmelCase     )
																							meta_keys.append(_lowerCAmelCase     )
											return (temp_dict, meta_keys)
					@torch.no_grad()
					def   a (	self					:	Any  ,			_lowerCAmelCase					:	List[Union[str, os.PathLike]]  ,			**_lowerCAmelCase					:	Tuple     )       ->				Any:



											'''simple docstring'''





											__magic_name__ 		=			kwargs.pop('cache_dir'  ,			_lowerCAmelCase     )
											__magic_name__ 		=			kwargs.pop('resume_download'  ,			_lowerCAmelCase     )
											__magic_name__ 		=			kwargs.pop('force_download'  ,			_lowerCAmelCase     )
											__magic_name__ 		=			kwargs.pop('proxies'  ,			_lowerCAmelCase     )
											__magic_name__ 		=			kwargs.pop('local_files_only'  ,			_lowerCAmelCase     )
											__magic_name__ 		=			kwargs.pop('use_auth_token'  ,			_lowerCAmelCase     )
											__magic_name__ 		=			kwargs.pop('revision'  ,			_lowerCAmelCase     )
											__magic_name__ 		=			kwargs.pop('torch_dtype'  ,			_lowerCAmelCase     )
											__magic_name__ 		=			kwargs.pop('device_map'  ,			_lowerCAmelCase     )

											__magic_name__ 		=			kwargs.pop('alpha'  ,			0.5     )
											__magic_name__ 		=			kwargs.pop('interp'  ,			_lowerCAmelCase     )

											print('Received list'  ,			_lowerCAmelCase     )
											print(F'''Combining with alpha={alpha}, interpolation mode={interp}'''     )

											__magic_name__ 		=			len(_lowerCAmelCase     )
											# Ignore result from model_index_json comparision of the two checkpoints
											__magic_name__ 		=			kwargs.pop('force'  ,			_lowerCAmelCase     )

											# If less than 2 checkpoints, nothing to merge. If more than 3, not supported for now.
											if checkpoint_count > 3 or checkpoint_count < 2:
																	raise ValueError(
																	    'Received incorrect number of checkpoints to merge. Ensure that either 2 or 3 checkpoints are being'
																	    ' passed.'     )

											print('Received the right number of checkpoints'     )
											# chkpt0, chkpt1 = pretrained_model_name_or_path_list[0:2]
											# chkpt2 = pretrained_model_name_or_path_list[2] if checkpoint_count == 3 else None

											# Validate that the checkpoints can be merged
											# Step 1: Load the model config and compare the checkpoints. We'll compare the model_index.json first while ignoring the keys starting with '_'
											__magic_name__ 		=			[]
											for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
																	__magic_name__ 		=			DiffusionPipeline.load_config(
																	    _lowerCAmelCase  ,			cache_dir=_lowerCAmelCase  ,			resume_download=_lowerCAmelCase  ,			force_download=_lowerCAmelCase  ,			proxies=_lowerCAmelCase  ,			local_files_only=_lowerCAmelCase  ,			use_auth_token=_lowerCAmelCase  ,			revision=_lowerCAmelCase  ,			)
																	config_dicts.append(_lowerCAmelCase     )

											__magic_name__ 		=			True
											for idx in range(1  ,			len(_lowerCAmelCase     )     ):
																	comparison_result &= self._compare_model_configs(config_dicts[idx - 1]  ,			config_dicts[idx]     )
																	if not force and comparison_result is False:
																							raise ValueError('Incompatible checkpoints. Please check model_index.json for the models.'     )
																							print(config_dicts[0]  ,			config_dicts[1]     )
											print('Compatible model_index.json files found'     )
											# Step 2: Basic Validation has succeeded. Let's download the models and save them into our local files.
											__magic_name__ 		=			[]
											for pretrained_model_name_or_path, config_dict in zip(_lowerCAmelCase  ,			_lowerCAmelCase     ):
																	__magic_name__ 		=			[k for k in config_dict.keys() if not k.startswith('_'     )]
																	__magic_name__ 		=			[os.path.join(_lowerCAmelCase  ,			'*'     ) for k in folder_names]
																	allow_patterns += [
																	    WEIGHTS_NAME,
																	    SCHEDULER_CONFIG_NAME,
																	    CONFIG_NAME,
																	    ONNX_WEIGHTS_NAME,
																	    DiffusionPipeline.config_name,
																	]
																	__magic_name__ 		=			config_dict.get('_class_name'     )
																	__magic_name__ 		=			{'diffusers': __version__, 'pipeline_class': requested_pipeline_class}

																	__magic_name__ 		=			(
																	    pretrained_model_name_or_path
																	    if os.path.isdir(_lowerCAmelCase     )
																	    else snapshot_download(
																	        _lowerCAmelCase  ,			cache_dir=_lowerCAmelCase  ,			resume_download=_lowerCAmelCase  ,			proxies=_lowerCAmelCase  ,			local_files_only=_lowerCAmelCase  ,			use_auth_token=_lowerCAmelCase  ,			revision=_lowerCAmelCase  ,			allow_patterns=_lowerCAmelCase  ,			user_agent=_lowerCAmelCase  ,			)
																	)
																	print('Cached Folder'  ,			_lowerCAmelCase     )
																	cached_folders.append(_lowerCAmelCase     )

											# Step 3:-
											# Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
											__magic_name__ 		=			DiffusionPipeline.from_pretrained(
											    cached_folders[0]  ,			torch_dtype=_lowerCAmelCase  ,			device_map=_lowerCAmelCase     )
											final_pipe.to(self.device     )

											__magic_name__ 		=			None
											if len(_lowerCAmelCase     ) > 2:
																	__magic_name__ 		=			os.path.join(cached_folders[2]     )

											if interp == "sigmoid":
																	__magic_name__ 		=			CheckpointMergerPipeline.sigmoid
											elif interp == "inv_sigmoid":
																	__magic_name__ 		=			CheckpointMergerPipeline.inv_sigmoid
											elif interp == "add_diff":
																	__magic_name__ 		=			CheckpointMergerPipeline.add_difference
											else:
																	__magic_name__ 		=			CheckpointMergerPipeline.weighted_sum

											# Find each module's state dict.
											for attr in final_pipe.config.keys():
																	if not attr.startswith('_'     ):
																							__magic_name__ 		=			os.path.join(cached_folders[1]  ,			_lowerCAmelCase     )
																							if os.path.exists(_lowerCAmelCase     ):
																													__magic_name__ 		=			[
																													    *glob.glob(os.path.join(_lowerCAmelCase  ,			'*.safetensors'     )     ),
																													    *glob.glob(os.path.join(_lowerCAmelCase  ,			'*.bin'     )     ),
																													]
																													__magic_name__ 		=			files[0] if len(_lowerCAmelCase     ) > 0 else None
																							if len(_lowerCAmelCase     ) < 3:
																													__magic_name__ 		=			None
																							else:
																													__magic_name__ 		=			os.path.join(cached_folders[2]  ,			_lowerCAmelCase     )
																													if os.path.exists(_lowerCAmelCase     ):
																																			__magic_name__ 		=			[
																																			    *glob.glob(os.path.join(_lowerCAmelCase  ,			'*.safetensors'     )     ),
																																			    *glob.glob(os.path.join(_lowerCAmelCase  ,			'*.bin'     )     ),
																																			]
																																			__magic_name__ 		=			files[0] if len(_lowerCAmelCase     ) > 0 else None
                # For an attr if both checkpoint_path_1 and 2 are None, ignore.
                # If atleast one is present, deal with it according to interp method, of course only if the state_dict keys match.
																							if checkpoint_path_a is None and checkpoint_path_a is None:
																													print(F'''Skipping {attr}: not present in 2nd or 3d model'''     )
																													continue
																							try:
																													__magic_name__ 		=			getattr(_lowerCAmelCase  ,			_lowerCAmelCase     )
																													if isinstance(_lowerCAmelCase  ,			_lowerCAmelCase     ):  # ignore requires_safety_checker boolean
																																			continue
																													__magic_name__ 		=			getattr(_lowerCAmelCase  ,			'state_dict'     )
																													__magic_name__ 		=			theta_a()

																													__magic_name__ 		=			getattr(_lowerCAmelCase  ,			'load_state_dict'     )
																													__magic_name__ 		=			(
																													    safetensors.torch.load_file(_lowerCAmelCase     )
																													    if (is_safetensors_available() and checkpoint_path_a.endswith('.safetensors'     ))
																													    else torch.load(_lowerCAmelCase  ,			map_location='cpu'     )
																													)
																													__magic_name__ 		=			None
																													if checkpoint_path_a:
																																			__magic_name__ 		=			(
																																			    safetensors.torch.load_file(_lowerCAmelCase     )
																																			    if (is_safetensors_available() and checkpoint_path_a.endswith('.safetensors'     ))
																																			    else torch.load(_lowerCAmelCase  ,			map_location='cpu'     )
																																			)

																													if not theta_a.keys() == theta_a.keys():
																																			print(F'''Skipping {attr}: key mismatch'''     )
																																			continue
																													if theta_a and not theta_a.keys() == theta_a.keys():
																																			print(F'''Skipping {attr}:y mismatch'''     )
																							except Exception as e:
																													print(F'''Skipping {attr} do to an unexpected error: {str(_lowerCAmelCase     )}'''     )
																													continue
																							print(F'''MERGING {attr}'''     )

																							for key in theta_a.keys():
																													if theta_a:
																																			__magic_name__ 		=			theta_func(theta_a[key]  ,			theta_a[key]  ,			theta_a[key]  ,			_lowerCAmelCase     )
																													else:
																																			__magic_name__ 		=			theta_func(theta_a[key]  ,			theta_a[key]  ,			_lowerCAmelCase  ,			_lowerCAmelCase     )

																							del theta_a
																							del theta_a
																							update_theta_a(_lowerCAmelCase     )

																							del theta_a
											return final_pipe
					@staticmethod
					def   a (	_lowerCAmelCase					:	Union[str, Any]  ,			_lowerCAmelCase					:	Optional[int]  ,			_lowerCAmelCase					:	Optional[Any]  ,			_lowerCAmelCase					:	Dict     )       ->				Union[str, Any]:



											'''simple docstring'''





											return ((1 - alpha) * thetaa) + (alpha * thetaa)
					@staticmethod
					def   a (	_lowerCAmelCase					:	str  ,			_lowerCAmelCase					:	Dict  ,			_lowerCAmelCase					:	Optional[int]  ,			_lowerCAmelCase					:	Optional[int]     )       ->				Any:



											'''simple docstring'''





											__magic_name__ 		=			alpha * alpha * (3 - (2 * alpha))
											return thetaa + ((thetaa - thetaa) * alpha)
					@staticmethod
					def   a (	_lowerCAmelCase					:	Optional[int]  ,			_lowerCAmelCase					:	int  ,			_lowerCAmelCase					:	Tuple  ,			_lowerCAmelCase					:	int     )       ->				Any:



											'''simple docstring'''





											import math

											__magic_name__ 		=			0.5 - math.sin(math.asin(1.0 - 2.0 * alpha     ) / 3.0     )
											return thetaa + ((thetaa - thetaa) * alpha)







					@staticmethod
					def   a (	_lowerCAmelCase					:	Optional[Any]  ,			_lowerCAmelCase					:	Optional[Any]  ,			_lowerCAmelCase					:	Optional[Any]  ,			_lowerCAmelCase					:	List[Any]     )       ->				Optional[Any]:



											'''simple docstring'''





											return thetaa + (thetaa - thetaa) * (1.0 - alpha)





import argparse
import os

import evaluate
import torch
from datasets import load_dataset
from torch.optim import AdamW
from torch.utils.data import DataLoader
from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed

from accelerate import Accelerator, DistributedType


########################################################################
# This is a fully working simple example to use Accelerate
#
# This example trains a Bert base model on GLUE MRPC
# in any of the following settings (with the same script):
#   - single CPU or single GPU
#   - multi GPUS (using PyTorch distributed mode)
#   - (multi) TPUs
#   - fp16 (mixed-precision) or fp32 (normal precision)
#
# This example also demonstrates the checkpointing and sharding capabilities
#
# To run it in each of these various modes, follow the instructions
# in the readme for examples:
# https://github.com/huggingface/accelerate/tree/main/examples
#
########################################################################


UpperCamelCase :				List[Any]						    =       16
UpperCamelCase :				Dict						    =       32
def 							UpperCamelCase_  (				__snake_case			:						Any	,			__snake_case			:						Tuple     )->      List[Any]:




						'''simple docstring'''
						# Initialize accelerator
						if args.with_tracking:
												__magic_name__ 		=			Accelerator(
												    cpu=args.cpu	,			mixed_precision=args.mixed_precision	,			log_with='all'	,			project_dir=args.project_dir     )
						else:
												__magic_name__ 		=			Accelerator(cpu=args.cpu	,			mixed_precision=args.mixed_precision     )

						if hasattr(args.checkpointing_steps	,			'isdigit'     ):
												if args.checkpointing_steps == "epoch":
																		__magic_name__ 		=			args.checkpointing_steps
												elif args.checkpointing_steps.isdigit():
																		__magic_name__ 		=			int(args.checkpointing_steps     )
												else:
																		raise ValueError(
																		    F'''Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.'''     )
						else:
												__magic_name__ 		=			None
						# Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
						__magic_name__ 		=			config['lr']
						__magic_name__ 		=			int(config['num_epochs']     )
						__magic_name__ 		=			int(config['seed']     )
						__magic_name__ 		=			int(config['batch_size']     )

						# We need to initialize the trackers we use, and also store our configuration
						if args.with_tracking:
												__magic_name__ 		=			os.path.split(__snake_case     )[-1].split('.'     )[0]
												accelerator.init_trackers(__snake_case	,			__snake_case     )

						__magic_name__ 		=			AutoTokenizer.from_pretrained('bert-base-cased'     )
						__magic_name__ 		=			load_dataset('glue'	,			'mrpc'     )
						__magic_name__ 		=			evaluate.load('glue'	,			'mrpc'     )

						def tokenize_function(__snake_case			:						Dict     ):
												# max_length=None => use the model max length (it's actually the default)
												__magic_name__ 		=			tokenizer(examples['sentence1']	,			examples['sentence2']	,			truncation=__snake_case	,			max_length=__snake_case     )
												return outputs

						# Apply the method we just defined to all the examples in all the splits of the dataset
						# starting with the main process first:
						with accelerator.main_process_first():
												__magic_name__ 		=			datasets.map(
												    __snake_case	,			batched=__snake_case	,			remove_columns=['idx', 'sentence1', 'sentence2']	,			)

						# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
						# transformers library
						__magic_name__ 		=			tokenized_datasets.rename_column('label'	,			'labels'     )

						# If the batch size is too big we use gradient accumulation
						__magic_name__ 		=			1
						if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU:
												__magic_name__ 		=			batch_size // MAX_GPU_BATCH_SIZE
												__magic_name__ 		=			MAX_GPU_BATCH_SIZE

						def collate_fn(__snake_case			:						Tuple     ):
												# On TPU it's best to pad everything to the same length or training will be very slow.
												__magic_name__ 		=			1_28 if accelerator.distributed_type == DistributedType.TPU else None
												# When using mixed precision we want round multiples of 8/16
												if accelerator.mixed_precision == "fp8":
																		__magic_name__ 		=			16
												elif accelerator.mixed_precision != "no":
																		__magic_name__ 		=			8
												else:
																		__magic_name__ 		=			None

												return tokenizer.pad(
												    __snake_case	,			padding='longest'	,			max_length=__snake_case	,			pad_to_multiple_of=__snake_case	,			return_tensors='pt'	,			)

						# Instantiate dataloaders.
						__magic_name__ 		=			DataLoader(
						    tokenized_datasets['train']	,			shuffle=__snake_case	,			collate_fn=__snake_case	,			batch_size=__snake_case     )
						__magic_name__ 		=			DataLoader(
						    tokenized_datasets['validation']	,			shuffle=__snake_case	,			collate_fn=__snake_case	,			batch_size=__snake_case     )

						set_seed(__snake_case     )

						# Instantiate the model (we build the model here so that the seed also control new weights initialization)
						__magic_name__ 		=			AutoModelForSequenceClassification.from_pretrained('bert-base-cased'	,			return_dict=__snake_case     )

						# We could avoid this line since the accelerator is set with `device_placement=True` (default value).
						# Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer
						# creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).
						__magic_name__ 		=			model.to(accelerator.device     )

						# Instantiate optimizer
						__magic_name__ 		=			AdamW(params=model.parameters()	,			lr=__snake_case     )

						# Instantiate scheduler
						__magic_name__ 		=			get_linear_schedule_with_warmup(
						    optimizer=__snake_case	,			num_warmup_steps=1_00	,			num_training_steps=(len(__snake_case     ) * num_epochs) // gradient_accumulation_steps	,			)

						# Prepare everything
						# There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
						# prepare method.
						__magic_name__		,			__magic_name__		,			__magic_name__		,			__magic_name__		,			__magic_name__ 		=			accelerator.prepare(
						    __snake_case	,			__snake_case	,			__snake_case	,			__snake_case	,			__snake_case     )

						# We need to keep track of how many total steps we have iterated over
						__magic_name__ 		=			0
						# We also need to keep track of the stating epoch so files are named properly
						__magic_name__ 		=			0

						# Potentially load in the weights and states from a previous save
						if args.resume_from_checkpoint:
												if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
																		accelerator.print(F'''Resumed from checkpoint: {args.resume_from_checkpoint}'''     )
																		accelerator.load_state(args.resume_from_checkpoint     )
																		__magic_name__ 		=			os.path.basename(args.resume_from_checkpoint     )
												else:
																		# Get the most recent checkpoint
																		__magic_name__ 		=			[f.name for f in os.scandir(os.getcwd()     ) if f.is_dir()]
																		dirs.sort(key=os.path.getctime     )
																		__magic_name__ 		=			dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
												# Extract `epoch_{i}` or `step_{i}`
												__magic_name__ 		=			os.path.splitext(__snake_case     )[0]

												if "epoch" in training_difference:
																		__magic_name__ 		=			int(training_difference.replace('epoch_'	,			''     )     ) + 1
																		__magic_name__ 		=			None
												else:
																		__magic_name__ 		=			int(training_difference.replace('step_'	,			''     )     )
																		__magic_name__ 		=			resume_step // len(__snake_case     )
																		resume_step -= starting_epoch * len(__snake_case     )

    # Now we train the model
						for epoch in range(__snake_case	,			__snake_case     ):
												model.train()
												if args.with_tracking:
																		__magic_name__ 		=			0
												if args.resume_from_checkpoint and epoch == starting_epoch and resume_step is not None:
																		# We need to skip steps until we reach the resumed step
																		__magic_name__ 		=			accelerator.skip_first_batches(__snake_case	,			__snake_case     )
																		overall_step += resume_step
												else:
																		# After the first iteration though, we need to go back to the original dataloader
																		__magic_name__ 		=			train_dataloader
												for step, batch in enumerate(__snake_case     ):
																		# We could avoid this line since we set the accelerator with `device_placement=True`.
																		batch.to(accelerator.device     )
																		__magic_name__ 		=			model(**__snake_case     )
																		__magic_name__ 		=			outputs.loss
																		__magic_name__ 		=			loss / gradient_accumulation_steps
																		# We keep track of the loss at each epoch
																		if args.with_tracking:
																								total_loss += loss.detach().float()
																		accelerator.backward(__snake_case     )
																		if step % gradient_accumulation_steps == 0:
																								optimizer.step()
																								lr_scheduler.step()
																								optimizer.zero_grad()

																		overall_step += 1

																		if isinstance(__snake_case	,			__snake_case     ):
																								__magic_name__ 		=			F'''step_{overall_step}'''
																								if overall_step % checkpointing_steps == 0:
																														if args.output_dir is not None:
																																				__magic_name__ 		=			os.path.join(args.output_dir	,			__snake_case     )
																														accelerator.save_state(__snake_case     )

												model.eval()
												for step, batch in enumerate(__snake_case     ):
																		# We could avoid this line since we set the accelerator with `device_placement=True`.
																		batch.to(accelerator.device     )
																		with torch.no_grad():
																								__magic_name__ 		=			model(**__snake_case     )
																		__magic_name__ 		=			outputs.logits.argmax(dim=-1     )
																		__magic_name__		,			__magic_name__ 		=			accelerator.gather_for_metrics((predictions, batch['labels'])     )
																		metric.add_batch(
																		    predictions=__snake_case	,			references=__snake_case	,			)

												__magic_name__ 		=			metric.compute()
												# Use accelerator.print to print only on the main process.
												accelerator.print(F'''epoch {epoch}:'''	,			__snake_case     )
												if args.with_tracking:
																		accelerator.log(
																		    {
																		        'accuracy': eval_metric['accuracy'],
																		        'f1': eval_metric['f1'],
																		        'train_loss': total_loss.item() / len(__snake_case     ),
																		        'epoch': epoch,
																		    }	,			step=__snake_case	,			)

												if checkpointing_steps == "epoch":
																		__magic_name__ 		=			F'''epoch_{epoch}'''
																		if args.output_dir is not None:
																								__magic_name__ 		=			os.path.join(args.output_dir	,			__snake_case     )
																		accelerator.save_state(__snake_case     )

						if args.with_tracking:
												accelerator.end_training()
def 							UpperCamelCase_  (				)->      Dict:




						'''simple docstring'''
						__magic_name__ 		=			argparse.ArgumentParser(description='Simple example of training script.'     )
						parser.add_argument(
						    '--mixed_precision'	,			type=__snake_case	,			default=__snake_case	,			choices=['no', 'fp16', 'bf16', 'fp8']	,			help='Whether to use mixed precision. Choose'
						    'between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.'
						    'and an Nvidia Ampere GPU.'	,			)
						parser.add_argument('--cpu'	,			action='store_true'	,			help='If passed, will train on the CPU.'     )
						parser.add_argument(
						    '--checkpointing_steps'	,			type=__snake_case	,			default=__snake_case	,			help='Whether the various states should be saved at the end of every n steps, or \'epoch\' for each epoch.'	,			)
						parser.add_argument(
						    '--resume_from_checkpoint'	,			type=__snake_case	,			default=__snake_case	,			help='If the training should continue from a checkpoint folder.'	,			)
						parser.add_argument(
						    '--with_tracking'	,			action='store_true'	,			help='Whether to load in all available experiment trackers from the environment and use them for logging.'	,			)
						parser.add_argument(
						    '--output_dir'	,			type=__snake_case	,			default='.'	,			help='Optional save directory where all checkpoint folders will be stored. Default is the current working directory.'	,			)
						parser.add_argument(
						    '--project_dir'	,			type=__snake_case	,			default='logs'	,			help='Location on where to store experiment tracking logs` and relevent project information'	,			)
						__magic_name__ 		=			parser.parse_args()
						__magic_name__ 		=			{'lr': 2E-5, 'num_epochs': 3, 'seed': 42, 'batch_size': 16}
						training_function(__snake_case	,			__snake_case     )


if __name__ == "__main__":
					main()

