





import tempfile
import unittest

import numpy as np

import transformers
from transformers import GPTaConfig, GPTaTokenizer, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
					import jax
					import jax.numpy as jnp

					from transformers.modeling_flax_pytorch_utils import (
					    convert_pytorch_state_dict_to_flax,
					    load_flax_weights_in_pytorch_model,
					)
					from transformers.models.gpta.modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel

if is_torch_available():
					import torch




class 			_lowerCamelCase	:



						"""simple docstring"""






						def __init__(	self			,  UpperCAmelCase			,  UpperCAmelCase=14			,  UpperCAmelCase=7			,  UpperCAmelCase=True			,  UpperCAmelCase=True			,  UpperCAmelCase=False			,  UpperCAmelCase=True			,  UpperCAmelCase=99			,  UpperCAmelCase=32			,  UpperCAmelCase=5			,  UpperCAmelCase=4			,  UpperCAmelCase=37			,  UpperCAmelCase="gelu"			,  UpperCAmelCase=0.1			,  UpperCAmelCase=0.1			,  UpperCAmelCase=512			,  UpperCAmelCase=0.02			,  )    ->				str:






								'''simple docstring'''






								__snake_case				:			Any            =    parent
								__snake_case				:			Any            =    batch_size
								__snake_case				:			Tuple            =    seq_length
								__snake_case				:			Dict            =    is_training
								__snake_case				:			List[Any]            =    use_input_mask
								__snake_case				:			Optional[Any]            =    use_token_type_ids
								__snake_case				:			Tuple            =    use_labels
								__snake_case				:			Optional[int]            =    vocab_size
								__snake_case				:			Optional[int]            =    hidden_size
								__snake_case				:			List[Any]            =    num_hidden_layers
								__snake_case				:			List[Any]            =    num_attention_heads
								__snake_case				:			Any            =    intermediate_size
								__snake_case				:			Dict            =    hidden_act
								__snake_case				:			List[str]            =    hidden_dropout_prob
								__snake_case				:			Optional[Any]            =    attention_probs_dropout_prob
								__snake_case				:			Tuple            =    max_position_embeddings
								__snake_case				:			Union[str, Any]            =    initializer_range
								__snake_case				:			List[Any]            =    None
								__snake_case				:			List[str]            =    vocab_size - 1
								__snake_case				:			List[Any]            =    vocab_size - 1
								__snake_case				:			Optional[Any]            =    vocab_size - 1







						def   UpperCAmelCase						(	self				)    ->				Union[str, Any]:






								'''simple docstring'''






								__snake_case				:			Optional[Any]            =    ids_tensor([self.batch_size, self.seq_length]			,  self.vocab_size				)

								__snake_case				:			Optional[int]            =    None
								if self.use_input_mask:
										__snake_case				:			Optional[Any]            =    random_attention_mask([self.batch_size, self.seq_length]				)

								__snake_case				:			Any            =    GPTaConfig(
								    vocab_size=self.vocab_size			,  n_embd=self.hidden_size			,  n_layer=self.num_hidden_layers			,  n_head=self.num_attention_heads			,  n_positions=self.max_position_embeddings			,  use_cache=UpperCAmelCase			,  bos_token_id=self.bos_token_id			,  eos_token_id=self.eos_token_id			,  pad_token_id=self.pad_token_id			,  )

								return (config, input_ids, input_mask)







						def   UpperCAmelCase						(	self				)    ->				Any:






								'''simple docstring'''






								__snake_case				:			List[str]            =    self.prepare_config_and_inputs()
								__snake_case				:			Union[str, Any]            =    config_and_inputs
								__snake_case				:			Optional[int]            =    {"input_ids": input_ids, "attention_mask": attention_mask}
								return config, inputs_dict







						def   UpperCAmelCase						(	self				)    ->				int:






								'''simple docstring'''






								__snake_case				:			Dict            =    self.prepare_config_and_inputs()

								__snake_case				:			Dict            =    floats_tensor([self.batch_size, self.seq_length, self.hidden_size]				)
								__snake_case				:			List[Any]            =    ids_tensor([self.batch_size, self.seq_length]			,  vocab_size=2				)

								return (
								    config,
								    input_ids,
								    attention_mask,
								    encoder_hidden_states,
								    encoder_attention_mask,
								)







						def   UpperCAmelCase						(	self			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase				)    ->				List[str]:






								'''simple docstring'''






								__snake_case				:			str            =    20
								__snake_case				:			Any            =    model_class_name(UpperCAmelCase				)

								__snake_case				:			Optional[int]            =    model.init_cache(input_ids.shape[0]			,  UpperCAmelCase				)
								__snake_case				:			Optional[Any]            =    jnp.ones((input_ids.shape[0], max_decoder_length)			,  dtype="i4"				)

								__snake_case				:			List[str]            =    jnp.broadcast_to(
								    jnp.arange(input_ids.shape[-1] - 1				)[None, :]			,  (input_ids.shape[0], input_ids.shape[-1] - 1)				)
								__snake_case				:			Any            =    model(
								    input_ids[:, :-1]			,  attention_mask=UpperCAmelCase			,  past_key_values=UpperCAmelCase			,  position_ids=UpperCAmelCase			,  )

								__snake_case				:			List[Any]            =    jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]			,  dtype="i4"				)
								__snake_case				:			Optional[int]            =    model(
								    input_ids[:, -1:]			,  attention_mask=UpperCAmelCase			,  past_key_values=outputs_cache.past_key_values			,  position_ids=UpperCAmelCase			,  )

								__snake_case				:			List[Any]            =    model(UpperCAmelCase				)

								__snake_case				:			Dict            =    np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])				)				)
								self.parent.assertTrue(diff < 1E-3			,  msg=F"""Max diff is {diff}"""				)







						def   UpperCAmelCase						(	self			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase				)    ->				Optional[Any]:






								'''simple docstring'''






								__snake_case				:			Optional[Any]            =    20
								__snake_case				:			Optional[int]            =    model_class_name(UpperCAmelCase				)

								__snake_case				:			str            =    jnp.concatenate(
								    [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])				)]			,  axis=-1			,  )

								__snake_case				:			str            =    model.init_cache(input_ids.shape[0]			,  UpperCAmelCase				)
								__snake_case				:			str            =    jnp.broadcast_to(
								    jnp.arange(input_ids.shape[-1] - 1				)[None, :]			,  (input_ids.shape[0], input_ids.shape[-1] - 1)				)

								__snake_case				:			int            =    model(
								    input_ids[:, :-1]			,  attention_mask=UpperCAmelCase			,  past_key_values=UpperCAmelCase			,  position_ids=UpperCAmelCase			,  )
								__snake_case				:			Optional[int]            =    jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]			,  dtype="i4"				)
								__snake_case				:			str            =    model(
								    input_ids[:, -1:]			,  past_key_values=outputs_cache.past_key_values			,  attention_mask=UpperCAmelCase			,  position_ids=UpperCAmelCase			,  )

								__snake_case				:			List[Any]            =    model(UpperCAmelCase			,  attention_mask=UpperCAmelCase				)

								__snake_case				:			Optional[int]            =    np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])				)				)
								self.parent.assertTrue(diff < 1E-3			,  msg=F"""Max diff is {diff}"""				)




