


from typing import Mapping

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


UpperCamelCase					:       Tuple			    =     logging.get_logger(__name__)

UpperCamelCase					:       List[Any]			    =     {
    """google/umt5-small""": """https://huggingface.co/google/umt5-small/resolve/main/config.json""",
    # See all umt5 models at https://huggingface.co/models?filter=umt5
}



class A__     ( A__  ):



  """simple docstring"""



  _lowercase									=		'umt5'
  _lowercase									=		['past_key_values']

  def __init__( self			:  Union[str, Any]				,				lowerCamelCase__			:  List[Any]=250_112				,				lowerCamelCase__			:  str=512				,				lowerCamelCase__			:  Optional[Any]=64				,				lowerCamelCase__			:  List[Any]=1_024				,				lowerCamelCase__			:  int=8				,				lowerCamelCase__			:  List[str]=None				,				lowerCamelCase__			:  Optional[Any]=6				,				lowerCamelCase__			:  int=32				,				lowerCamelCase__			:  Union[str, Any]=128				,				lowerCamelCase__			:  Tuple=0.1				,				lowerCamelCase__			:  Optional[Any]=1E-6				,				lowerCamelCase__			:  Union[str, Any]=1.0				,				lowerCamelCase__			:  Union[str, Any]="gated-gelu"				,				lowerCamelCase__			:  Any=True				,				lowerCamelCase__			:  List[str]=True				,				lowerCamelCase__			:  Any="T5Tokenizer"				,				lowerCamelCase__			:  Union[str, Any]=True				,				lowerCamelCase__			:  Optional[Any]=0				,				lowerCamelCase__			:  List[Any]=1				,				lowerCamelCase__			:  List[str]=0				,				**lowerCamelCase__			:  Any				,				):
        super().__init__(
            is_encoder_decoder=lowerCamelCase__				,				tokenizer_class=lowerCamelCase__				,				tie_word_embeddings=lowerCamelCase__				,				pad_token_id=lowerCamelCase__				,				eos_token_id=lowerCamelCase__				,				decoder_start_token_id=lowerCamelCase__				,				**lowerCamelCase__				,				)
        a__	:  Dict     =   vocab_size
        a__	:  List[Any]     =   d_model
        a__	:  Optional[Any]     =   d_kv
        a__	:  Optional[int]     =   d_ff
        a__	:  List[Any]     =   num_layers
        a__	:  int     =   (
            num_decoder_layers if num_decoder_layers is not None else self.num_layers
        )  # default = symmetry
        a__	:  str     =   num_heads
        a__	:  Optional[int]     =   relative_attention_num_buckets
        a__	:  Any     =   relative_attention_max_distance
        a__	:  int     =   dropout_rate
        a__	:  Union[str, Any]     =   layer_norm_epsilon
        a__	:  Optional[int]     =   initializer_factor
        a__	:  Optional[int]     =   feed_forward_proj
        a__	:  Tuple     =   use_cache

        a__	:  List[Any]     =   self.feed_forward_proj.split("-"       )
        a__	:  Optional[int]     =   act_info[-1]
        a__	:  Union[str, Any]     =   act_info[0] == "gated"

        if len(lowerCamelCase__       ) > 1 and act_info[0] != "gated" or len(lowerCamelCase__       ) > 2:
              raise ValueError(
                  f'''`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer.'''
                  "Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. "
                  "'gated-gelu' or 'relu'"       )

        if feed_forward_proj == "gated-gelu":
              a__	:  Optional[int]     =   "gelu_new"

  @property
  def    _UpperCamelCase( self			:  int       ):
        return self.d_model

  @property
  def    _UpperCamelCase( self			:  int       ):
        return self.num_heads

  @property
  def    _UpperCamelCase( self			:  Dict       ):
        return self.num_layers




class A__     ( A__  ):



  """simple docstring"""



  @property
  # Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.inputs
  def    _UpperCamelCase( self			:  Optional[Any]       ):
        a__	:  Dict     =   {
            "input_ids": {0: "batch", 1: "encoder_sequence"},
            "attention_mask": {0: "batch", 1: "encoder_sequence"},
        }
        if self.use_past:
              a__	:  Tuple     =   "past_encoder_sequence + sequence"
              a__	:  Dict     =   {0: "batch"}
              a__	:  Union[str, Any]     =   {0: "batch", 1: "past_decoder_sequence + sequence"}
        else:
              a__	:  Tuple     =   {0: "batch", 1: "decoder_sequence"}
              a__	:  List[str]     =   {0: "batch", 1: "decoder_sequence"}

        if self.use_past:
              self.fill_with_past_key_values_(lowerCamelCase__				,				direction="inputs"       )

        return common_inputs

  @property
  # Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.default_onnx_opset
  def    _UpperCamelCase( self			:  int       ):
        return 13

  @property
  def    _UpperCamelCase( self			:  List[str]       ):
        return 5E-4





import logging
import os
from dataclasses import dataclass
from typing import List, Optional, Union

