





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

import pytest
from parameterized import parameterized, 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.p3.16xlarge''',
            '''results''': {'''train_runtime''': 650, '''eval_accuracy''': 0.7, '''eval_loss''': 0.6},
        },
        {
            '''framework''': '''pytorch''',
            '''script''': '''run_ddp.py''',
            '''model_name_or_path''': '''distilbert-base-cased''',
            '''instance_type''': '''ml.p3.16xlarge''',
            '''results''': {'''train_runtime''': 600, '''eval_accuracy''': 0.7, '''eval_loss''': 0.6},
        },
        {
            '''framework''': '''tensorflow''',
            '''script''': '''run_tf_dist.py''',
            '''model_name_or_path''': '''distilbert-base-cased''',
            '''instance_type''': '''ml.p3.16xlarge''',
            '''results''': {'''train_runtime''': 600, '''eval_accuracy''': 0.6, '''eval_loss''': 0.7},
        },
    ]	)
class    __lowerCAmelCase			(     unittest.TestCase	):






			def      lowerCamelCase    (self       )	->  Tuple:


							'''simple docstring'''



							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=__magic_name__   ,				)
							assert hasattr(self   ,				'''env'''       )






			def      lowerCamelCase    (self   ,				__magic_name__       )	->  Any:


							'''simple docstring'''



							snake_case_		:       List[Any]           =    F'''{self.env.base_job_name}-{instance_count}-{"ddp" if "ddp" in self.script else "smd"}'''
							# distributed data settings
							snake_case_		:       int           =    {'''smdistributed''': {'''dataparallel''': {'''enabled''': True}}} if self.script != '''run_ddp.py''' else None

							# 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=__magic_name__   ,				instance_count=__magic_name__   ,				instance_type=self.instance_type   ,				debugger_hook_config=__magic_name__   ,				hyperparameters={**self.env.distributed_hyperparameters, '''model_name_or_path''': self.model_name_or_path}   ,				metric_definitions=self.env.metric_definitions   ,				distribution=__magic_name__   ,				py_version='''py36'''   ,				)






			def      lowerCamelCase    (self   ,				__magic_name__       )	->  int:


							'''simple docstring'''



							TrainingJobAnalytics(__magic_name__       ).export_csv(F'''{self.env.test_path}/{job_name}_metrics.csv'''       )






			@parameterized.expand([(2,)]       )
			def      lowerCamelCase    (self   ,				__magic_name__       )	->  str:


							'''simple docstring'''



							snake_case_		:       str           =    self.create_estimator(__magic_name__       )

							# run training
							estimator.fit()

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

							# extract kpis
							snake_case_		:       List[str]           =    list(result_metrics_df[result_metrics_df.metric_name == '''eval_accuracy''']['''value''']       )
							snake_case_		:       Optional[Any]           =    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_		:       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}   ,				__magic_name__       )


import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_video_inputs


if is_torch_available():
		import torch

if is_vision_available():
		from PIL import Image

		from transformers import VivitImageProcessor



class    a_ (			unittest.TestCase    ):






			def __init__(      self				,			__UpperCamelCase				,			__UpperCamelCase=7				,			__UpperCamelCase=3				,			__UpperCamelCase=10				,			__UpperCamelCase=18				,			__UpperCamelCase=30				,			__UpperCamelCase=400				,			__UpperCamelCase=True				,			__UpperCamelCase=None				,			__UpperCamelCase=True				,			__UpperCamelCase=[0.5, 0.5, 0.5]				,			__UpperCamelCase=[0.5, 0.5, 0.5]				,			__UpperCamelCase=None				,			):
									_lowercase					       =					size if size is not None else {"""shortest_edge""": 18}
									_lowercase					       =					crop_size if crop_size is not None else {"""height""": 18, """width""": 18}

									_lowercase					       =					parent
									_lowercase					       =					batch_size
									_lowercase					       =					num_channels
									_lowercase					       =					num_frames
									_lowercase					       =					image_size
									_lowercase					       =					min_resolution
									_lowercase					       =					max_resolution
									_lowercase					       =					do_resize
									_lowercase					       =					size
									_lowercase					       =					do_normalize
									_lowercase					       =					image_mean
									_lowercase					       =					image_std
									_lowercase					       =					crop_size






			def    UpperCamelCase_				(      self  ):
									return {
									    "image_mean": self.image_mean,
									    "image_std": self.image_std,
									    "do_normalize": self.do_normalize,
									    "do_resize": self.do_resize,
									    "size": self.size,
									    "crop_size": self.crop_size,
									}







@require_torch
@require_vision
class    a_ (			_a					,			unittest.TestCase    ):
			a	:			str					   =							VivitImageProcessor if is_vision_available() else None






			def    UpperCamelCase_				(      self  ):
									_lowercase					       =					VivitImageProcessingTester(self  )






			@property
			def    UpperCamelCase_				(      self  ):
									return self.image_processor_tester.prepare_image_processor_dict()






			def    UpperCamelCase_				(      self  ):
									_lowercase					       =					self.image_processing_class(**self.image_processor_dict  )
									self.assertTrue(hasattr(__UpperCamelCase				,			"""image_mean"""  )  )
									self.assertTrue(hasattr(__UpperCamelCase				,			"""image_std"""  )  )
									self.assertTrue(hasattr(__UpperCamelCase				,			"""do_normalize"""  )  )
									self.assertTrue(hasattr(__UpperCamelCase				,			"""do_resize"""  )  )
									self.assertTrue(hasattr(__UpperCamelCase				,			"""do_center_crop"""  )  )
									self.assertTrue(hasattr(__UpperCamelCase				,			"""size"""  )  )






			def    UpperCamelCase_				(      self  ):
									_lowercase					       =					self.image_processing_class.from_dict(self.image_processor_dict  )
									self.assertEqual(image_processor.size				,			{"""shortest_edge""": 18}  )
									self.assertEqual(image_processor.crop_size				,			{"""height""": 18, """width""": 18}  )

									_lowercase					       =					self.image_processing_class.from_dict(self.image_processor_dict				,			size=42				,			crop_size=84  )
									self.assertEqual(image_processor.size				,			{"""shortest_edge""": 42}  )
									self.assertEqual(image_processor.crop_size				,			{"""height""": 84, """width""": 84}  )






			def    UpperCamelCase_				(      self  ):
									# Initialize image_processing
									_lowercase					       =					self.image_processing_class(**self.image_processor_dict  )
									# create random PIL videos
									_lowercase					       =					prepare_video_inputs(self.image_processor_tester				,			equal_resolution=__UpperCamelCase  )
									for video in video_inputs:
															self.assertIsInstance(__UpperCamelCase				,			__UpperCamelCase  )
															self.assertIsInstance(video[0]				,			Image.Image  )

									# Test not batched input
									_lowercase					       =					image_processing(video_inputs[0]				,			return_tensors="""pt"""  ).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,			(
									        1,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,			)

									# Test batched
									_lowercase					       =					image_processing(__UpperCamelCase				,			return_tensors="""pt"""  ).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,			(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,			)






			def    UpperCamelCase_				(      self  ):
									# Initialize image_processing
									_lowercase					       =					self.image_processing_class(**self.image_processor_dict  )
									# create random numpy tensors
									_lowercase					       =					prepare_video_inputs(self.image_processor_tester				,			equal_resolution=__UpperCamelCase				,			numpify=__UpperCamelCase  )
									for video in video_inputs:
															self.assertIsInstance(__UpperCamelCase				,			__UpperCamelCase  )
															self.assertIsInstance(video[0]				,			np.ndarray  )

									# Test not batched input
									_lowercase					       =					image_processing(video_inputs[0]				,			return_tensors="""pt"""  ).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,			(
									        1,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,			)

									# Test batched
									_lowercase					       =					image_processing(__UpperCamelCase				,			return_tensors="""pt"""  ).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,			(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,			)






			def    UpperCamelCase_				(      self  ):
									# Initialize image_processing
									_lowercase					       =					self.image_processing_class(**self.image_processor_dict  )
									# create random PyTorch tensors
									_lowercase					       =					prepare_video_inputs(self.image_processor_tester				,			equal_resolution=__UpperCamelCase				,			torchify=__UpperCamelCase  )
									for video in video_inputs:
															self.assertIsInstance(__UpperCamelCase				,			__UpperCamelCase  )
															self.assertIsInstance(video[0]				,			torch.Tensor  )

									# Test not batched input
									_lowercase					       =					image_processing(video_inputs[0]				,			return_tensors="""pt"""  ).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,			(
									        1,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,			)

									# Test batched
									_lowercase					       =					image_processing(__UpperCamelCase				,			return_tensors="""pt"""  ).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,			(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,			)