@require_flax
class 			_lowerCamelCase	(      a	,				a	,				unittest.TestCase      ):



						"""simple docstring"""






						UpperCAmelCase_  : List[str]				      =(FlaxGPTaModel, FlaxGPTaLMHeadModel) if is_flax_available() else ()
						UpperCAmelCase_  : Tuple				      =(FlaxGPTaLMHeadModel,) if is_flax_available() else ()







						def   UpperCAmelCase						(	self				)    ->				Optional[Any]:






								'''simple docstring'''






								__snake_case				:			List[Any]            =    FlaxGPTaModelTester(self				)







						def   UpperCAmelCase						(	self				)    ->				List[str]:






								'''simple docstring'''






								for model_class_name in self.all_model_classes:
										__snake_case				:			List[Any]            =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.check_use_cache_forward(UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase				)







						def   UpperCAmelCase						(	self				)    ->				str:






								'''simple docstring'''






								for model_class_name in self.all_model_classes:
										__snake_case				:			List[Any]            =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.check_use_cache_forward_with_attn_mask(
										    UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase				)







						@slow
						def   UpperCAmelCase						(	self				)    ->				Optional[Any]:






								'''simple docstring'''






								__snake_case				:			int            =    GPTaTokenizer.from_pretrained("gpt2"			,  pad_token="</s>"			,  padding_side="left"				)
								__snake_case				:			Tuple            =    tokenizer(["Hello this is a long string", "Hey"]			,  return_tensors="np"			,  padding=UpperCAmelCase			,  truncation=UpperCAmelCase				)

								__snake_case				:			Any            =    FlaxGPTaLMHeadModel.from_pretrained("gpt2"				)
								__snake_case				:			int            =    False
								__snake_case				:			Optional[int]            =    model.config.eos_token_id

								__snake_case				:			int            =    jax.jit(model.generate				)

								__snake_case				:			Union[str, Any]            =    jit_generate(inputs["input_ids"]			,  attention_mask=inputs["attention_mask"]				).sequences

								__snake_case				:			Optional[int]            =    tokenizer.batch_decode(UpperCAmelCase			,  skip_special_tokens=UpperCAmelCase				)

								__snake_case				:			Optional[int]            =    [
								    "Hello this is a long string of words. I'm going to start with the first one.\n",
								    "Hey, I'm not sure if I'm going to be able to do",
								]

								self.assertListEqual(UpperCAmelCase			,  UpperCAmelCase				)







						@is_pt_flax_cross_test
						def   UpperCAmelCase						(	self				)    ->				Union[str, Any]:






								'''simple docstring'''






								__snake_case				:			Tuple            =    self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										with self.subTest(model_class.__name__				):
												# prepare inputs
												__snake_case				:			List[str]            =    self._prepare_for_class(UpperCAmelCase			,  UpperCAmelCase				)
												__snake_case				:			Optional[int]            =    {k: torch.tensor(v.tolist()				) for k, v in prepared_inputs_dict.items()}

												# load corresponding PyTorch class
												__snake_case				:			Union[str, Any]            =    model_class.__name__[4:]  # Skip the "Flax" at the beginning
												__snake_case				:			Any            =    getattr(UpperCAmelCase			,  UpperCAmelCase				)

												__snake_case				:			Optional[Any]            =    pt_inputs["input_ids"].shape
												__snake_case				:			List[str]            =    np.random.randint(0			,  seq_length - 1			,  size=(batch_size,)				)
												for batch_idx, start_index in enumerate(UpperCAmelCase				):
														__snake_case				:			Tuple            =    0
														__snake_case				:			Any            =    1
														__snake_case				:			int            =    0
														__snake_case				:			int            =    1
												__snake_case				:			Optional[int]            =    pt_model_class(UpperCAmelCase				).eval()
												__snake_case				:			str            =    model_class(UpperCAmelCase			,  dtype=jnp.floataa				)

												__snake_case				:			Optional[Any]            =    convert_pytorch_state_dict_to_flax(pt_model.state_dict()			,  UpperCAmelCase				)
												__snake_case				:			Dict            =    fx_state

												with torch.no_grad():
														__snake_case				:			List[Any]            =    pt_model(**UpperCAmelCase				).to_tuple()

												__snake_case				:			Optional[int]            =    fx_model(**UpperCAmelCase				).to_tuple()
												self.assertEqual(len(UpperCAmelCase				)			,  len(UpperCAmelCase				)			,  "Output lengths differ between Flax and PyTorch"				)
												for fx_output, pt_output in zip(UpperCAmelCase			,  UpperCAmelCase				):
														self.assert_almost_equals(fx_output[:, -1]			,  pt_output[:, -1].numpy()			,  4E-2				)

												with tempfile.TemporaryDirectory() as tmpdirname:
														pt_model.save_pretrained(UpperCAmelCase				)
														__snake_case				:			Union[str, Any]            =    model_class.from_pretrained(UpperCAmelCase			,  from_pt=UpperCAmelCase				)

												__snake_case				:			Tuple            =    fx_model_loaded(**UpperCAmelCase				).to_tuple()
												self.assertEqual(
												    len(UpperCAmelCase				)			,  len(UpperCAmelCase				)			,  "Output lengths differ between Flax and PyTorch"				)
												for fx_output_loaded, pt_output in zip(UpperCAmelCase			,  UpperCAmelCase				):
														self.assert_almost_equals(fx_output_loaded[:, -1]			,  pt_output[:, -1].numpy()			,  4E-2				)







						@is_pt_flax_cross_test
						def   UpperCAmelCase						(	self				)    ->				Optional[Any]:






								'''simple docstring'''






								__snake_case				:			int            =    self.model_tester.prepare_config_and_inputs_for_common()
								for model_class in self.all_model_classes:
										with self.subTest(model_class.__name__				):
												# prepare inputs
												__snake_case				:			List[str]            =    self._prepare_for_class(UpperCAmelCase			,  UpperCAmelCase				)
												__snake_case				:			List[Any]            =    {k: torch.tensor(v.tolist()				) for k, v in prepared_inputs_dict.items()}

												# load corresponding PyTorch class
												__snake_case				:			Union[str, Any]            =    model_class.__name__[4:]  # Skip the "Flax" at the beginning
												__snake_case				:			Any            =    getattr(UpperCAmelCase			,  UpperCAmelCase				)

												__snake_case				:			Any            =    pt_model_class(UpperCAmelCase				).eval()
												__snake_case				:			Optional[int]            =    model_class(UpperCAmelCase			,  dtype=jnp.floataa				)

												__snake_case				:			Optional[int]            =    load_flax_weights_in_pytorch_model(UpperCAmelCase			,  fx_model.params				)
												__snake_case				:			Dict            =    pt_inputs["input_ids"].shape
												__snake_case				:			str            =    np.random.randint(0			,  seq_length - 1			,  size=(batch_size,)				)
												for batch_idx, start_index in enumerate(UpperCAmelCase				):
														__snake_case				:			Optional[int]            =    0
														__snake_case				:			List[str]            =    1
														__snake_case				:			Tuple            =    0
														__snake_case				:			Optional[Any]            =    1

												# make sure weights are tied in PyTorch
												pt_model.tie_weights()

												with torch.no_grad():
														__snake_case				:			Any            =    pt_model(**UpperCAmelCase				).to_tuple()

												__snake_case				:			Tuple            =    fx_model(**UpperCAmelCase				).to_tuple()
												self.assertEqual(len(UpperCAmelCase				)			,  len(UpperCAmelCase				)			,  "Output lengths differ between Flax and PyTorch"				)
												for fx_output, pt_output in zip(UpperCAmelCase			,  UpperCAmelCase				):
														self.assert_almost_equals(fx_output[:, -1]			,  pt_output[:, -1].numpy()			,  4E-2				)

												with tempfile.TemporaryDirectory() as tmpdirname:
														fx_model.save_pretrained(UpperCAmelCase				)
														__snake_case				:			int            =    pt_model_class.from_pretrained(UpperCAmelCase			,  from_flax=UpperCAmelCase				)

												with torch.no_grad():
														__snake_case				:			Any            =    pt_model_loaded(**UpperCAmelCase				).to_tuple()

												self.assertEqual(
												    len(UpperCAmelCase				)			,  len(UpperCAmelCase				)			,  "Output lengths differ between Flax and PyTorch"				)
												for fx_output, pt_output in zip(UpperCAmelCase			,  UpperCAmelCase				):
														self.assert_almost_equals(fx_output[:, -1]			,  pt_output[:, -1].numpy()			,  4E-2				)







						@slow
						def   UpperCAmelCase						(	self				)    ->				Dict:






								'''simple docstring'''






								for model_class_name in self.all_model_classes:
										__snake_case				:			Union[str, Any]            =    model_class_name.from_pretrained("gpt2"			,  from_pt=UpperCAmelCase				)
										__snake_case				:			Union[str, Any]            =    model(np.ones((1, 1)				)				)
										self.assertIsNotNone(UpperCAmelCase				)








