






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_model_parallelism.py',
            'model_name_or_path': 'roberta-large',
            'instance_type': 'ml.p3dn.24xlarge',
            'results': {'train_runtime': 1_600, 'eval_accuracy': 0.3, 'eval_loss': 1.2},
        },
        {
            'framework': 'pytorch',
            'script': 'run_glue.py',
            'model_name_or_path': 'roberta-large',
            'instance_type': 'ml.p3dn.24xlarge',
            'results': {'train_runtime': 1_600, 'eval_accuracy': 0.3, 'eval_loss': 1.2},
        },
    ]   )
class     a    ( unittest.TestCase   ):



      """simple docstring"""


      def 	UpperCAmelCase      (      self					:			int					)							->      Dict:
        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=__lowercase		,      )
        assert hasattr(self		,      """env"""					)
      def 	UpperCAmelCase      (      self					:			Optional[Any]		,      __lowercase					:			Optional[int]					)							->      Optional[Any]:
        # configuration for running training on smdistributed Model Parallel
        __UpperCAmelCase							:	Union[str, Any]           =  {
            """enabled""": True,
            """processes_per_host""": 8,
        }
        __UpperCAmelCase							:	Dict           =  {
            """enabled""": True,
            """parameters""": {
                """microbatches""": 4,
                """placement_strategy""": """spread""",
                """pipeline""": """interleaved""",
                """optimize""": """speed""",
                """partitions""": 4,
                """ddp""": True,
            },
        }

        __UpperCAmelCase							:	Tuple           =  {"""smdistributed""": {"""modelparallel""": smp_options}, """mpi""": mpi_options}

        __UpperCAmelCase							:	List[Any]           =  """trainer""" if self.script == """run_glue.py""" else """smtrainer"""
        # 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}-{instance_count}-smp-{name_extension}"""		,      instance_count=__lowercase		,      instance_type=self.instance_type		,      debugger_hook_config=__lowercase		,      hyperparameters={
                **self.env.hyperparameters,
                """model_name_or_path""": self.model_name_or_path,
                """max_steps""": 500,
            }		,      metric_definitions=self.env.metric_definitions		,      distribution=__lowercase		,      py_version="""py36"""		,      )
      def 	UpperCAmelCase      (      self					:			str		,      __lowercase					:			Tuple					)							->      List[Any]:
        TrainingJobAnalytics(__lowercase					).export_csv(f"""{self.env.test_path}/{job_name}_metrics.csv"""					)




      @parameterized.expand([(1,)]					)
      def 	UpperCAmelCase      (      self					:			Tuple		,      __lowercase					:			Optional[int]					)							->      List[Any]:
        # create estimator
        __UpperCAmelCase							:	List[Any]           =  self.create_estimator(__lowercase					)

        # run training
        estimator.fit()

        # result dataframe
        __UpperCAmelCase							:	str           =  TrainingJobAnalytics(estimator.latest_training_job.name					).dataframe()

        # extract kpis
        __UpperCAmelCase							:	str           =  list(result_metrics_df[result_metrics_df.metric_name == """eval_accuracy"""]["""value"""]					)
        __UpperCAmelCase							:	Optional[int]           =  list(result_metrics_df[result_metrics_df.metric_name == """eval_loss"""]["""value"""]					)
        # get train time from SageMaker job, this includes starting, preprocessing, stopping
        __UpperCAmelCase							:	List[Any]           =  (
            Session().describe_training_job(estimator.latest_training_job.name					).get("""TrainingTimeInSeconds"""		,      999999					)
        )

        # 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}		,      __lowercase					)










import warnings
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


a		:       List[Any]			     = logging.get_logger(__name__)

a		:       List[Any]			     = {
    "nvidia/segformer-b0-finetuned-ade-512-512": (
        "https://huggingface.co/nvidia/segformer-b0-finetuned-ade-512-512/resolve/main/config.json"
    ),
    # See all SegFormer models at https://huggingface.co/models?filter=segformer
}
class     a    ( lowercase__   ):



      """simple docstring"""


      a  : int							       =	'segformer'
      def __init__(      self					:			Dict		,      __lowercase					:			str=3		,      __lowercase					:			Dict=4		,      __lowercase					:			Any=[2, 2, 2, 2]		,      __lowercase					:			Optional[int]=[8, 4, 2, 1]		,      __lowercase					:			List[str]=[32, 64, 160, 256]		,      __lowercase					:			Union[str, Any]=[7, 3, 3, 3]		,      __lowercase					:			Optional[int]=[4, 2, 2, 2]		,      __lowercase					:			Any=[1, 2, 5, 8]		,      __lowercase					:			List[str]=[4, 4, 4, 4]		,      __lowercase					:			Any="gelu"		,      __lowercase					:			Optional[int]=0.0		,      __lowercase					:			Dict=0.0		,      __lowercase					:			Optional[Any]=0.1		,      __lowercase					:			int=0.02		,      __lowercase					:			Optional[int]=0.1		,      __lowercase					:			Optional[Any]=1e-6		,      __lowercase					:			Tuple=256		,      __lowercase					:			List[Any]=255		,      **__lowercase					:			Union[str, Any]		,      )							->      List[Any]:
        super().__init__(**__lowercase					)

        if "reshape_last_stage" in kwargs and kwargs["reshape_last_stage"] is False:
          warnings.warn(
              """Reshape_last_stage is set to False in this config. This argument is deprecated and will soon be"""
              """ removed, as the behaviour will default to that of reshape_last_stage = True."""		,      __lowercase		,      )

        __UpperCAmelCase							:	Tuple           =  num_channels
        __UpperCAmelCase							:	Any           =  num_encoder_blocks
        __UpperCAmelCase							:	List[Any]           =  depths
        __UpperCAmelCase							:	Dict           =  sr_ratios
        __UpperCAmelCase							:	int           =  hidden_sizes
        __UpperCAmelCase							:	Optional[Any]           =  patch_sizes
        __UpperCAmelCase							:	List[Any]           =  strides
        __UpperCAmelCase							:	List[str]           =  mlp_ratios
        __UpperCAmelCase							:	Tuple           =  num_attention_heads
        __UpperCAmelCase							:	List[str]           =  hidden_act
        __UpperCAmelCase							:	Tuple           =  hidden_dropout_prob
        __UpperCAmelCase							:	Dict           =  attention_probs_dropout_prob
        __UpperCAmelCase							:	Any           =  classifier_dropout_prob
        __UpperCAmelCase							:	Optional[int]           =  initializer_range
        __UpperCAmelCase							:	Optional[Any]           =  drop_path_rate
        __UpperCAmelCase							:	int           =  layer_norm_eps
        __UpperCAmelCase							:	Dict           =  decoder_hidden_size
        __UpperCAmelCase							:	Tuple           =  kwargs.get("""reshape_last_stage"""		,      __lowercase					)
        __UpperCAmelCase							:	int           =  semantic_loss_ignore_index


class     a    ( lowercase__   ):



      """simple docstring"""


      a  : Union[str, Any]							       =	version.parse('1.11'   )
      @property
      def 	UpperCAmelCase      (      self					:			Union[str, Any]					)							->      Mapping[str, Mapping[int, str]]:
        return OrderedDict(
            [
                ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
            ]					)
      @property
      def 	UpperCAmelCase      (      self					:			Optional[Any]					)							->      float:
        return 1e-4




      @property
      def 	UpperCAmelCase      (      self					:			str					)							->      int:
        return 12