import tqdm
from filelock import FileLock

from transformers import (
    BartTokenizer,
    BartTokenizerFast,
    DataProcessor,
    PreTrainedTokenizer,
    RobertaTokenizer,
    RobertaTokenizerFast,
    XLMRobertaTokenizer,
    is_tf_available,
    is_torch_available,
)


lowerCAmelCase__    :List[str]       =				logging.getLogger(__name__)

@dataclass(frozen=UpperCAmelCase     )
class 						__a :
		_a      :    str
		_a      :    str
		_a      :    Optional[str]           =      None
		_a      :    Optional[str]           =      None
		_a      :    Optional[str]           =      None



@dataclass(frozen=UpperCAmelCase     )
class 						__a :
		_a      :    List[int]
		_a      :    Optional[List[int]]           =      None
		_a      :    Optional[List[int]]           =      None
		_a      :    Optional[Union[int, float]]           =      None
		_a      :    Optional[int]           =      None


if is_torch_available():
		import torch
		from torch.utils.data import Dataset

		class 						__a (							UpperCAmelCase     ):
				_a      :    List[InputFeatures]
				def __init__(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE = None     ,       _SCREAMING_SNAKE_CASE=False     ,       _SCREAMING_SNAKE_CASE = False     ,       )					->			List[Any]:




											"""simple docstring"""





											_UpperCAmelCase											=     hans_processors[task]()

											_UpperCAmelCase											=     os.path.join(
											    _SCREAMING_SNAKE_CASE     ,       'cached_{}_{}_{}_{}'.format(
											        'dev' if evaluate else 'train'     ,       tokenizer.__class__.__name__     ,       str(_SCREAMING_SNAKE_CASE		)     ,       _SCREAMING_SNAKE_CASE     ,       )     ,       )
											_UpperCAmelCase											=     processor.get_labels()
											if tokenizer.__class__ in (
											    RobertaTokenizer,
											    RobertaTokenizerFast,
											    XLMRobertaTokenizer,
											    BartTokenizer,
											    BartTokenizerFast,
											):
																		# HACK(label indices are swapped in RoBERTa pretrained model)
																		_UpperCAmelCase						,			_UpperCAmelCase											=     label_list[2], label_list[1]
											_UpperCAmelCase											=     label_list

											# Make sure only the first process in distributed training processes the dataset,
											# and the others will use the cache.
											_UpperCAmelCase											=     cached_features_file + '.lock'
											with FileLock(_SCREAMING_SNAKE_CASE		):
																		if os.path.exists(_SCREAMING_SNAKE_CASE		) and not overwrite_cache:
																									logger.info(f'''Loading features from cached file {cached_features_file}'''		)
																									_UpperCAmelCase											=     torch.load(_SCREAMING_SNAKE_CASE		)
																		else:
																									logger.info(f'''Creating features from dataset file at {data_dir}'''		)

																									_UpperCAmelCase											=     (
																									    processor.get_dev_examples(_SCREAMING_SNAKE_CASE		) if evaluate else processor.get_train_examples(_SCREAMING_SNAKE_CASE		)
																									)

																									logger.info('Training examples: %s'     ,       len(_SCREAMING_SNAKE_CASE		)		)
																									_UpperCAmelCase											=     hans_convert_examples_to_features(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)
																									logger.info('Saving features into cached file %s'     ,       _SCREAMING_SNAKE_CASE		)
																									torch.save(self.features     ,       _SCREAMING_SNAKE_CASE		)
				def __len__(     self		)					->			List[str]:




											"""simple docstring"""





											return len(self.features		)
				def __getitem__(     self     ,       _SCREAMING_SNAKE_CASE		)					->			InputFeatures:




											"""simple docstring"""





											return self.features[i]






				def       UpperCAmelCase__							(     self		)					->			Optional[int]:




											"""simple docstring"""





											return self.label_list


