


'''simple docstring'''

from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


__lowercase:		int    						=  logging.get_logger(__name__)

__lowercase:		Tuple    						=  {
    "facebook/mbart-large-cc25": "https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json",
    # See all MBART models at https://huggingface.co/models?filter=mbart
}







class 			UpperCAmelCase			(							SCREAMING_SNAKE_CASE__):
 _lowerCamelCase			:       List[str]            =       'mbart'
 _lowerCamelCase			:       str            =       ['past_key_values']
 _lowerCamelCase			:       List[str]            =       {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}

 def __init__(			self			:						Tuple,       a_			:						Union[str, Any]=5_0265,       a_			:						Union[str, Any]=1024,       a_			:						Optional[int]=12,       a_			:						str=4096,       a_			:						Optional[Any]=16,       a_			:						str=12,       a_			:						Union[str, Any]=4096,       a_			:						List[Any]=16,       a_			:						Optional[Any]=0.0,       a_			:						int=0.0,       a_			:						Any=True,       a_			:						Optional[Any]=True,       a_			:						Any="gelu",       a_			:						int=1024,       a_			:						Any=0.1,       a_			:						Optional[int]=0.0,       a_			:						Tuple=0.0,       a_			:						Optional[Any]=0.02,       a_			:						Any=0.0,       a_			:						Optional[Any]=False,       a_			:						Any=1,       a_			:						Optional[Any]=0,       a_			:						List[str]=2,       a_			:						Any=2,       **a_			:						int,       ):





    """simple docstring"""



    UpperCamelCase__			    =    vocab_size
    UpperCamelCase__			    =    max_position_embeddings
    UpperCamelCase__			    =    d_model
    UpperCamelCase__			    =    encoder_ffn_dim
    UpperCamelCase__			    =    encoder_layers
    UpperCamelCase__			    =    encoder_attention_heads
    UpperCamelCase__			    =    decoder_ffn_dim
    UpperCamelCase__			    =    decoder_layers
    UpperCamelCase__			    =    decoder_attention_heads
    UpperCamelCase__			    =    dropout
    UpperCamelCase__			    =    attention_dropout
    UpperCamelCase__			    =    activation_dropout
    UpperCamelCase__			    =    activation_function
    UpperCamelCase__			    =    init_std
    UpperCamelCase__			    =    encoder_layerdrop
    UpperCamelCase__			    =    decoder_layerdrop
    UpperCamelCase__			    =    classifier_dropout
    UpperCamelCase__			    =    use_cache
    UpperCamelCase__			    =    encoder_layers
    UpperCamelCase__			    =    scale_embedding  # scale factor will be sqrt(d_model) if True
    super().__init__(
        pad_token_id=a_,       bos_token_id=a_,       eos_token_id=a_,       is_encoder_decoder=a_,       forced_eos_token_id=a_,       **a_,       )







