






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     _a							(	unittest.TestCase     ):






  """simple docstring"""





  def  _UpperCAmelCase  (  self			)      ->			str:
     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=_UpperCAmelCase		,		)
     assert hasattr(self		,		'env'			)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			str:
     UpperCamelCase_						=  f"""{self.env.base_job_name}-{instance_count}-{"ddp" if "ddp" in self.script else "smd"}"""
     # distributed data settings
     UpperCamelCase_						=  {'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=_UpperCAmelCase		,		instance_count=_UpperCAmelCase		,		instance_type=self.instance_type		,		debugger_hook_config=_UpperCAmelCase		,		hyperparameters={**self.env.distributed_hyperparameters, 'model_name_or_path': self.model_name_or_path}		,		metric_definitions=self.env.metric_definitions		,		distribution=_UpperCAmelCase		,		py_version='py36'		,		)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Any:
     TrainingJobAnalytics(_UpperCAmelCase			).export_csv(f"""{self.env.test_path}/{job_name}_metrics.csv"""			)




  @parameterized.expand([(2,)]			)
  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Tuple:
     # create estimator
     UpperCamelCase_						=  self.create_estimator(_UpperCAmelCase			)

     # run training
     estimator.fit()

     # result dataframe
     UpperCamelCase_						=  TrainingJobAnalytics(estimator.latest_training_job.name			).dataframe()

     # extract kpis
     UpperCamelCase_						=  list(result_metrics_df[result_metrics_df.metric_name == 'eval_accuracy']['value']			)
     UpperCamelCase_						=  list(result_metrics_df[result_metrics_df.metric_name == 'eval_loss']['value']			)
     # get train time from SageMaker job, this includes starting, preprocessing, stopping
     UpperCamelCase_						=  (
         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}		,		_UpperCAmelCase			)













import argparse

import torch

from transformers import MobileBertConfig, MobileBertForPreTraining, load_tf_weights_in_mobilebert
from transformers.utils import logging


logging.set_verbosity_info()






def      _snake_case     (__lowercase     ,   __lowercase     ,   __lowercase):
   # Initialise PyTorch model
   UpperCamelCase_						=  MobileBertConfig.from_json_file(__lowercase)
   print(f"""Building PyTorch model from configuration: {config}""")
   UpperCamelCase_						=  MobileBertForPreTraining(__lowercase)
   # Load weights from tf checkpoint
   UpperCamelCase_						=  load_tf_weights_in_mobilebert(__lowercase     ,   __lowercase     ,   __lowercase)
   # Save pytorch-model
   print(f"""Save PyTorch model to {pytorch_dump_path}""")
   torch.save(model.state_dict()     ,   __lowercase)


if __name__ == "__main__":
 snake_case__   :						int													=   argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
 )
 parser.add_argument(
     """--mobilebert_config_file""",
     default=None,
     type=str,
     required=True,
     help=(
         """The config json file corresponding to the pre-trained MobileBERT model. \n"""
         """This specifies the model architecture."""
     ),
 )
 parser.add_argument(
     """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
 )
 snake_case__   :						Optional[Any]													=   parser.parse_args()
 convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.mobilebert_config_file, args.pytorch_dump_path)