if is_tf_available():
		import tensorflow as tf

		class 						__a :
				_a      :    List[InputFeatures]
				def __init__(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE = 128     ,       _SCREAMING_SNAKE_CASE=False     ,       _SCREAMING_SNAKE_CASE = False     ,       )					->			Tuple:




											"""simple docstring"""





											_UpperCAmelCase											=     hans_processors[task]()
											_UpperCAmelCase											=     processor.get_labels()
											if tokenizer.__class__ in (
											    RobertaTokenizer,
											    RobertaTokenizerFast,
											    XLMRobertaTokenizer,
											    BartTokenizer,
											    BartTokenizerFast,
											):
																		# HACK(label indices are swapped in RoBERTa pretrained model)
																		_UpperCAmelCase						,			_UpperCAmelCase											=     label_list[2], label_list[1]
											_UpperCAmelCase											=     label_list

											_UpperCAmelCase											=     processor.get_dev_examples(_SCREAMING_SNAKE_CASE		) if evaluate else processor.get_train_examples(_SCREAMING_SNAKE_CASE		)
											_UpperCAmelCase											=     hans_convert_examples_to_features(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

											def gen():
																		for ex_index, ex in tqdm.tqdm(enumerate(self.features		)     ,       desc='convert examples to features'		):
																									if ex_index % 10000 == 0:
																																logger.info('Writing example %d of %d' % (ex_index, len(_SCREAMING_SNAKE_CASE		))		)

																									yield (
																									    {
																									        "example_id": 0,
																									        "input_ids": ex.input_ids,
																									        "attention_mask": ex.attention_mask,
																									        "token_type_ids": ex.token_type_ids,
																									    },
																									    ex.label,
																									)

											_UpperCAmelCase											=     tf.data.Dataset.from_generator(
											    _SCREAMING_SNAKE_CASE     ,       (
											        {
											            'example_id': tf.intaa,
											            'input_ids': tf.intaa,
											            'attention_mask': tf.intaa,
											            'token_type_ids': tf.intaa,
											        },
											        tf.intaa,
											    )     ,       (
											        {
											            'example_id': tf.TensorShape([]		),
											            'input_ids': tf.TensorShape([None, None]		),
											            'attention_mask': tf.TensorShape([None, None]		),
											            'token_type_ids': tf.TensorShape([None, None]		),
											        },
											        tf.TensorShape([]		),
											    )     ,       )
				def       UpperCAmelCase__							(     self		)					->			Dict:




											"""simple docstring"""





											return self.dataset
				def __len__(     self		)					->			List[Any]:




											"""simple docstring"""





											return len(self.features		)
				def __getitem__(     self     ,       _SCREAMING_SNAKE_CASE		)					->			InputFeatures:




											"""simple docstring"""





											return self.features[i]






				def       UpperCAmelCase__							(     self		)					->			List[Any]:




											"""simple docstring"""





											return self.label_list

class 						__a (							UpperCAmelCase     ):
		def       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE		)					->			List[Any]:




									"""simple docstring"""





									return self._create_examples(self._read_tsv(os.path.join(_SCREAMING_SNAKE_CASE     ,       'heuristics_train_set.txt'		)		)     ,       'train'		)
		def       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE		)					->			Union[str, Any]:




									"""simple docstring"""





									return self._create_examples(self._read_tsv(os.path.join(_SCREAMING_SNAKE_CASE     ,       'heuristics_evaluation_set.txt'		)		)     ,       'dev'		)
		def       UpperCAmelCase__							(     self		)					->			List[str]:




									"""simple docstring"""





									return ["contradiction", "entailment", "neutral"]






		def       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)					->			Any:




									"""simple docstring"""





									_UpperCAmelCase											=     []
									for i, line in enumerate(_SCREAMING_SNAKE_CASE		):
																if i == 0:
																							continue
																_UpperCAmelCase											=     '%s-%s' % (set_type, line[0])
																_UpperCAmelCase											=     line[5]
																_UpperCAmelCase											=     line[6]
																_UpperCAmelCase											=     line[7][2:] if line[7].startswith('ex'		) else line[7]
																_UpperCAmelCase											=     line[0]
																examples.append(InputExample(guid=_SCREAMING_SNAKE_CASE     ,       text_a=_SCREAMING_SNAKE_CASE     ,       text_b=_SCREAMING_SNAKE_CASE     ,       label=_SCREAMING_SNAKE_CASE     ,       pairID=_SCREAMING_SNAKE_CASE		)		)
									return examples



def 			lowerCAmelCase__					(     a__:						List[InputExample]     ,    a__:						List[str]     ,    a__:						int     ,    a__:						PreTrainedTokenizer     ,    )    ->						str:


							'''simple docstring'''





							_UpperCAmelCase											=     {label: i for i, label in enumerate(a__			)}

							_UpperCAmelCase											=     []
							for ex_index, example in tqdm.tqdm(enumerate(a__			)     ,    desc='convert examples to features'			):
														if ex_index % 1_0_0_0_0 == 0:
																					logger.info('Writing example %d' % (ex_index)			)

														_UpperCAmelCase											=     tokenizer(
														    example.text_a     ,    example.text_b     ,    add_special_tokens=a__     ,    max_length=a__     ,    padding='max_length'     ,    truncation=a__     ,    return_overflowing_tokens=a__     ,    )

														_UpperCAmelCase											=     label_map[example.label] if example.label in label_map else 0

														_UpperCAmelCase											=     int(example.pairID			)

														features.append(InputFeatures(**a__     ,    label=a__     ,    pairID=a__			)			)

							for i, example in enumerate(examples[:5]			):
														logger.info('*** Example ***'			)
														logger.info(F'''guid: {example}'''			)
														logger.info(F'''features: {features[i]}'''			)

							return features


lowerCAmelCase__    :Optional[Any]       =				{
    '''hans''': 3,
}







lowerCAmelCase__    :Optional[int]       =				{
    '''hans''': HansProcessor,
}