class 			UpperCAmelCase			(							SCREAMING_SNAKE_CASE__):

 @property
 def 		lowercase_    (			self			:						Optional[Any]       ):





    """simple docstring"""



    if self.task in ["default", "seq2seq-lm"]:
       UpperCamelCase__			    =    OrderedDict(
           [
               ("input_ids", {0: "batch", 1: "encoder_sequence"}),
               ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
           ]       )

       if self.use_past:
          UpperCamelCase__			    =    {0: "batch"}
          UpperCamelCase__			    =    {0: "batch", 1: "past_decoder_sequence + sequence"}
       else:
          UpperCamelCase__			    =    {0: "batch", 1: "decoder_sequence"}
          UpperCamelCase__			    =    {0: "batch", 1: "decoder_sequence"}

       if self.use_past:
          self.fill_with_past_key_values_(a_,       direction="inputs"       )
    elif self.task == "causal-lm":
       # TODO: figure this case out.
       UpperCamelCase__			    =    OrderedDict(
           [
               ("input_ids", {0: "batch", 1: "encoder_sequence"}),
               ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
           ]       )
       if self.use_past:
          UpperCamelCase__    ,		UpperCamelCase__			    =    self.num_layers
          for i in range(a_       ):
             UpperCamelCase__			    =    {0: "batch", 2: "past_sequence + sequence"}
             UpperCamelCase__			    =    {0: "batch", 2: "past_sequence + sequence"}
    else:
       UpperCamelCase__			    =    OrderedDict(
           [
               ("input_ids", {0: "batch", 1: "encoder_sequence"}),
               ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
               ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
               ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
           ]       )

    return common_inputs

 @property
 def 		lowercase_    (			self			:						Any       ):





    """simple docstring"""



    if self.task in ["default", "seq2seq-lm"]:
       UpperCamelCase__			    =    super().outputs
    else:
       UpperCamelCase__			    =    super(a_,       self       ).outputs
       if self.use_past:
          UpperCamelCase__    ,		UpperCamelCase__			    =    self.num_layers
          for i in range(a_       ):
             UpperCamelCase__			    =    {0: "batch", 2: "past_sequence + sequence"}
             UpperCamelCase__			    =    {0: "batch", 2: "past_sequence + sequence"}
    return common_outputs

 def 		lowercase_    (			self			:						str,       a_			:						PreTrainedTokenizer,       a_			:						int = -1,       a_			:						int = -1,       a_			:						bool = False,       a_			:						Optional[TensorType] = None,       ):





    """simple docstring"""



    UpperCamelCase__			    =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        a_,       a_,       a_,       a_,       a_       )

    # Generate decoder inputs
    UpperCamelCase__			    =    seq_length if not self.use_past else 1
    UpperCamelCase__			    =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        a_,       a_,       a_,       a_,       a_       )
    UpperCamelCase__			    =    {f'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
    UpperCamelCase__			    =    dict(**a_,       **a_       )

    if self.use_past:
       if not is_torch_available():
          raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."       )
       else:
          import torch
       UpperCamelCase__    ,		UpperCamelCase__			    =    common_inputs["input_ids"].shape
       UpperCamelCase__			    =    common_inputs["decoder_input_ids"].shape[1]
       UpperCamelCase__    ,		UpperCamelCase__			    =    self.num_attention_heads
       UpperCamelCase__			    =    (
           batch,
           num_encoder_attention_heads,
           encoder_seq_length,
           self._config.hidden_size // num_encoder_attention_heads,
       )
       UpperCamelCase__			    =    decoder_seq_length + 3
       UpperCamelCase__			    =    (
           batch,
           num_decoder_attention_heads,
           decoder_past_length,
           self._config.hidden_size // num_decoder_attention_heads,
       )

       UpperCamelCase__			    =    torch.cat(
           [common_inputs["decoder_attention_mask"], torch.ones(a_,       a_       )],       dim=1       )

       UpperCamelCase__			    =    []
       # If the number of encoder and decoder layers are present in the model configuration, both are considered
       UpperCamelCase__    ,		UpperCamelCase__			    =    self.num_layers
       UpperCamelCase__			    =    min(a_,       a_       )
       UpperCamelCase__			    =    max(a_,       a_       ) - min_num_layers
       UpperCamelCase__			    =    "encoder" if num_encoder_layers > num_decoder_layers else "decoder"

       for _ in range(a_       ):
          common_inputs["past_key_values"].append(
              (
                  torch.zeros(a_       ),
                  torch.zeros(a_       ),
                  torch.zeros(a_       ),
                  torch.zeros(a_       ),
              )       )
       # TODO: test this.
       UpperCamelCase__			    =    encoder_shape if remaining_side_name == "encoder" else decoder_shape
       for _ in range(a_,       a_       ):
          common_inputs["past_key_values"].append((torch.zeros(a_       ), torch.zeros(a_       ))       )
    return common_inputs

 def 		lowercase_    (			self			:						Optional[int],       a_			:						PreTrainedTokenizer,       a_			:						int = -1,       a_			:						int = -1,       a_			:						bool = False,       a_			:						Optional[TensorType] = None,       ):





    """simple docstring"""



    UpperCamelCase__			    =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        a_,       a_,       a_,       a_,       a_       )

    if self.use_past:
       if not is_torch_available():
          raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."       )
       else:
          import torch
       UpperCamelCase__    ,		UpperCamelCase__			    =    common_inputs["input_ids"].shape
       # Not using the same length for past_key_values
       UpperCamelCase__			    =    seqlen + 2
       UpperCamelCase__    ,		UpperCamelCase__			    =    self.num_layers
       UpperCamelCase__    ,		UpperCamelCase__			    =    self.num_attention_heads
       UpperCamelCase__			    =    (
           batch,
           num_encoder_attention_heads,
           past_key_values_length,
           self._config.hidden_size // num_encoder_attention_heads,
       )

       UpperCamelCase__			    =    common_inputs["attention_mask"].dtype
       UpperCamelCase__			    =    torch.cat(
           [common_inputs["attention_mask"], torch.ones(a_,       a_,       dtype=a_       )],       dim=1       )
       UpperCamelCase__			    =    [
           (torch.zeros(a_       ), torch.zeros(a_       )) for _ in range(a_       )
       ]
    return common_inputs

 def 		lowercase_    (			self			:						List[Any],       a_			:						PreTrainedTokenizer,       a_			:						int = -1,       a_			:						int = -1,       a_			:						bool = False,       a_			:						Optional[TensorType] = None,       ):





    """simple docstring"""



    UpperCamelCase__			    =    compute_effective_axis_dimension(
        a_,       fixed_dimension=OnnxConfig.default_fixed_batch,       num_token_to_add=0       )

    # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
    UpperCamelCase__			    =    tokenizer.num_special_tokens_to_add(a_       )
    UpperCamelCase__			    =    compute_effective_axis_dimension(
        a_,       fixed_dimension=OnnxConfig.default_fixed_sequence,       num_token_to_add=a_       )

    # Generate dummy inputs according to compute batch and sequence
    UpperCamelCase__			    =    [" ".join([tokenizer.unk_token]       ) * seq_length] * batch_size
    UpperCamelCase__			    =    dict(tokenizer(a_,       return_tensors=a_       )       )
    return common_inputs

 def 		lowercase_    (			self			:						Union[str, Any],       a_			:						PreTrainedTokenizer,       a_			:						int = -1,       a_			:						int = -1,       a_			:						bool = False,       a_			:						Optional[TensorType] = None,       ):





    """simple docstring"""



    if self.task in ["default", "seq2seq-lm"]:
       UpperCamelCase__			    =    self._generate_dummy_inputs_for_default_and_seqaseq_lm(
           a_,       batch_size=a_,       seq_length=a_,       is_pair=a_,       framework=a_       )

    elif self.task == "causal-lm":
       UpperCamelCase__			    =    self._generate_dummy_inputs_for_causal_lm(
           a_,       batch_size=a_,       seq_length=a_,       is_pair=a_,       framework=a_       )
    else:
       UpperCamelCase__			    =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           a_,       batch_size=a_,       seq_length=a_,       is_pair=a_,       framework=a_       )

    return common_inputs

 def 		lowercase_    (			self			:						Dict,       a_			:						int,       a_			:						str,       a_			:						List[Any],       a_			:						int       ):





    """simple docstring"""



    if self.task in ["default", "seq2seq-lm"]:
       UpperCamelCase__			    =    super()._flatten_past_key_values_(a_,       a_,       a_,       a_       )
    else:
       UpperCamelCase__			    =    super(a_,       self       )._flatten_past_key_values_(
           a_,       a_,       a_,       a_       )



