



import argparse
import json
import logging
import os
import shutil
import sys
import tempfile
import unittest
from unittest import mock

import torch
from accelerate.utils import write_basic_config

from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device
from transformers.utils import is_apex_available


logging.basicConfig(level=logging.DEBUG)

UpperCAmelCase__       =	logging.getLogger()





def 							A     (					)    ->			Tuple:







			'''simple docstring'''
			_UpperCAmelCase			=       argparse.ArgumentParser()
			parser.add_argument('-f'   )
			_UpperCAmelCase			=       parser.parse_args()
			return args.f





def 							A     (					_UpperCAmelCase    :       Optional[int]   )    ->			List[Any]:







			'''simple docstring'''
			_UpperCAmelCase			=       {}
			_UpperCAmelCase			=       os.path.join(_UpperCAmelCase							,       'all_results.json'   )
			if os.path.exists(_UpperCAmelCase   ):
						with open(_UpperCAmelCase							,       'r'   ) as f:
									_UpperCAmelCase			=       json.load(_UpperCAmelCase   )
			else:
						raise ValueError(F"can\'t find {path}"   )
			return results





def 							A     (					)    ->			Union[str, Any]:







			'''simple docstring'''
			_UpperCAmelCase			=       torch.cuda.is_available() and torch_device == 'cuda'
			return is_using_cuda and is_apex_available()


UpperCAmelCase__       =	logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)







