
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       a		(   __UpperCAmelCase					):







							def       UpperCAmelCase__					(						self  :  List[Any]      ,				snake_case__  :  List[str] ):
								"""simple docstring"""







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







							def       UpperCAmelCase__					(						self  :  str      ,				snake_case__  :  int      ,				snake_case__  :  str = "pytorch" ):
								"""simple docstring"""







								__lowerCAmelCase         =							self.get_auto_remove_tmp_dir()
								__lowerCAmelCase         =							os.path.join(snake_case__      ,				"output" )
								__lowerCAmelCase         =							os.path.join(snake_case__      ,				"data" )
								self._create_dummy_data(data_dir=snake_case__ )

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

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







							@require_torch_gpu
							def       UpperCAmelCase__					(						self  :  Any ):
								"""simple docstring"""







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







							@require_torch_multi_gpu
							def       UpperCAmelCase__					(						self  :  List[Any] ):
								"""simple docstring"""







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







							@require_torch_gpu
							@require_ray
							def       UpperCAmelCase__					(						self  :  Any ):
								"""simple docstring"""







								__lowerCAmelCase         =							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  :  Optional[Any] ):
								"""simple docstring"""







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








from collections import OrderedDict
from typing import Mapping

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


UpperCamelCase_   	=	logging.get_logger(__name__)

UpperCamelCase_   	=	{
    "distilbert-base-uncased": "https://huggingface.co/distilbert-base-uncased/resolve/main/config.json",
    "distilbert-base-uncased-distilled-squad": (
        "https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/config.json"
    ),
    "distilbert-base-cased": "https://huggingface.co/distilbert-base-cased/resolve/main/config.json",
    "distilbert-base-cased-distilled-squad": (
        "https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/config.json"
    ),
    "distilbert-base-german-cased": "https://huggingface.co/distilbert-base-german-cased/resolve/main/config.json",
    "distilbert-base-multilingual-cased": (
        "https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/config.json"
    ),
    "distilbert-base-uncased-finetuned-sst-2-english": (
        "https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english/resolve/main/config.json"
    ),
}

class       a		(   __UpperCAmelCase					):
							lowercase_		:						str   							=  'distilbert'
							lowercase_		:						Any   							=  {
							    'hidden_size': 'dim',
							    'num_attention_heads': 'n_heads',
							    'num_hidden_layers': 'n_layers',
							}







							def __init__(						self  :  Optional[int]      ,				snake_case__  :  int=30_522      ,				snake_case__  :  str=512      ,				snake_case__  :  Tuple=False      ,				snake_case__  :  Tuple=6      ,				snake_case__  :  Any=12      ,				snake_case__  :  Dict=768      ,				snake_case__  :  Any=4 * 768      ,				snake_case__  :  Union[str, Any]=0.1      ,				snake_case__  :  str=0.1      ,				snake_case__  :  Tuple="gelu"      ,				snake_case__  :  str=0.0_2      ,				snake_case__  :  Optional[Any]=0.1      ,				snake_case__  :  Optional[Any]=0.2      ,				snake_case__  :  str=0      ,				**snake_case__  :  Dict      ,				):
								"""simple docstring"""







								__lowerCAmelCase         =							vocab_size
								__lowerCAmelCase         =							max_position_embeddings
								__lowerCAmelCase         =							sinusoidal_pos_embds
								__lowerCAmelCase         =							n_layers
								__lowerCAmelCase         =							n_heads
								__lowerCAmelCase         =							dim
								__lowerCAmelCase         =							hidden_dim
								__lowerCAmelCase         =							dropout
								__lowerCAmelCase         =							attention_dropout
								__lowerCAmelCase         =							activation
								__lowerCAmelCase         =							initializer_range
								__lowerCAmelCase         =							qa_dropout
								__lowerCAmelCase         =							seq_classif_dropout
								super().__init__(**snake_case__      ,				pad_token_id=snake_case__ )

class       a		(   __UpperCAmelCase					):







							@property
							def       UpperCAmelCase__					(						self  :  Tuple ):
								"""simple docstring"""







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