'''simple docstring'''

import csv
import json
import os

import datasets


# TODO: Add BibTeX citation
# Find for instance the citation on arxiv or on the dataset repo/website
__lowercase:		Tuple    						=  "\\n@InProceedings{huggingface:dataset,\ntitle = {A great new dataset},\nauthor={huggingface, Inc.\n},\nyear={2020}\n}\n"

# TODO: Add description of the dataset here
# You can copy an official description
__lowercase:		Optional[int]    						=  "\\nThis new dataset is designed to solve this great NLP task and is crafted with a lot of care.\n"

# TODO: Add a link to an official homepage for the dataset here
__lowercase:		List[str]    						=  ""

# TODO: Add the licence for the dataset here if you can find it
__lowercase:		List[Any]    						=  ""

# TODO: Add link to the official dataset URLs here
# The HuggingFace Datasets library doesn't host the datasets but only points to the original files.
# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
__lowercase:		List[str]    						=  {
    "first_domain": "https://huggingface.co/great-new-dataset-first_domain.zip",
    "second_domain": "https://huggingface.co/great-new-dataset-second_domain.zip",
}







class 			UpperCAmelCase			(							datasets.GeneratorBasedBuilder):
 _lowerCamelCase			:       List[str]            =       datasets.Version('1.1.0')

 # This is an example of a dataset with multiple configurations.
 # If you don't want/need to define several sub-sets in your dataset,
 # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.

 # If you need to make complex sub-parts in the datasets with configurable options
 # You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
 # BUILDER_CONFIG_CLASS = MyBuilderConfig

 # You will be able to load one or the other configurations in the following list with
 # data = datasets.load_dataset('my_dataset', 'first_domain')
 # data = datasets.load_dataset('my_dataset', 'second_domain')
 _lowerCamelCase			:       Dict            =       [
     datasets.BuilderConfig(name='first_domain'		,      version=SCREAMING_SNAKE_CASE__		,      description='This part of my dataset covers a first domain'),
     datasets.BuilderConfig(name='second_domain'		,      version=SCREAMING_SNAKE_CASE__		,      description='This part of my dataset covers a second domain'),
 ]

 _lowerCamelCase			:       Any            =       'first_domain'  # It's not mandatory to have a default configuration. Just use one if it make sense.

 def 		lowercase_    (			self			:						List[str]       ):





    """simple docstring"""



    if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
       UpperCamelCase__			    =    datasets.Features(
           {
               "sentence": datasets.Value("string"       ),
               "option1": datasets.Value("string"       ),
               "answer": datasets.Value("string"       )
               # These are the features of your dataset like images, labels ...
           }       )
    else:  # This is an example to show how to have different features for "first_domain" and "second_domain"
       UpperCamelCase__			    =    datasets.Features(
           {
               "sentence": datasets.Value("string"       ),
               "option2": datasets.Value("string"       ),
               "second_domain_answer": datasets.Value("string"       )
               # These are the features of your dataset like images, labels ...
           }       )
    return datasets.DatasetInfo(
        # This is the description that will appear on the datasets page.
        description=_DESCRIPTION,       features=a_,       homepage=_HOMEPAGE,       license=_LICENSE,       citation=_CITATION,       )

 def 		lowercase_    (			self			:						Any,       a_			:						Union[str, Any]       ):





    """simple docstring"""



    UpperCamelCase__			    =    _URLS[self.config.name]
    UpperCamelCase__			    =    dl_manager.download_and_extract(a_       )
    return [
        datasets.SplitGenerator(
            name=datasets.Split.TRAIN,       gen_kwargs={
                "filepath": os.path.join(a_,       "train.jsonl"       ),
                "split": "train",
            },       ),
        datasets.SplitGenerator(
            name=datasets.Split.VALIDATION,       gen_kwargs={
                "filepath": os.path.join(a_,       "dev.jsonl"       ),
                "split": "dev",
            },       ),
        datasets.SplitGenerator(
            name=datasets.Split.TEST,       gen_kwargs={
                "filepath": os.path.join(a_,       "test.jsonl"       ),
                "split": "test"
            },       ),
    ]

 def 		lowercase_    (			self			:						str,       a_			:						Optional[Any],       a_			:						Tuple       ):





    """simple docstring"""



    with open(a_,       encoding="utf-8"       ) as f:
       for key, row in enumerate(a_       ):
          UpperCamelCase__			    =    json.loads(a_       )
          if self.config.name == "first_domain":
             # Yields examples as (key, example) tuples
             yield key, {
                 "sentence": data["sentence"],
                 "option1": data["option1"],
                 "answer": "" if split == "test" else data["answer"],
             }
          else:
             yield key, {
                 "sentence": data["sentence"],
                 "option2": data["option2"],
                 "second_domain_answer": "" if split == "test" else data["second_domain_answer"],
             }