






import json
import os
import subprocess
import unittest
from ast import literal_eval

import pytest
from parameterized import parameterized_class

from . import is_sagemaker_available


if is_sagemaker_available():
							from sagemaker import Session, TrainingJobAnalytics
							from sagemaker.huggingface import HuggingFace




@pytest.mark.skipif(
    literal_eval(os.getenv('TEST_SAGEMAKER'					,  'False'					)					) is not True					,  reason='Skipping test because should only be run when releasing minor transformers version'					,  )
@pytest.mark.usefixtures('sm_env'					)
@parameterized_class(
    [
        {
            'framework': 'pytorch',
            'script': 'run_glue.py',
            'model_name_or_path': 'distilbert-base-cased',
            'instance_type': 'ml.g4dn.xlarge',
            'results': {'train_runtime': 6_50, 'eval_accuracy': 0.6, 'eval_loss': 0.9},
        },
        {
            'framework': 'tensorflow',
            'script': 'run_tf.py',
            'model_name_or_path': 'distilbert-base-cased',
            'instance_type': 'ml.g4dn.xlarge',
            'results': {'train_runtime': 6_00, 'eval_accuracy': 0.3, 'eval_loss': 0.9},
        },
    ]					)
class 		UpperCAmelCase_						(	unittest.TestCase					):


						'''simple docstring'''




						def       _lowerCAmelCase       (	self				) ->				Optional[Any]:
								if self.framework == "pytorch":
										subprocess.run(
										    f'''cp ./examples/pytorch/text-classification/run_glue.py {self.env.test_path}/run_glue.py'''.split()		,				encoding="utf-8"		,				check=_SCREAMING_SNAKE_CASE		,				)
								assert hasattr(self		,				"env"				)






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE=1				) ->				List[str]:
								# creates estimator
								return HuggingFace(
								    entry_point=self.script		,				source_dir=self.env.test_path		,				role=self.env.role		,				image_uri=self.env.image_uri		,				base_job_name=f'''{self.env.base_job_name}-single'''		,				instance_count=_SCREAMING_SNAKE_CASE		,				instance_type=self.instance_type		,				debugger_hook_config=_SCREAMING_SNAKE_CASE		,				hyperparameters={**self.env.hyperparameters, "model_name_or_path": self.model_name_or_path}		,				metric_definitions=self.env.metric_definitions		,				py_version="py36"		,				)






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE				) ->				str:
								TrainingJobAnalytics(_SCREAMING_SNAKE_CASE				).export_csv(f'''{self.env.test_path}/{job_name}_metrics.csv'''				)






						def       _lowerCAmelCase       (	self				) ->				Union[str, Any]:
								# create estimator
								snake_case_				:							Optional[int]						 =       self.create_estimator()

								# run training
								estimator.fit()

								# result dataframe
								snake_case_				:							List[Any]						 =       TrainingJobAnalytics(estimator.latest_training_job.name				).dataframe()

								# extract kpis
								snake_case_				:							str						 =       list(result_metrics_df[result_metrics_df.metric_name == "eval_accuracy"]["value"]				)
								snake_case_				:							Dict						 =       list(result_metrics_df[result_metrics_df.metric_name == "eval_loss"]["value"]				)
								# get train time from SageMaker job, this includes starting, preprocessing, stopping
								snake_case_				:							Union[str, Any]						 =       (
								    Session().describe_training_job(estimator.latest_training_job.name				).get("TrainingTimeInSeconds"		,				99_9999				)
								)

								# assert kpis
								assert train_runtime <= self.results["train_runtime"]
								assert all(t >= self.results["eval_accuracy"] for t in eval_accuracy				)
								assert all(t <= self.results["eval_loss"] for t in eval_loss				)

								# dump tests result into json file to share in PR
								with open(f'''{estimator.latest_training_job.name}.json'''		,				"w"				) as outfile:
										json.dump({"train_time": train_runtime, "eval_accuracy": eval_accuracy, "eval_loss": eval_loss}		,				_SCREAMING_SNAKE_CASE				)








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_speech_available, is_torch_available


lowercase  :							int			  =    {
    '''configuration_audio_spectrogram_transformer''': [
        '''AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''ASTConfig''',
    ]
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase  :							Optional[Any]			  =    [
							    '''AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''ASTForAudioClassification''',
							    '''ASTModel''',
							    '''ASTPreTrainedModel''',
							]

try:
							if not is_speech_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase  :							Optional[int]			  =    ['''ASTFeatureExtractor''']

if TYPE_CHECKING:
							from .configuration_audio_spectrogram_transformer import (
							    AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    ASTConfig,
							)

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_audio_spectrogram_transformer import (
														    AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
														    ASTForAudioClassification,
														    ASTModel,
														    ASTPreTrainedModel,
														)

							try:
														if not is_speech_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .feature_extraction_audio_spectrogram_transformer import ASTFeatureExtractor


else:
							import sys

							lowercase  :							Optional[int]			  =    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
