



"""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)
lowerCamelCase       	=						logging.getLogger()

lowerCamelCase       	=						logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)
class 				lowercase__       (   SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       def 					lowercase__    (							self      :  Optional[int]		,    _UpperCAmelCase      :  Tuple   )			->						str:


             '''simple docstring'''




             os.makedirs(_UpperCAmelCase		,    exist_ok=_UpperCAmelCase   )
             UpperCAmelCase_      			=							{"source": "What is love ?", "target": "life"}
             UpperCAmelCase_      			=							{"train": 12, "val": 2, "test": 2}
             for split in ["train", "test", "val"]:
                   for field in ["source", "target"]:
                         UpperCAmelCase_      			=							"\n".join([contents[field]] * n_lines[split]   )
                         with open(os.path.join(_UpperCAmelCase		,    F"""{split}.{field}"""   )		,    "w"   ) as f:
                               f.write(_UpperCAmelCase   )



       def 					lowercase__    (							self      :  str		,    _UpperCAmelCase      :  int		,    _UpperCAmelCase      :  str = "pytorch"   )			->						Union[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							self.get_auto_remove_tmp_dir()
             UpperCAmelCase_      			=							os.path.join(_UpperCAmelCase		,    "output"   )
             UpperCAmelCase_      			=							os.path.join(_UpperCAmelCase		,    "data"   )
             self._create_dummy_data(data_dir=_UpperCAmelCase   )

             UpperCAmelCase_      			=							F"""
                --data_dir {data_dir} \
                --output_dir {output_dir} \
                --model_name_or_path facebook/rag-sequence-base \
                --model_type rag_sequence \
                --do_train \
                --do_predict \
                --n_val -1 \
                --val_check_interval 1.0 \
                --train_batch_size 2 \
                --eval_batch_size 1 \
                --max_source_length 25 \
                --max_target_length 25 \
                --val_max_target_length 25 \
                --test_max_target_length 25 \
                --label_smoothing 0.1 \
                --dropout 0.1 \
                --attention_dropout 0.1 \
                --weight_decay 0.001 \
                --adam_epsilon 1e-08 \
                --max_grad_norm 0.1 \
                --lr_scheduler polynomial \
                --learning_rate 3e-04 \
                --num_train_epochs 1 \
                --warmup_steps 4 \
                --gradient_accumulation_steps 1 \
                --distributed-port 8787 \
                --use_dummy_dataset 1 \
                --distributed_retriever {distributed_retriever} \
            """.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"   )

             UpperCAmelCase_      			=							[sys.executable, str(Path(finetune_rag.__file__   ).resolve()   )] + testargs
             execute_subprocess_async(_UpperCAmelCase		,    env=self.get_env()   )

             UpperCAmelCase_      			=							os.path.join(_UpperCAmelCase		,    "metrics.json"   )
             with open(_UpperCAmelCase   ) as f:
                   UpperCAmelCase_      			=							json.load(_UpperCAmelCase   )
             return result



       @require_torch_gpu
       def 					lowercase__    (							self      :  List[str]   )			->						Any:


             '''simple docstring'''




             UpperCAmelCase_      			=							self._run_finetune(gpus=1   )
             self.assertGreaterEqual(result["test"][0]["test_avg_em"]		,    0.2   )



       @require_torch_multi_gpu
       def 					lowercase__    (							self      :  str   )			->						str:


             '''simple docstring'''




             UpperCAmelCase_      			=							self._run_finetune(gpus=2   )
             self.assertGreaterEqual(result["test"][0]["test_avg_em"]		,    0.2   )



       @require_torch_gpu
       @require_ray
       def 					lowercase__    (							self      :  Dict   )			->						Optional[int]:


             '''simple docstring'''




             UpperCAmelCase_      			=							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      :  Union[str, Any]   )			->						Union[str, Any]:


             '''simple docstring'''




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









"""simple docstring"""





from collections import OrderedDict
from typing import Mapping

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


lowerCamelCase       	=						logging.get_logger(__name__)

lowerCamelCase       	=						{
    """roberta-base""": """https://huggingface.co/roberta-base/resolve/main/config.json""",
    """roberta-large""": """https://huggingface.co/roberta-large/resolve/main/config.json""",
    """roberta-large-mnli""": """https://huggingface.co/roberta-large-mnli/resolve/main/config.json""",
    """distilroberta-base""": """https://huggingface.co/distilroberta-base/resolve/main/config.json""",
    """roberta-base-openai-detector""": """https://huggingface.co/roberta-base-openai-detector/resolve/main/config.json""",
    """roberta-large-openai-detector""": """https://huggingface.co/roberta-large-openai-detector/resolve/main/config.json""",
}
class 				lowercase__       (   SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					'''roberta'''



       def __init__(							self      :  int		,    _UpperCAmelCase      :  List[Any]=50265		,    _UpperCAmelCase      :  str=768		,    _UpperCAmelCase      :  List[str]=12		,    _UpperCAmelCase      :  int=12		,    _UpperCAmelCase      :  Tuple=3072		,    _UpperCAmelCase      :  Dict="gelu"		,    _UpperCAmelCase      :  int=0.1		,    _UpperCAmelCase      :  Optional[int]=0.1		,    _UpperCAmelCase      :  Optional[int]=512		,    _UpperCAmelCase      :  Optional[Any]=2		,    _UpperCAmelCase      :  Optional[int]=0.02		,    _UpperCAmelCase      :  Optional[Any]=1e-12		,    _UpperCAmelCase      :  Dict=1		,    _UpperCAmelCase      :  str=0		,    _UpperCAmelCase      :  int=2		,    _UpperCAmelCase      :  Tuple="absolute"		,    _UpperCAmelCase      :  Any=True		,    _UpperCAmelCase      :  int=None		,    **_UpperCAmelCase      :  List[str]		,    )			->						Any:


             '''simple docstring'''




             super().__init__(pad_token_id=_UpperCAmelCase		,    bos_token_id=_UpperCAmelCase		,    eos_token_id=_UpperCAmelCase		,    **_UpperCAmelCase   )

             UpperCAmelCase_      			=							vocab_size
             UpperCAmelCase_      			=							hidden_size
             UpperCAmelCase_      			=							num_hidden_layers
             UpperCAmelCase_      			=							num_attention_heads
             UpperCAmelCase_      			=							hidden_act
             UpperCAmelCase_      			=							intermediate_size
             UpperCAmelCase_      			=							hidden_dropout_prob
             UpperCAmelCase_      			=							attention_probs_dropout_prob
             UpperCAmelCase_      			=							max_position_embeddings
             UpperCAmelCase_      			=							type_vocab_size
             UpperCAmelCase_      			=							initializer_range
             UpperCAmelCase_      			=							layer_norm_eps
             UpperCAmelCase_      			=							position_embedding_type
             UpperCAmelCase_      			=							use_cache
             UpperCAmelCase_      			=							classifier_dropout



class 				lowercase__       (   SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       @property
       def 					lowercase__    (							self      :  List[Any]   )			->						Mapping[str, Mapping[int, str]]:


             '''simple docstring'''




             if self.task == "multiple-choice":
                   UpperCAmelCase_      			=							{0: "batch", 1: "choice", 2: "sequence"}
             else:
                   UpperCAmelCase_      			=							{0: "batch", 1: "sequence"}
             return OrderedDict(
                 [
                     ("input_ids", dynamic_axis),
                     ("attention_mask", dynamic_axis),
                 ]   )




