

'''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)
lowercase__         =      logging.getLogger()

lowercase__         =      logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)




class 	A_			(    _snake_case							):






     '''simple docstring'''



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


     def        UpperCAmelCase_	(		self			:					Dict					,      lowercase_			:					int					,      lowercase_			:					str = "pytorch"	)						->     int:
      UpperCAmelCase	:     Dict						 =			self.get_auto_remove_tmp_dir()
      UpperCAmelCase	:     Optional[Any]						 =			os.path.join(lowercase_					,      'output'	)
      UpperCAmelCase	:     Union[str, Any]						 =			os.path.join(lowercase_					,      'data'	)
      self._create_dummy_data(data_dir=lowercase_	)

      UpperCAmelCase	:     str						 =			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	:     Union[str, Any]						 =			[sys.executable, str(Path(finetune_rag.__file__	).resolve()	)] + testargs
      execute_subprocess_async(lowercase_					,      env=self.get_env()	)

      UpperCAmelCase	:     Optional[int]						 =			os.path.join(lowercase_					,      'metrics.json'	)
      with open(lowercase_	) as f:
       UpperCAmelCase	:     Union[str, Any]						 =			json.load(lowercase_	)
      return result


     @require_torch_gpu
     def        UpperCAmelCase_	(		self			:					List[Any]	)						->     List[str]:
      UpperCAmelCase	:     Optional[Any]						 =			self._run_finetune(gpus=1	)
      self.assertGreaterEqual(result['test'][0]['test_avg_em']					,      0.2	)


     @require_torch_multi_gpu
     def        UpperCAmelCase_	(		self			:					Any	)						->     Dict:
      UpperCAmelCase	:     List[str]						 =			self._run_finetune(gpus=2	)
      self.assertGreaterEqual(result['test'][0]['test_avg_em']					,      0.2	)


     @require_torch_gpu
     @require_ray
     def        UpperCAmelCase_	(		self			:					Optional[Any]	)						->     Dict:
      UpperCAmelCase	:     Optional[int]						 =			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        UpperCAmelCase_	(		self			:					Tuple	)						->     Any:
      UpperCAmelCase	:     Any						 =			self._run_finetune(gpus=1					,      distributed_retriever='ray'	)
      self.assertGreaterEqual(result['test'][0]['test_avg_em']					,      0.2	)







'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


lowercase__         =      {
    "configuration_xlm": ["XLM_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLMConfig", "XLMOnnxConfig"],
    "tokenization_xlm": ["XLMTokenizer"],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowercase__         =      [
     "XLM_PRETRAINED_MODEL_ARCHIVE_LIST",
     "XLMForMultipleChoice",
     "XLMForQuestionAnswering",
     "XLMForQuestionAnsweringSimple",
     "XLMForSequenceClassification",
     "XLMForTokenClassification",
     "XLMModel",
     "XLMPreTrainedModel",
     "XLMWithLMHeadModel",
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowercase__         =      [
     "TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST",
     "TFXLMForMultipleChoice",
     "TFXLMForQuestionAnsweringSimple",
     "TFXLMForSequenceClassification",
     "TFXLMForTokenClassification",
     "TFXLMMainLayer",
     "TFXLMModel",
     "TFXLMPreTrainedModel",
     "TFXLMWithLMHeadModel",
 ]


if TYPE_CHECKING:
 from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
 from .tokenization_xlm import XLMTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_xlm import (
      XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
      XLMForMultipleChoice,
      XLMForQuestionAnswering,
      XLMForQuestionAnsweringSimple,
      XLMForSequenceClassification,
      XLMForTokenClassification,
      XLMModel,
      XLMPreTrainedModel,
      XLMWithLMHeadModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_xlm import (
      TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFXLMForMultipleChoice,
      TFXLMForQuestionAnsweringSimple,
      TFXLMForSequenceClassification,
      TFXLMForTokenClassification,
      TFXLMMainLayer,
      TFXLMModel,
      TFXLMPreTrainedModel,
      TFXLMWithLMHeadModel,
  )

else:
 import sys

 lowercase__         =      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