import csv
import dataclasses
import json
from dataclasses import dataclass
from typing import List, Optional, Union

from ...utils import is_tf_available, is_torch_available, logging


_UpperCamelCase    =	logging.get_logger(__name__)




@dataclass
class 			_lowerCamelCase	:



      """simple docstring"""






      UpperCAmelCase_  : str
      UpperCAmelCase_  : str
      UpperCAmelCase_  : Optional[str]				      =None
      UpperCAmelCase_  : Optional[str]				      =None







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






        '''simple docstring'''






        return json.dumps(dataclasses.asdict(self				)			,  indent=2				) + "\n"




@dataclass(frozen=a      )
class 			_lowerCamelCase	:



      """simple docstring"""






      UpperCAmelCase_  : List[int]
      UpperCAmelCase_  : Optional[List[int]]				      =None
      UpperCAmelCase_  : Optional[List[int]]				      =None
      UpperCAmelCase_  : Optional[Union[int, float]]				      =None







      def   UpperCAmelCase						(	self				)    ->				Tuple:






        '''simple docstring'''






        return json.dumps(dataclasses.asdict(self				)				) + "\n"




class 			_lowerCamelCase	:



      """simple docstring"""






      def   UpperCAmelCase						(	self			,  UpperCAmelCase				)    ->				Dict:






        '''simple docstring'''






        raise NotImplementedError()







      def   UpperCAmelCase						(	self			,  UpperCAmelCase				)    ->				int:






        '''simple docstring'''






        raise NotImplementedError()







      def   UpperCAmelCase						(	self			,  UpperCAmelCase				)    ->				List[str]:






        '''simple docstring'''






        raise NotImplementedError()







      def   UpperCAmelCase						(	self			,  UpperCAmelCase				)    ->				str:






        '''simple docstring'''






        raise NotImplementedError()







      def   UpperCAmelCase						(	self				)    ->				str:






        '''simple docstring'''






        raise NotImplementedError()







      def   UpperCAmelCase						(	self			,  UpperCAmelCase				)    ->				Tuple:






        '''simple docstring'''






        if len(self.get_labels()				) > 1:
          __snake_case				:			Any            =    self.get_labels()[int(example.label				)]
        return example







      @classmethod
      def   UpperCAmelCase						(	cls			,  UpperCAmelCase			,  UpperCAmelCase=None				)    ->				str:






        '''simple docstring'''






        with open(UpperCAmelCase			,  "r"			,  encoding="utf-8-sig"				) as f:
          return list(csv.reader(UpperCAmelCase			,  delimiter="\t"			,  quotechar=UpperCAmelCase				)				)




