import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Optional

import evaluate
import numpy as np
import torch
from datasets import load_dataset
from PIL import Image
from torchvision.transforms import (
    CenterCrop,
    Compose,
    Normalize,
    RandomHorizontalFlip,
    RandomResizedCrop,
    Resize,
    ToTensor,
)

import transformers
from transformers import (
    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    AutoModelForImageClassification,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import get_last_checkpoint
from transformers.utils import check_min_version, send_example_telemetry
from transformers.utils.versions import require_version
lowercase_     :   Optional[int] 				=				logging.getLogger(__name__)

# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
check_min_version('4.31.0')

require_version('datasets>=1.8.0', 'To fix: pip install -r examples/pytorch/image-classification/requirements.txt')

lowercase_     :   Any 				=				list(MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING.keys())
lowercase_     :   Union[str, Any] 				=				tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)







def 			A__      (	snake_case_ :		str      ):
 with open(snake_case_       ,				'''rb'''      ) as f:
  SCREAMING_SNAKE_CASE__:   List[Any]=      Image.open(snake_case_      )
  return im.convert('''RGB'''      )






@dataclass
class 		_lowerCamelCase		:
    __a  =      field(
        default=UpperCamelCase_    ,     metadata={
            "help": "Name of a dataset from the hub (could be your own, possibly private dataset hosted on the hub)."
        }    ,     )
    __a  =      field(
        default=UpperCamelCase_    ,     metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}    )
    __a  =      field(default=UpperCamelCase_    ,     metadata={"help": "A folder containing the training data."}    )
    __a  =      field(default=UpperCamelCase_    ,     metadata={"help": "A folder containing the validation data."}    )
    __a  =      field(
        default=0.15    ,     metadata={"help": "Percent to split off of train for validation."}    )
    __a  =      field(
        default=UpperCamelCase_    ,     metadata={
            "help": (
                "For debugging purposes or quicker training, truncate the number of training examples to this "
                "value if set."
            )
        }    ,     )
    __a  =      field(
        default=UpperCamelCase_    ,     metadata={
            "help": (
                "For debugging purposes or quicker training, truncate the number of evaluation examples to this "
                "value if set."
            )
        }    ,     )
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     if self.dataset_name is None and (self.train_dir is None and self.validation_dir is None):
      raise ValueError(
          '''You must specify either a dataset name from the hub or a train and/or validation directory.'''   )






