
'''simple docstring'''
import json
import logging
import os
import sys
from pathlib import Path

import finetune_rag

from transformers.file_utils import is_apex_available
from transformers.testing_utils import (
    TestCasePlus,
    execute_subprocess_async,
    require_ray,
    require_torch_gpu,
    require_torch_multi_gpu,
)


logging.basicConfig(level=logging.DEBUG)
A__   :		int 		=logging.getLogger()

A__   :		Union[str, Any] 		=logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)







class  __A				( _SCREAMING_SNAKE_CASE			):
 def 		lowercase_(   self			:    int				,   lowerCamelCase			:    Optional[Any]       ):



   """simple docstring"""





   os.makedirs(lowerCamelCase				,   exist_ok=lowerCamelCase       )
   __A		:     Optional[Any]												=		{"""source""": """What is love ?""", """target""": """life"""}
   __A		:     List[str]												=		{"""train""": 12, """val""": 2, """test""": 2}
   for split in ["train", "test", "val"]:
     for field in ["source", "target"]:
       __A		:     List[Any]												=		"""\n""".join([contents[field]] * n_lines[split]       )
       with open(os.path.join(lowerCamelCase				,   f"{split}.{field}"       )				,   """w"""       ) as f:
         f.write(lowerCamelCase       )
 def 		lowercase_(   self			:    Optional[Any]				,   lowerCamelCase			:    int				,   lowerCamelCase			:    str = "pytorch"       ):



   """simple docstring"""





   __A		:     Optional[int]												=		self.get_auto_remove_tmp_dir()
   __A		:     Any												=		os.path.join(lowerCamelCase				,   """output"""       )
   __A		:     Union[str, Any]												=		os.path.join(lowerCamelCase				,   """data"""       )
   self._create_dummy_data(data_dir=lowerCamelCase       )

   __A		:     List[Any]												=		f"\n                --data_dir {data_dir} \\n                --output_dir {output_dir} \\n                --model_name_or_path facebook/rag-sequence-base \\n                --model_type rag_sequence \\n                --do_train \\n                --do_predict \\n                --n_val -1 \\n                --val_check_interval 1.0 \\n                --train_batch_size 2 \\n                --eval_batch_size 1 \\n                --max_source_length 25 \\n                --max_target_length 25 \\n                --val_max_target_length 25 \\n                --test_max_target_length 25 \\n                --label_smoothing 0.1 \\n                --dropout 0.1 \\n                --attention_dropout 0.1 \\n                --weight_decay 0.001 \\n                --adam_epsilon 1e-08 \\n                --max_grad_norm 0.1 \\n                --lr_scheduler polynomial \\n                --learning_rate 3e-04 \\n                --num_train_epochs 1 \\n                --warmup_steps 4 \\n                --gradient_accumulation_steps 1 \\n                --distributed-port 8787 \\n                --use_dummy_dataset 1 \\n                --distributed_retriever {distributed_retriever} \\n            ".split()

   if gpus > 0:
     testargs.append(f"--gpus={gpus}"       )
     if is_apex_available():
       testargs.append("""--fp16"""       )
   else:
     testargs.append("""--gpus=0"""       )
     testargs.append("""--distributed_backend=ddp_cpu"""       )
     testargs.append("""--num_processes=2"""       )

   __A		:     Tuple												=		[sys.executable, str(Path(finetune_rag.__file__       ).resolve()       )] + testargs
   execute_subprocess_async(lowerCamelCase				,   env=self.get_env()       )

   __A		:     int												=		os.path.join(lowerCamelCase				,   """metrics.json"""       )
   with open(lowerCamelCase       ) as f:
     __A		:     str												=		json.load(lowerCamelCase       )
   return result
 @require_torch_gpu
 def 		lowercase_(   self			:    Union[str, Any]       ):



   """simple docstring"""





   __A		:     Dict												=		self._run_finetune(gpus=1       )
   self.assertGreaterEqual(result["""test"""][0]["""test_avg_em"""]				,   0.2       )
 @require_torch_multi_gpu
 def 		lowercase_(   self			:    int       ):



   """simple docstring"""





   __A		:     Tuple												=		self._run_finetune(gpus=2       )
   self.assertGreaterEqual(result["""test"""][0]["""test_avg_em"""]				,   0.2       )
 @require_torch_gpu
 @require_ray
 def 		lowercase_(   self			:    List[Any]       ):



   """simple docstring"""





   __A		:     List[Any]												=		self._run_finetune(gpus=1				,   distributed_retriever="""ray"""       )
   self.assertGreaterEqual(result["""test"""][0]["""test_avg_em"""]				,   0.2       )






 @require_torch_multi_gpu
 @require_ray
 def 		lowercase_(   self			:    Optional[Any]       ):



   """simple docstring"""





   __A		:     Optional[int]												=		self._run_finetune(gpus=1				,   distributed_retriever="""ray"""       )
   self.assertGreaterEqual(result["""test"""][0]["""test_avg_em"""]				,   0.2       )





'''simple docstring'''
import argparse

import torch

from transformers import RemBertConfig, RemBertModel, load_tf_weights_in_rembert
from transformers.utils import logging


logging.set_verbosity_info()







def        A_     (						__SCREAMING_SNAKE_CASE						:  Optional[Any]			,     __SCREAMING_SNAKE_CASE						:  List[str]			,     __SCREAMING_SNAKE_CASE						:  Optional[Any] )				->       List[Any]:





  """simple docstring"""

  __A		:     Optional[int]												=		RemBertConfig.from_json_file(__SCREAMING_SNAKE_CASE )
  print("""Building PyTorch model from configuration: {}""".format(str(__SCREAMING_SNAKE_CASE ) ) )
  __A		:     str												=		RemBertModel(__SCREAMING_SNAKE_CASE )

  # Load weights from tf checkpoint
  load_tf_weights_in_rembert(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )

  # Save pytorch-model
  print("""Save PyTorch model to {}""".format(__SCREAMING_SNAKE_CASE ) )
  torch.save(model.state_dict()			,     __SCREAMING_SNAKE_CASE )


if __name__ == "__main__":
     A__   :		Optional[Any] 		=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(
         '--rembert_config_file',
         default=None,
         type=str,
         required=True,
         help=(
             'The config json file corresponding to the pre-trained RemBERT 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.'
     )
     A__   :		Dict 		=parser.parse_args()
     convert_rembert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.rembert_config_file, args.pytorch_dump_path)