class 			_lowerCamelCase	(      a      ):



      """simple docstring"""






      def __init__(	self			,  UpperCAmelCase=None			,  UpperCAmelCase=None			,  UpperCAmelCase="classification"			,  UpperCAmelCase=False				)    ->				str:






        '''simple docstring'''






        __snake_case				:			Optional[Any]            =    [] if labels is None else labels
        __snake_case				:			str            =    [] if examples is None else examples
        __snake_case				:			str            =    mode
        __snake_case				:			Tuple            =    verbose







      def __len__(	self				)    ->				Dict:






        '''simple docstring'''






        return len(self.examples				)







      def __getitem__(	self			,  UpperCAmelCase				)    ->				Tuple:






        '''simple docstring'''






        if isinstance(UpperCAmelCase			,  UpperCAmelCase				):
          return SingleSentenceClassificationProcessor(labels=self.labels			,  examples=self.examples[idx]				)
        return self.examples[idx]







      @classmethod
      def   UpperCAmelCase						(	cls			,  UpperCAmelCase			,  UpperCAmelCase=""			,  UpperCAmelCase=0			,  UpperCAmelCase=1			,  UpperCAmelCase=None			,  UpperCAmelCase=False			,  **UpperCAmelCase				)    ->				int:






        '''simple docstring'''






        __snake_case				:			Dict            =    cls(**UpperCAmelCase				)
        processor.add_examples_from_csv(
            UpperCAmelCase			,  split_name=UpperCAmelCase			,  column_label=UpperCAmelCase			,  column_text=UpperCAmelCase			,  column_id=UpperCAmelCase			,  skip_first_row=UpperCAmelCase			,  overwrite_labels=UpperCAmelCase			,  overwrite_examples=UpperCAmelCase			,  )
        return processor







      @classmethod
      def   UpperCAmelCase						(	cls			,  UpperCAmelCase			,  UpperCAmelCase=None			,  **UpperCAmelCase				)    ->				Tuple:






        '''simple docstring'''






        __snake_case				:			Dict            =    cls(**UpperCAmelCase				)
        processor.add_examples(UpperCAmelCase			,  labels=UpperCAmelCase				)
        return processor







      def   UpperCAmelCase						(	self			,  UpperCAmelCase			,  UpperCAmelCase=""			,  UpperCAmelCase=0			,  UpperCAmelCase=1			,  UpperCAmelCase=None			,  UpperCAmelCase=False			,  UpperCAmelCase=False			,  UpperCAmelCase=False			,  )    ->				Dict:






        '''simple docstring'''






        __snake_case				:			Optional[int]            =    self._read_tsv(UpperCAmelCase				)
        if skip_first_row:
          __snake_case				:			str            =    lines[1:]
        __snake_case				:			List[str]            =    []
        __snake_case				:			List[str]            =    []
        __snake_case				:			Optional[int]            =    []
        for i, line in enumerate(UpperCAmelCase				):
          texts.append(line[column_text]				)
          labels.append(line[column_label]				)
          if column_id is not None:
            ids.append(line[column_id]				)
          else:
            __snake_case				:			List[Any]            =    F"""{split_name}-{i}""" if split_name else str(UpperCAmelCase				)
            ids.append(UpperCAmelCase				)

        return self.add_examples(
            UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  overwrite_labels=UpperCAmelCase			,  overwrite_examples=UpperCAmelCase				)







      def   UpperCAmelCase						(	self			,  UpperCAmelCase			,  UpperCAmelCase=None			,  UpperCAmelCase=None			,  UpperCAmelCase=False			,  UpperCAmelCase=False				)    ->				Optional[Any]:






        '''simple docstring'''






        if labels is not None and len(UpperCAmelCase				) != len(UpperCAmelCase				):
          raise ValueError(
              F"""Text and labels have mismatched lengths {len(UpperCAmelCase				)} and {len(UpperCAmelCase				)}"""				)
        if ids is not None and len(UpperCAmelCase				) != len(UpperCAmelCase				):
          raise ValueError(F"""Text and ids have mismatched lengths {len(UpperCAmelCase				)} and {len(UpperCAmelCase				)}"""				)
        if ids is None:
          __snake_case				:			str            =    [None] * len(UpperCAmelCase				)
        if labels is None:
          __snake_case				:			Dict            =    [None] * len(UpperCAmelCase				)
        __snake_case				:			Dict            =    []
        __snake_case				:			Any            =    set()
        for text_or_text_and_label, label, guid in zip(UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase				):
          if isinstance(UpperCAmelCase			,  (tuple, list)				) and label is None:
            __snake_case      ,				__snake_case				:			int            =    text_or_text_and_label
          else:
            __snake_case				:			Dict            =    text_or_text_and_label
          added_labels.add(UpperCAmelCase				)
          examples.append(InputExample(guid=UpperCAmelCase			,  text_a=UpperCAmelCase			,  text_b=UpperCAmelCase			,  label=UpperCAmelCase				)				)

        # Update examples
        if overwrite_examples:
          __snake_case				:			Union[str, Any]            =    examples
        else:
          self.examples.extend(UpperCAmelCase				)

        # Update labels
        if overwrite_labels:
          __snake_case				:			Optional[Any]            =    list(UpperCAmelCase				)
        else:
          __snake_case				:			Dict            =    list(set(self.labels				).union(UpperCAmelCase				)				)

        return self.examples







      def   UpperCAmelCase						(	self			,  UpperCAmelCase			,  UpperCAmelCase=None			,  UpperCAmelCase=False			,  UpperCAmelCase=0			,  UpperCAmelCase=True			,  UpperCAmelCase=None			,  )    ->				str:






        '''simple docstring'''






        if max_length is None:
          __snake_case				:			Tuple            =    tokenizer.max_len

        __snake_case				:			Union[str, Any]            =    {label: i for i, label in enumerate(self.labels				)}

        __snake_case				:			Union[str, Any]            =    []
        for ex_index, example in enumerate(self.examples				):
          if ex_index % 10000 == 0:
            logger.info(F"""Tokenizing example {ex_index}"""				)

          __snake_case				:			Union[str, Any]            =    tokenizer.encode(
              example.text_a			,  add_special_tokens=UpperCAmelCase			,  max_length=min(UpperCAmelCase			,  tokenizer.max_len				)			,  )
          all_input_ids.append(UpperCAmelCase				)

        __snake_case				:			Union[str, Any]            =    max(len(UpperCAmelCase				) for input_ids in all_input_ids				)

        __snake_case				:			str            =    []
        for ex_index, (input_ids, example) in enumerate(zip(UpperCAmelCase			,  self.examples				)				):
          if ex_index % 10000 == 0:
            logger.info(F"""Writing example {ex_index}/{len(self.examples				)}"""				)
          # The mask has 1 for real tokens and 0 for padding tokens. Only real
          # tokens are attended to.
          __snake_case				:			Optional[Any]            =    [1 if mask_padding_with_zero else 0] * len(UpperCAmelCase				)

          # Zero-pad up to the sequence length.
          __snake_case				:			List[str]            =    batch_length - len(UpperCAmelCase				)
          if pad_on_left:
            __snake_case				:			List[Any]            =    ([pad_token] * padding_length) + input_ids
            __snake_case				:			str            =    ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask
          else:
            __snake_case				:			Any            =    input_ids + ([pad_token] * padding_length)
            __snake_case				:			List[str]            =    attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)

          if len(UpperCAmelCase				) != batch_length:
            raise ValueError(F"""Error with input length {len(UpperCAmelCase				)} vs {batch_length}"""				)
          if len(UpperCAmelCase				) != batch_length:
            raise ValueError(F"""Error with input length {len(UpperCAmelCase				)} vs {batch_length}"""				)

          if self.mode == "classification":
            __snake_case				:			str            =    label_map[example.label]
          elif self.mode == "regression":
            __snake_case				:			List[str]            =    float(example.label				)
          else:
            raise ValueError(self.mode				)

          if ex_index < 5 and self.verbose:
            logger.info("*** Example ***"				)
            logger.info(F"""guid: {example.guid}"""				)
            logger.info(F"""input_ids: {" ".join([str(UpperCAmelCase				) for x in input_ids]				)}"""				)
            logger.info(F"""attention_mask: {" ".join([str(UpperCAmelCase				) for x in attention_mask]				)}"""				)
            logger.info(F"""label: {example.label} (id = {label})"""				)

          features.append(InputFeatures(input_ids=UpperCAmelCase			,  attention_mask=UpperCAmelCase			,  label=UpperCAmelCase				)				)

        if return_tensors is None:
          return features
        elif return_tensors == "tf":
          if not is_tf_available():
            raise RuntimeError("return_tensors set to 'tf' but TensorFlow 2.0 can't be imported"				)
          import tensorflow as tf

          def gen():
            for ex in features:
              yield ({"input_ids": ex.input_ids, "attention_mask": ex.attention_mask}, ex.label)

          __snake_case				:			int            =    tf.data.Dataset.from_generator(
              UpperCAmelCase			,  ({"input_ids": tf.intaa, "attention_mask": tf.intaa}, tf.intaa)			,  ({"input_ids": tf.TensorShape([None]				), "attention_mask": tf.TensorShape([None]				)}, tf.TensorShape([]				))			,  )
          return dataset
        elif return_tensors == "pt":
          if not is_torch_available():
            raise RuntimeError("return_tensors set to 'pt' but PyTorch can't be imported"				)
          import torch
          from torch.utils.data import TensorDataset

          __snake_case				:			int            =    torch.tensor([f.input_ids for f in features]			,  dtype=torch.long				)
          __snake_case				:			int            =    torch.tensor([f.attention_mask for f in features]			,  dtype=torch.long				)
          if self.mode == "classification":
            __snake_case				:			List[Any]            =    torch.tensor([f.label for f in features]			,  dtype=torch.long				)
          elif self.mode == "regression":
            __snake_case				:			List[Any]            =    torch.tensor([f.label for f in features]			,  dtype=torch.float				)

          __snake_case				:			List[Any]            =    TensorDataset(UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase				)
          return dataset
        else:
          raise ValueError("return_tensors should be one of 'tf' or 'pt'"				)