@dataclass
class 		_lowerCamelCase		:
    __a  =      field(
        default="google/vit-base-patch16-224-in21k"    ,     metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}    ,     )
    __a  =      field(
        default=UpperCamelCase_    ,     metadata={"help": "If training from scratch, pass a model type from the list: " + ", ".join(UpperCamelCase_    )}    ,     )
    __a  =      field(
        default=UpperCamelCase_    ,     metadata={"help": "Pretrained config name or path if not the same as model_name"}    )
    __a  =      field(
        default=UpperCamelCase_    ,     metadata={"help": "Where do you want to store the pretrained models downloaded from s3"}    )
    __a  =      field(
        default="main"    ,     metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."}    ,     )
    __a  =      field(default=UpperCamelCase_    ,     metadata={"help": "Name or path of preprocessor config."}    )
    __a  =      field(
        default=UpperCamelCase_    ,     metadata={
            "help": (
                "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
                "with private models)."
            )
        }    ,     )
    __a  =      field(
        default=UpperCamelCase_    ,     metadata={"help": "Will enable to load a pretrained model whose head dimensions are different."}    ,     )







def 			A__      (	snake_case_ :		Any      ):
 SCREAMING_SNAKE_CASE__:   List[str]=      torch.stack([example['''pixel_values'''] for example in examples]      )
 SCREAMING_SNAKE_CASE__:   List[Any]=      torch.tensor([example['''labels'''] for example in examples]      )
 return {"pixel_values": pixel_values, "labels": labels}







def 			A__      (	):
 # See all possible arguments in src/transformers/training_args.py
 # or by passing the --help flag to this script.
 # We now keep distinct sets of args, for a cleaner separation of concerns.

 SCREAMING_SNAKE_CASE__:   Tuple=      HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)      )
 if len(sys.argv      ) == 2 and sys.argv[1].endswith('''.json'''      ):
  # If we pass only one argument to the script and it's the path to a json file,
  # let's parse it to get our arguments.
  SCREAMING_SNAKE_CASE__,	SCREAMING_SNAKE_CASE__,	SCREAMING_SNAKE_CASE__:   Optional[int]=      parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]      )      )
 else:
  SCREAMING_SNAKE_CASE__,	SCREAMING_SNAKE_CASE__,	SCREAMING_SNAKE_CASE__:   Optional[int]=      parser.parse_args_into_dataclasses()

 # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
 # information sent is the one passed as arguments along with your Python/PyTorch versions.
 send_example_telemetry('''run_image_classification'''       ,				snake_case_       ,				snake_case_      )

 # Setup logging
 logging.basicConfig(
     format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s'''       ,				datefmt='''%m/%d/%Y %H:%M:%S'''       ,				handlers=[logging.StreamHandler(sys.stdout      )]       ,				)

 if training_args.should_log:
  # The default of training_args.log_level is passive, so we set log level at info here to have that default.
  transformers.utils.logging.set_verbosity_info()

 SCREAMING_SNAKE_CASE__:   Tuple=      training_args.get_process_log_level()
 logger.setLevel(snake_case_      )
 transformers.utils.logging.set_verbosity(snake_case_      )
 transformers.utils.logging.enable_default_handler()
 transformers.utils.logging.enable_explicit_format()

 # Log on each process the small summary:
 logger.warning(
     F'Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}'
     + F'distributed training: {bool(training_args.local_rank != -1      )}, 16-bits training: {training_args.fpaa}'      )
 logger.info(F'Training/evaluation parameters {training_args}'      )

 # Detecting last checkpoint.
 SCREAMING_SNAKE_CASE__:   int=      None
 if os.path.isdir(training_args.output_dir      ) and training_args.do_train and not training_args.overwrite_output_dir:
  SCREAMING_SNAKE_CASE__:   int=      get_last_checkpoint(training_args.output_dir      )
  if last_checkpoint is None and len(os.listdir(training_args.output_dir      )      ) > 0:
   raise ValueError(
       F'Output directory ({training_args.output_dir}) already exists and is not empty. '
       '''Use --overwrite_output_dir to overcome.'''      )
  elif last_checkpoint is not None and training_args.resume_from_checkpoint is None:
   logger.info(
       F'Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change '
       '''the `--output_dir` or add `--overwrite_output_dir` to train from scratch.'''      )

    # Set seed before initializing model.
 set_seed(training_args.seed      )

 # Initialize our dataset and prepare it for the 'image-classification' task.
 if data_args.dataset_name is not None:
  SCREAMING_SNAKE_CASE__:   List[str]=      load_dataset(
      data_args.dataset_name       ,				data_args.dataset_config_name       ,				cache_dir=model_args.cache_dir       ,				task='''image-classification'''       ,				use_auth_token=True if model_args.use_auth_token else None       ,				)
 else:
  SCREAMING_SNAKE_CASE__:   Any=      {}
  if data_args.train_dir is not None:
   SCREAMING_SNAKE_CASE__:   str=      os.path.join(data_args.train_dir       ,				'''**'''      )
  if data_args.validation_dir is not None:
   SCREAMING_SNAKE_CASE__:   Tuple=      os.path.join(data_args.validation_dir       ,				'''**'''      )
  SCREAMING_SNAKE_CASE__:   int=      load_dataset(
      '''imagefolder'''       ,				data_files=snake_case_       ,				cache_dir=model_args.cache_dir       ,				task='''image-classification'''       ,				)

 # If we don't have a validation split, split off a percentage of train as validation.
 SCREAMING_SNAKE_CASE__:   Tuple=      None if '''validation''' in dataset.keys() else data_args.train_val_split
 if isinstance(data_args.train_val_split       ,				snake_case_      ) and data_args.train_val_split > 0.0:
  SCREAMING_SNAKE_CASE__:   Optional[int]=      dataset['''train'''].train_test_split(data_args.train_val_split      )
  SCREAMING_SNAKE_CASE__:   List[Any]=      split['''train''']
  SCREAMING_SNAKE_CASE__:   List[Any]=      split['''test''']

 # Prepare label mappings.
 # We'll include these in the model's config to get human readable labels in the Inference API.
 SCREAMING_SNAKE_CASE__:   int=      dataset['''train'''].features['''labels'''].names
 SCREAMING_SNAKE_CASE__,	SCREAMING_SNAKE_CASE__:   List[str]=      {}, {}
 for i, label in enumerate(snake_case_      ):
  SCREAMING_SNAKE_CASE__:   Optional[Any]=      str(snake_case_      )
  SCREAMING_SNAKE_CASE__:   Optional[int]=      label

 # Load the accuracy metric from the datasets package
 SCREAMING_SNAKE_CASE__:   List[Any]=      evaluate.load('''accuracy'''      )

 # Define our compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a
 # predictions and label_ids field) and has to return a dictionary string to float.
 def compute_metrics(snake_case_ :		Tuple      ):
  return metric.compute(predictions=np.argmax(p.predictions       ,				axis=1      )       ,				references=p.label_ids      )

 SCREAMING_SNAKE_CASE__:   int=      AutoConfig.from_pretrained(
     model_args.config_name or model_args.model_name_or_path       ,				num_labels=len(snake_case_      )       ,				labelaid=snake_case_       ,				idalabel=snake_case_       ,				finetuning_task='''image-classification'''       ,				cache_dir=model_args.cache_dir       ,				revision=model_args.model_revision       ,				use_auth_token=True if model_args.use_auth_token else None       ,				)
 SCREAMING_SNAKE_CASE__:   int=      AutoModelForImageClassification.from_pretrained(
     model_args.model_name_or_path       ,				from_tf=bool('''.ckpt''' in model_args.model_name_or_path      )       ,				config=snake_case_       ,				cache_dir=model_args.cache_dir       ,				revision=model_args.model_revision       ,				use_auth_token=True if model_args.use_auth_token else None       ,				ignore_mismatched_sizes=model_args.ignore_mismatched_sizes       ,				)
 SCREAMING_SNAKE_CASE__:   Optional[int]=      AutoImageProcessor.from_pretrained(
     model_args.image_processor_name or model_args.model_name_or_path       ,				cache_dir=model_args.cache_dir       ,				revision=model_args.model_revision       ,				use_auth_token=True if model_args.use_auth_token else None       ,				)

 # Define torchvision transforms to be applied to each image.
 if "shortest_edge" in image_processor.size:
  SCREAMING_SNAKE_CASE__:   Optional[Any]=      image_processor.size['''shortest_edge''']
 else:
  SCREAMING_SNAKE_CASE__:   Optional[Any]=      (image_processor.size['''height'''], image_processor.size['''width'''])
 SCREAMING_SNAKE_CASE__:   int=      Normalize(mean=image_processor.image_mean       ,				std=image_processor.image_std      )
 SCREAMING_SNAKE_CASE__:   Tuple=      Compose(
     [
         RandomResizedCrop(snake_case_      ),
         RandomHorizontalFlip(),
         ToTensor(),
         normalize,
     ]      )
 SCREAMING_SNAKE_CASE__:   Union[str, Any]=      Compose(
     [
         Resize(snake_case_      ),
         CenterCrop(snake_case_      ),
         ToTensor(),
         normalize,
     ]      )

 def train_transforms(snake_case_ :		Any      ):
  SCREAMING_SNAKE_CASE__:   Any=      [
      _train_transforms(pil_img.convert('''RGB'''      )      ) for pil_img in example_batch['''image''']
  ]
  return example_batch

 def val_transforms(snake_case_ :		int      ):
  SCREAMING_SNAKE_CASE__:   int=      [_val_transforms(pil_img.convert('''RGB'''      )      ) for pil_img in example_batch['''image''']]
  return example_batch

 if training_args.do_train:
  if "train" not in dataset:
   raise ValueError('''--do_train requires a train dataset'''      )
  if data_args.max_train_samples is not None:
   SCREAMING_SNAKE_CASE__:   Optional[Any]=      (
       dataset['''train'''].shuffle(seed=training_args.seed      ).select(range(data_args.max_train_samples      )      )
   )
  # Set the training transforms
  dataset["train"].set_transform(snake_case_      )

 if training_args.do_eval:
  if "validation" not in dataset:
   raise ValueError('''--do_eval requires a validation dataset'''      )
  if data_args.max_eval_samples is not None:
   SCREAMING_SNAKE_CASE__:   List[str]=      (
       dataset['''validation'''].shuffle(seed=training_args.seed      ).select(range(data_args.max_eval_samples      )      )
   )
  # Set the validation transforms
  dataset["validation"].set_transform(snake_case_      )

 # Initalize our trainer
 SCREAMING_SNAKE_CASE__:   Optional[Any]=      Trainer(
     model=snake_case_       ,				args=snake_case_       ,				train_dataset=dataset['''train'''] if training_args.do_train else None       ,				eval_dataset=dataset['''validation'''] if training_args.do_eval else None       ,				compute_metrics=snake_case_       ,				tokenizer=snake_case_       ,				data_collator=snake_case_       ,				)

 # Training
 if training_args.do_train:
  SCREAMING_SNAKE_CASE__:   List[str]=      None
  if training_args.resume_from_checkpoint is not None:
   SCREAMING_SNAKE_CASE__:   str=      training_args.resume_from_checkpoint
  elif last_checkpoint is not None:
   SCREAMING_SNAKE_CASE__:   List[Any]=      last_checkpoint
  SCREAMING_SNAKE_CASE__:   str=      trainer.train(resume_from_checkpoint=snake_case_      )
  trainer.save_model()
  trainer.log_metrics('''train'''       ,				train_result.metrics      )
  trainer.save_metrics('''train'''       ,				train_result.metrics      )
  trainer.save_state()

 # Evaluation
 if training_args.do_eval:
  SCREAMING_SNAKE_CASE__:   Optional[int]=      trainer.evaluate()
  trainer.log_metrics('''eval'''       ,				snake_case_      )
  trainer.save_metrics('''eval'''       ,				snake_case_      )

 # Write model card and (optionally) push to hub
 SCREAMING_SNAKE_CASE__:   List[Any]=      {
     '''finetuned_from''': model_args.model_name_or_path,
     '''tasks''': '''image-classification''',
     '''dataset''': data_args.dataset_name,
     '''tags''': ['''image-classification''', '''vision'''],
 }
 if training_args.push_to_hub:
  trainer.push_to_hub(**snake_case_      )
 else:
  trainer.create_model_card(**snake_case_      )


if __name__ == "__main__":
      main()


import ast
import os
import re
import shutil
import tempfile
import unittest
from unittest import mock

import torch

from accelerate.test_utils.examples import compare_against_test
from accelerate.test_utils.testing import TempDirTestCase, require_trackers, run_command, slow
from accelerate.utils import write_basic_config


# DataLoaders built from `test_samples/MRPC` for quick testing
# Should mock `{script_name}.get_dataloaders` via:
# @mock.patch("{script_name}.get_dataloaders", mocked_dataloaders)

lowercase_     :   Optional[Any] 				=				[
    'cross_validation.py',
    'gradient_accumulation.py',
    'local_sgd.py',
    'multi_process_metrics.py',
    'memory.py',
    'automatic_gradient_accumulation.py',
    'fsdp_with_peak_mem_tracking.py',
    'deepspeed_with_config_support.py',
    'megatron_lm_gpt_pretraining.py',
]






class 		_lowerCamelCase		(   unittest.TestCase    ):
    def 						UpperCamelCase_				(  self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase = None , lowerCAmelCase = None   )       ->					int:
     SCREAMING_SNAKE_CASE__:   Optional[int]=      None
     SCREAMING_SNAKE_CASE__:   Dict=      os.path.abspath(os.path.join('''examples''' , '''by_feature'''   )   )
     SCREAMING_SNAKE_CASE__:   List[Any]=      os.path.abspath('''examples'''   )
     for item in os.listdir(lowerCAmelCase   ):
      if item not in EXCLUDE_EXAMPLES:
       SCREAMING_SNAKE_CASE__:   Tuple=      os.path.join(lowerCAmelCase , lowerCAmelCase   )
       if os.path.isfile(lowerCAmelCase   ) and ".py" in item_path:
        with self.subTest(
            tested_script=lowerCAmelCase , feature_script=lowerCAmelCase , tested_section='''main()''' if parser_only else '''training_function()''' , ):
         SCREAMING_SNAKE_CASE__:   List[Any]=      compare_against_test(
             os.path.join(lowerCAmelCase , lowerCAmelCase   ) , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase   )
         SCREAMING_SNAKE_CASE__:   str=      '''\n'''.join(lowerCAmelCase   )
         if special_strings is not None:
          for string in special_strings:
           SCREAMING_SNAKE_CASE__:   Union[str, Any]=      diff.replace(lowerCAmelCase , ''''''   )
         self.assertEqual(lowerCAmelCase , ''''''   )
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     self.one_complete_example('''complete_nlp_example.py''' , lowerCAmelCase   )
     self.one_complete_example('''complete_nlp_example.py''' , lowerCAmelCase   )



    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     SCREAMING_SNAKE_CASE__:   List[Any]=      os.path.abspath(os.path.join('''examples''' , '''cv_example.py'''   )   )
     SCREAMING_SNAKE_CASE__:   Dict=      [
         ''' ''' * 16 + '''{\n\n''',
         ''' ''' * 20 + '''"accuracy": eval_metric["accuracy"],\n\n''',
         ''' ''' * 20 + '''"f1": eval_metric["f1"],\n\n''',
         ''' ''' * 20 + '''"train_loss": total_loss.item() / len(train_dataloader),\n\n''',
         ''' ''' * 20 + '''"epoch": epoch,\n\n''',
         ''' ''' * 16 + '''},\n\n''',
         ''' ''' * 16 + '''step=epoch,\n''',
         ''' ''' * 12,
         ''' ''' * 8 + '''for step, batch in enumerate(active_dataloader):\n''',
     ]
     self.one_complete_example('''complete_cv_example.py''' , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase   )
     self.one_complete_example('''complete_cv_example.py''' , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase   )






@mock.patch.dict(os.environ    ,     {"TESTING_MOCKED_DATALOADERS": "1"}    )
class 		_lowerCamelCase		(   UpperCamelCase_    ):
    __a  =      False
    @classmethod
    def 						UpperCamelCase_				(  cls   )       ->					List[Any]:
     super().setUpClass()
     SCREAMING_SNAKE_CASE__:   List[Any]=      tempfile.mkdtemp()
     SCREAMING_SNAKE_CASE__:   Tuple=      os.path.join(cls._tmpdir , '''default_config.yml'''   )

     write_basic_config(save_location=cls.configPath   )
     SCREAMING_SNAKE_CASE__:   Dict=      ['''accelerate''', '''launch''', '''--config_file''', cls.configPath]
    @classmethod
    def 						UpperCamelCase_				(  cls   )       ->					List[Any]:
     super().tearDownClass()
     shutil.rmtree(cls._tmpdir   )
    def 						UpperCamelCase_				(  self   )       ->					str:
     SCREAMING_SNAKE_CASE__:   Dict=      f'\n        examples/by_feature/checkpointing.py\n        --checkpointing_steps epoch\n        --output_dir {self.tmpdir}\n        '.split()
     run_command(self._launch_args + testargs   )
     self.assertTrue(os.path.exists(os.path.join(self.tmpdir , '''epoch_0'''   )   )   )
    def 						UpperCamelCase_				(  self   )       ->					Dict:
     SCREAMING_SNAKE_CASE__:   List[Any]=      f'\n        examples/by_feature/checkpointing.py\n        --checkpointing_steps 1\n        --output_dir {self.tmpdir}\n        '.split()
     SCREAMING_SNAKE_CASE__:   List[Any]=      run_command(self._launch_args + testargs   )
     self.assertTrue(os.path.exists(os.path.join(self.tmpdir , '''step_2'''   )   )   )
    def 						UpperCamelCase_				(  self   )       ->					Dict:
     SCREAMING_SNAKE_CASE__:   Tuple=      f'\n        examples/by_feature/checkpointing.py\n        --resume_from_checkpoint {os.path.join(self.tmpdir , "epoch_0"   )}\n        '.split()
     SCREAMING_SNAKE_CASE__:   Dict=      run_command(self._launch_args + testargs , return_stdout=lowerCAmelCase   )
     self.assertNotIn('''epoch 0:''' , lowerCAmelCase   )
     self.assertIn('''epoch 1:''' , lowerCAmelCase   )
    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     SCREAMING_SNAKE_CASE__:   Dict=      f'\n        examples/by_feature/checkpointing.py\n        --resume_from_checkpoint {os.path.join(self.tmpdir , "step_2"   )}\n        '.split()
     SCREAMING_SNAKE_CASE__:   Dict=      run_command(self._launch_args + testargs , return_stdout=lowerCAmelCase   )
     if torch.cuda.is_available():
      SCREAMING_SNAKE_CASE__:   List[str]=      torch.cuda.device_count()
     else:
      SCREAMING_SNAKE_CASE__:   List[Any]=      1
     if num_processes > 1:
      self.assertNotIn('''epoch 0:''' , lowerCAmelCase   )
      self.assertIn('''epoch 1:''' , lowerCAmelCase   )
     else:
      self.assertIn('''epoch 0:''' , lowerCAmelCase   )
      self.assertIn('''epoch 1:''' , lowerCAmelCase   )
    @slow
    def 						UpperCamelCase_				(  self   )       ->					str:
     SCREAMING_SNAKE_CASE__:   List[str]=      '''
        examples/by_feature/cross_validation.py
        --num_folds 2
        '''.split()
     with mock.patch.dict(os.environ , {'''TESTING_MOCKED_DATALOADERS''': '''0'''}   ):
      SCREAMING_SNAKE_CASE__:   Any=      run_command(self._launch_args + testargs , return_stdout=lowerCAmelCase   )
      SCREAMING_SNAKE_CASE__:   Dict=      re.findall('''({.+})''' , lowerCAmelCase   )
      SCREAMING_SNAKE_CASE__:   int=      [r for r in results if '''accuracy''' in r][-1]
      SCREAMING_SNAKE_CASE__:   List[str]=      ast.literal_eval(lowerCAmelCase   )
      self.assertGreaterEqual(results['''accuracy'''] , 0.75   )
    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      ['''examples/by_feature/multi_process_metrics.py''']
     run_command(self._launch_args + testargs   )
    @require_trackers
    @mock.patch.dict(os.environ , {'''WANDB_MODE''': '''offline'''}   )
    def 						UpperCamelCase_				(  self   )       ->					int:
     with tempfile.TemporaryDirectory() as tmpdir:
      SCREAMING_SNAKE_CASE__:   Optional[int]=      f'\n            examples/by_feature/tracking.py\n            --with_tracking\n            --project_dir {tmpdir}\n            '.split()
      run_command(self._launch_args + testargs   )
      self.assertTrue(os.path.exists(os.path.join(lowerCAmelCase , '''tracking'''   )   )   )
    def 						UpperCamelCase_				(  self   )       ->					int:
     SCREAMING_SNAKE_CASE__:   int=      ['''examples/by_feature/gradient_accumulation.py''']
     run_command(self._launch_args + testargs   )



    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     SCREAMING_SNAKE_CASE__:   List[str]=      ['''examples/by_feature/local_sgd.py''']
     run_command(self._launch_args + testargs   )

