






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

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





class __lowerCamelCase (      snake_case__):





	"""simple docstring"""






	def        UpperCamelCase    (							self       ,    UpperCAmelCase    ):
							"""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        UpperCamelCase    (							self       ,    UpperCAmelCase       ,    UpperCAmelCase = "pytorch"    ):
							"""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        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	@require_torch_multi_gpu
	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	@require_torch_gpu
	@require_ray
	def        UpperCamelCase    (							self    ):
							"""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        UpperCamelCase    (							self    ):
							"""simple docstring"""







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







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase_     							= {
    'configuration_convbert': ['CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ConvBertConfig', 'ConvBertOnnxConfig'],
    'tokenization_convbert': ['ConvBertTokenizer'],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase_     							= ['ConvBertTokenizerFast']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase_     							= [
      'CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
      'ConvBertForMaskedLM',
      'ConvBertForMultipleChoice',
      'ConvBertForQuestionAnswering',
      'ConvBertForSequenceClassification',
      'ConvBertForTokenClassification',
      'ConvBertLayer',
      'ConvBertModel',
      'ConvBertPreTrainedModel',
      'load_tf_weights_in_convbert',
  ]


try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase_     							= [
      'TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TFConvBertForMaskedLM',
      'TFConvBertForMultipleChoice',
      'TFConvBertForQuestionAnswering',
      'TFConvBertForSequenceClassification',
      'TFConvBertForTokenClassification',
      'TFConvBertLayer',
      'TFConvBertModel',
      'TFConvBertPreTrainedModel',
  ]


if TYPE_CHECKING:
  from .configuration_convbert import CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvBertConfig, ConvBertOnnxConfig
  from .tokenization_convbert import ConvBertTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_convbert_fast import ConvBertTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_convbert import (
        CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        ConvBertForMaskedLM,
        ConvBertForMultipleChoice,
        ConvBertForQuestionAnswering,
        ConvBertForSequenceClassification,
        ConvBertForTokenClassification,
        ConvBertLayer,
        ConvBertModel,
        ConvBertPreTrainedModel,
        load_tf_weights_in_convbert,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_convbert import (
        TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFConvBertForMaskedLM,
        TFConvBertForMultipleChoice,
        TFConvBertForQuestionAnswering,
        TFConvBertForSequenceClassification,
        TFConvBertForTokenClassification,
        TFConvBertLayer,
        TFConvBertModel,
        TFConvBertPreTrainedModel,
    )


else:
  import sys

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

