
'''simple docstring'''
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''': 650, '''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''': 600, '''eval_accuracy''': 0.3, '''eval_loss''': 0.9},
        },
    ]			)
class  __A				( unittest.TestCase			):
 def 		lowercase_(   self			:    List[str]       ):



   """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=A_				,   )
   assert hasattr(self				,   """env"""       )
 def 		lowercase_(   self			:    Optional[int]				,   lowerCamelCase			:    Any=1       ):



   """simple docstring"""





   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=A_				,   instance_type=self.instance_type				,   debugger_hook_config=A_				,   hyperparameters={**self.env.hyperparameters, """model_name_or_path""": self.model_name_or_path}				,   metric_definitions=self.env.metric_definitions				,   py_version="""py36"""				,   )
 def 		lowercase_(   self			:    Union[str, Any]				,   lowerCamelCase			:    Optional[Any]       ):



   """simple docstring"""





   TrainingJobAnalytics(A_       ).export_csv(f"{self.env.test_path}/{job_name}_metrics.csv"       )






 def 		lowercase_(   self			:    str       ):



   """simple docstring"""





   __A		:     List[str]												=		self.create_estimator()

   # run training
   estimator.fit()

   # result dataframe
   __A		:     Tuple												=		TrainingJobAnalytics(estimator.latest_training_job.name       ).dataframe()

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

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

'''simple docstring'''
from ...configuration_utils import PretrainedConfig
from ...utils import logging


A__   :		int 		=logging.get_logger(__name__)

A__   :		Union[str, Any] 		={
    'facebook/dpr-ctx_encoder-single-nq-base': (
        'https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/config.json'
    ),
    'facebook/dpr-question_encoder-single-nq-base': (
        'https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/config.json'
    ),
    'facebook/dpr-reader-single-nq-base': (
        'https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/config.json'
    ),
    'facebook/dpr-ctx_encoder-multiset-base': (
        'https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/config.json'
    ),
    'facebook/dpr-question_encoder-multiset-base': (
        'https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/config.json'
    ),
    'facebook/dpr-reader-multiset-base': (
        'https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/config.json'
    ),
}







class  __A				( _SCREAMING_SNAKE_CASE			):
 lowerCamelCase				       ='''dpr'''
 def __init__(   self			:    Optional[int]				,   lowerCamelCase			:    Tuple=3_05_22				,   lowerCamelCase			:    List[str]=7_68				,   lowerCamelCase			:    Union[str, Any]=12				,   lowerCamelCase			:    Tuple=12				,   lowerCamelCase			:    Dict=30_72				,   lowerCamelCase			:    List[Any]="gelu"				,   lowerCamelCase			:    List[Any]=0.1				,   lowerCamelCase			:    Union[str, Any]=0.1				,   lowerCamelCase			:    Optional[Any]=5_12				,   lowerCamelCase			:    List[Any]=2				,   lowerCamelCase			:    int=0.02				,   lowerCamelCase			:    Union[str, Any]=1e-1_2				,   lowerCamelCase			:    int=0				,   lowerCamelCase			:    List[str]="absolute"				,   lowerCamelCase			:    int = 0				,   **lowerCamelCase			:    List[Any]				,   ):



   """simple docstring"""





   super().__init__(pad_token_id=lowerCamelCase				,   **lowerCamelCase       )

   __A		:     Dict												=		vocab_size
   __A		:     int												=		hidden_size
   __A		:     str												=		num_hidden_layers
   __A		:     Union[str, Any]												=		num_attention_heads
   __A		:     Union[str, Any]												=		hidden_act
   __A		:     Optional[Any]												=		intermediate_size
   __A		:     str												=		hidden_dropout_prob
   __A		:     int												=		attention_probs_dropout_prob
   __A		:     int												=		max_position_embeddings
   __A		:     Dict												=		type_vocab_size
   __A		:     Dict												=		initializer_range
   __A		:     Union[str, Any]												=		layer_norm_eps
   __A		:     int												=		projection_dim
   __A		:     List[Any]												=		position_embedding_type



