



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

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






class 					lowerCamelCase_    (				SCREAMING_SNAKE_CASE_     ):
  """simple docstring"""




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




  def 						_lowercase     ( self      :	int			,	_a      :	int			,	_a      :	str = "pytorch"   )					->					Any:
    __lowerCamelCase       :       Dict           = self.get_auto_remove_tmp_dir()
    __lowerCamelCase       :       List[Any]           = os.path.join(_a			,	'output'   )
    __lowerCamelCase       :       Tuple           = os.path.join(_a			,	'data'   )
    self._create_dummy_data(data_dir=_a   )

    __lowerCamelCase       :       str           = 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'   )

    __lowerCamelCase       :       Optional[int]           = [sys.executable, str(Path(finetune_rag.__file__   ).resolve()   )] + testargs
    execute_subprocess_async(_a			,	env=self.get_env()   )

    __lowerCamelCase       :       Dict           = os.path.join(_a			,	'metrics.json'   )
    with open(_a   ) as f:
      __lowerCamelCase       :       Tuple           = json.load(_a   )
    return result




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




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




  @require_torch_gpu
  @require_ray
  def 						_lowercase     ( self      :	Tuple   )					->					List[Any]:
    __lowerCamelCase       :       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      :	List[str]   )					->					Tuple:
    __lowerCamelCase       :       List[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_flax_available, is_torch_available


_UpperCamelCase											=						{'configuration_speech_encoder_decoder': ['SpeechEncoderDecoderConfig']}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCamelCase											=						['SpeechEncoderDecoderModel']

try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCamelCase											=						['FlaxSpeechEncoderDecoderModel']

if TYPE_CHECKING:
   from .configuration_speech_encoder_decoder import SpeechEncoderDecoderConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_speech_encoder_decoder import SpeechEncoderDecoderModel

   try:
      if not is_flax_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_flax_speech_encoder_decoder import FlaxSpeechEncoderDecoderModel

else:
   import sys

   _UpperCamelCase											=						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