class       __lowerCAmelCase   (      SCREAMING_SNAKE_CASE_						):



			@classmethod
			def    _lowerCamelCase	(						cls       :  Any)       ->   List[str]:



						"""simple docstring"""






						_UpperCAmelCase			=       tempfile.mkdtemp()
						_UpperCAmelCase			=       os.path.join(cls.tmpdir			,		'default_config.yml')
						write_basic_config(save_location=cls.configPath)
						_UpperCAmelCase			=       ['accelerate', 'launch', '--config_file', cls.configPath]



			@classmethod
			def    _lowerCamelCase	(						cls       :  List[str])       ->   List[str]:



						"""simple docstring"""






						shutil.rmtree(cls.tmpdir)



			@mock.patch.dict(os.environ			,		{'WANDB_MODE': 'offline'})
			def    _lowerCamelCase	(						self       :  Any)       ->   Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase			=       self.get_auto_remove_tmp_dir()
						_UpperCAmelCase			=       F"\n            {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py\n            --model_name_or_path distilbert-base-uncased\n            --output_dir {tmp_dir}\n            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv\n            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --learning_rate=1e-4\n            --seed=42\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

						if is_cuda_and_apex_available():
									testargs.append('--fp16')

						run_command(self._launch_args + testargs)
						_UpperCAmelCase			=       get_results(__a)
						self.assertGreaterEqual(result['eval_accuracy']			,		0.7_5)
						self.assertTrue(os.path.exists(os.path.join(__a			,		'epoch_0')))
						self.assertTrue(os.path.exists(os.path.join(__a			,		'glue_no_trainer')))



			@mock.patch.dict(os.environ			,		{'WANDB_MODE': 'offline'})
			def    _lowerCamelCase	(						self       :  List[Any])       ->   Union[str, Any]:



						"""simple docstring"""






						_UpperCAmelCase			=       self.get_auto_remove_tmp_dir()
						_UpperCAmelCase			=       F"\n            {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py\n            --model_name_or_path distilgpt2\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --block_size 128\n            --per_device_train_batch_size 5\n            --per_device_eval_batch_size 5\n            --num_train_epochs 2\n            --output_dir {tmp_dir}\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

						if torch.cuda.device_count() > 1:
									# Skipping because there are not enough batches to train the model + would need a drop_last to work.
									return

						run_command(self._launch_args + testargs)
						_UpperCAmelCase			=       get_results(__a)
						self.assertLess(result['perplexity']			,		1_00)
						self.assertTrue(os.path.exists(os.path.join(__a			,		'epoch_0')))
						self.assertTrue(os.path.exists(os.path.join(__a			,		'clm_no_trainer')))



			@mock.patch.dict(os.environ			,		{'WANDB_MODE': 'offline'})
			def    _lowerCamelCase	(						self       :  str)       ->   List[str]:



						"""simple docstring"""






						_UpperCAmelCase			=       self.get_auto_remove_tmp_dir()
						_UpperCAmelCase			=       F"\n            {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py\n            --model_name_or_path distilroberta-base\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --output_dir {tmp_dir}\n            --num_train_epochs=1\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

						run_command(self._launch_args + testargs)
						_UpperCAmelCase			=       get_results(__a)
						self.assertLess(result['perplexity']			,		42)
						self.assertTrue(os.path.exists(os.path.join(__a			,		'epoch_0')))
						self.assertTrue(os.path.exists(os.path.join(__a			,		'mlm_no_trainer')))



			@mock.patch.dict(os.environ			,		{'WANDB_MODE': 'offline'})
			def    _lowerCamelCase	(						self       :  Optional[int])       ->   Optional[int]:



						"""simple docstring"""






						_UpperCAmelCase			=       7 if get_gpu_count() > 1 else 2

						_UpperCAmelCase			=       self.get_auto_remove_tmp_dir()
						_UpperCAmelCase			=       F"\n            {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/conll/sample.json\n            --validation_file tests/fixtures/tests_samples/conll/sample.json\n            --output_dir {tmp_dir}\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=2\n            --num_train_epochs={epochs}\n            --seed 7\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

						run_command(self._launch_args + testargs)
						_UpperCAmelCase			=       get_results(__a)
						self.assertGreaterEqual(result['eval_accuracy']			,		0.7_5)
						self.assertLess(result['train_loss']			,		0.5)
						self.assertTrue(os.path.exists(os.path.join(__a			,		'epoch_0')))
						self.assertTrue(os.path.exists(os.path.join(__a			,		'ner_no_trainer')))



			@unittest.skip(reason='Fix me @muellerzr')
			@mock.patch.dict(os.environ			,		{'WANDB_MODE': 'offline'})
			def    _lowerCamelCase	(						self       :  Any)       ->   List[Any]:



						"""simple docstring"""






						_UpperCAmelCase			=       self.get_auto_remove_tmp_dir()
						_UpperCAmelCase			=       F"\n            {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --version_2_with_negative\n            --train_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --output_dir {tmp_dir}\n            --seed=42\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

						run_command(self._launch_args + testargs)
						_UpperCAmelCase			=       get_results(__a)
						# Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics.
						self.assertGreaterEqual(result['eval_f1']			,		28)
						self.assertGreaterEqual(result['eval_exact']			,		28)
						self.assertTrue(os.path.exists(os.path.join(__a			,		'epoch_0')))
						self.assertTrue(os.path.exists(os.path.join(__a			,		'qa_no_trainer')))



			@mock.patch.dict(os.environ			,		{'WANDB_MODE': 'offline'})
			def    _lowerCamelCase	(						self       :  Dict)       ->   List[Any]:



						"""simple docstring"""






						_UpperCAmelCase			=       self.get_auto_remove_tmp_dir()
						_UpperCAmelCase			=       F"\n            {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/swag/sample.json\n            --validation_file tests/fixtures/tests_samples/swag/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=20\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --with_tracking\n        ".split()

						run_command(self._launch_args + testargs)
						_UpperCAmelCase			=       get_results(__a)
						self.assertGreaterEqual(result['eval_accuracy']			,		0.8)
						self.assertTrue(os.path.exists(os.path.join(__a			,		'swag_no_trainer')))



			@slow
			@mock.patch.dict(os.environ			,		{'WANDB_MODE': 'offline'})
			def    _lowerCamelCase	(						self       :  Any)       ->   Union[str, Any]:



						"""simple docstring"""






						_UpperCAmelCase			=       self.get_auto_remove_tmp_dir()
						_UpperCAmelCase			=       F"\n            {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py\n            --model_name_or_path t5-small\n            --train_file tests/fixtures/tests_samples/xsum/sample.json\n            --validation_file tests/fixtures/tests_samples/xsum/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

						run_command(self._launch_args + testargs)
						_UpperCAmelCase			=       get_results(__a)
						self.assertGreaterEqual(result['eval_rouge1']			,		10)
						self.assertGreaterEqual(result['eval_rouge2']			,		2)
						self.assertGreaterEqual(result['eval_rougeL']			,		7)
						self.assertGreaterEqual(result['eval_rougeLsum']			,		7)
						self.assertTrue(os.path.exists(os.path.join(__a			,		'epoch_0')))
						self.assertTrue(os.path.exists(os.path.join(__a			,		'summarization_no_trainer')))



			@slow
			@mock.patch.dict(os.environ			,		{'WANDB_MODE': 'offline'})
			def    _lowerCamelCase	(						self       :  Union[str, Any])       ->   int:



						"""simple docstring"""






						_UpperCAmelCase			=       self.get_auto_remove_tmp_dir()
						_UpperCAmelCase			=       F"\n            {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py\n            --model_name_or_path sshleifer/student_marian_en_ro_6_1\n            --source_lang en\n            --target_lang ro\n            --train_file tests/fixtures/tests_samples/wmt16/sample.json\n            --validation_file tests/fixtures/tests_samples/wmt16/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --num_beams=6\n            --learning_rate=3e-3\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --source_lang en_XX\n            --target_lang ro_RO\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

						run_command(self._launch_args + testargs)
						_UpperCAmelCase			=       get_results(__a)
						self.assertGreaterEqual(result['eval_bleu']			,		30)
						self.assertTrue(os.path.exists(os.path.join(__a			,		'epoch_0')))
						self.assertTrue(os.path.exists(os.path.join(__a			,		'translation_no_trainer')))



			@slow
			def    _lowerCamelCase	(						self       :  Optional[Any])       ->   Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase			=       logging.StreamHandler(sys.stdout)
						logger.addHandler(__a)

						_UpperCAmelCase			=       self.get_auto_remove_tmp_dir()
						_UpperCAmelCase			=       F"\n            {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py\n            --dataset_name huggingface/semantic-segmentation-test-sample\n            --output_dir {tmp_dir}\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n        ".split()

						run_command(self._launch_args + testargs)
						_UpperCAmelCase			=       get_results(__a)
						self.assertGreaterEqual(result['eval_overall_accuracy']			,		0.1_0)



			@mock.patch.dict(os.environ			,		{'WANDB_MODE': 'offline'})
			def    _lowerCamelCase	(						self       :  Tuple)       ->   Any:



						"""simple docstring"""






						_UpperCAmelCase			=       self.get_auto_remove_tmp_dir()
						_UpperCAmelCase			=       F"\n            {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py\n            --model_name_or_path google/vit-base-patch16-224-in21k\n            --dataset_name hf-internal-testing/cats_vs_dogs_sample\n            --learning_rate 1e-4\n            --per_device_train_batch_size 2\n            --per_device_eval_batch_size 1\n            --max_train_steps 2\n            --train_val_split 0.1\n            --seed 42\n            --output_dir {tmp_dir}\n            --with_tracking\n            --checkpointing_steps 1\n        ".split()

						if is_cuda_and_apex_available():
									testargs.append('--fp16')

						run_command(self._launch_args + testargs)
						_UpperCAmelCase			=       get_results(__a)
						# The base model scores a 25%
						self.assertGreaterEqual(result['eval_accuracy']			,		0.6)
						self.assertTrue(os.path.exists(os.path.join(__a			,		'step_1')))
						self.assertTrue(os.path.exists(os.path.join(__a			,		'image_classification_no_trainer')))






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


UpperCAmelCase__       =	{
    "configuration_mega": ["MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP", "MegaConfig", "MegaOnnxConfig"],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__       =	[
							    "MEGA_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "MegaForCausalLM",
							    "MegaForMaskedLM",
							    "MegaForMultipleChoice",
							    "MegaForQuestionAnswering",
							    "MegaForSequenceClassification",
							    "MegaForTokenClassification",
							    "MegaModel",
							    "MegaPreTrainedModel",
							]

if TYPE_CHECKING:
							from .configuration_mega import MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP, MegaConfig, MegaOnnxConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_mega import (
														    MEGA_PRETRAINED_MODEL_ARCHIVE_LIST,
														    MegaForCausalLM,
														    MegaForMaskedLM,
														    MegaForMultipleChoice,
														    MegaForQuestionAnswering,
														    MegaForSequenceClassification,
														    MegaForTokenClassification,
														    MegaModel,
														    MegaPreTrainedModel,
														)

else:
							import sys

							UpperCAmelCase__       =	_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
