


from math import sqrt

def 			_a  (				SCREAMING_SNAKE_CASE	:				int     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (
     number >= 0
 ), "'number' must been an int and positive"

 UpperCamelCase__					:    int          =   True

 # 0 and 1 are none primes.
 if number <= 1:
  UpperCamelCase__					:    Optional[int]          =   False

 for divisor in range(2    , int(round(sqrt(SCREAMING_SNAKE_CASE     )     )     ) + 1     ):
  # if 'number' divisible by 'divisor' then sets 'status'
  # of false and break up the loop.
  if number % divisor == 0:
   UpperCamelCase__					:    str          =   False
   break

    # precondition
 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ), "'status' must been from type bool"

 return status

def 			_a  (				SCREAMING_SNAKE_CASE	:				Any     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (n > 2), "'N' must been an int and > 2"

 # beginList: contains all natural numbers from 2 up to N
 UpperCamelCase__					:    Dict          =   list(range(2    , n + 1     )     )

 UpperCamelCase__					:    Any          =   []  # this list will be returns.

 # actual sieve of erathostenes
 for i in range(len(SCREAMING_SNAKE_CASE     )     ):
  for j in range(i + 1    , len(SCREAMING_SNAKE_CASE     )     ):
   if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
    UpperCamelCase__					:    Any          =   0

    # filters actual prime numbers.
 UpperCamelCase__					:    str          =   [x for x in begin_list if x != 0]

 # precondition
 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ), "'ans' must been from type list"

 return ans

def 			_a  (				SCREAMING_SNAKE_CASE	:				Any     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (n > 2), "'N' must been an int and > 2"

 UpperCamelCase__					:    List[str]          =   []

 # iterates over all numbers between 2 up to N+1
 # if a number is prime then appends to list 'ans'
 for number in range(2    , n + 1     ):
  if is_prime(SCREAMING_SNAKE_CASE     ):
   ans.append(SCREAMING_SNAKE_CASE     )

    # precondition
 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ), "'ans' must been from type list"

 return ans

def 			_a  (				SCREAMING_SNAKE_CASE	:				List[Any]     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and number >= 0, "'number' must been an int and >= 0"

 UpperCamelCase__					:    str          =   []  # this list will be returns of the function.

 # potential prime number factors.

 UpperCamelCase__					:    Dict          =   2

 UpperCamelCase__					:    Tuple          =   number

 if number == 0 or number == 1:
  ans.append(SCREAMING_SNAKE_CASE     )

 # if 'number' not prime then builds the prime factorization of 'number'
 elif not is_prime(SCREAMING_SNAKE_CASE     ):
  while quotient != 1:
   if is_prime(SCREAMING_SNAKE_CASE     ) and (quotient % factor == 0):
    ans.append(SCREAMING_SNAKE_CASE     )
    quotient /= factor
   else:
    factor += 1

 else:
  ans.append(SCREAMING_SNAKE_CASE     )

 # precondition
 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ), "'ans' must been from type list"

 return ans

def 			_a  (				SCREAMING_SNAKE_CASE	:				List[Any]     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (
     number >= 0
 ), "'number' bust been an int and >= 0"

 UpperCamelCase__					:    List[Any]          =   0

 # prime factorization of 'number'
 UpperCamelCase__					:    List[Any]          =   prime_factorization(SCREAMING_SNAKE_CASE     )

 UpperCamelCase__					:    Tuple          =   max(SCREAMING_SNAKE_CASE     )

 # precondition
 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ), "'ans' must been from type int"

 return ans

def 			_a  (				SCREAMING_SNAKE_CASE	:				Tuple     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (
     number >= 0
 ), "'number' bust been an int and >= 0"

 UpperCamelCase__					:    str          =   0

 # prime factorization of 'number'
 UpperCamelCase__					:    str          =   prime_factorization(SCREAMING_SNAKE_CASE     )

 UpperCamelCase__					:    int          =   min(SCREAMING_SNAKE_CASE     )

 # precondition
 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ), "'ans' must been from type int"

 return ans

def 			_a  (				SCREAMING_SNAKE_CASE	:				int     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ), "'number' must been an int"
 assert isinstance(number % 2 == 0    , SCREAMING_SNAKE_CASE     ), "compare bust been from type bool"

 return number % 2 == 0

def 			_a  (				SCREAMING_SNAKE_CASE	:				Dict     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ), "'number' must been an int"
 assert isinstance(number % 2 != 0    , SCREAMING_SNAKE_CASE     ), "compare bust been from type bool"

 return number % 2 != 0

def 			_a  (				SCREAMING_SNAKE_CASE	:				str     ):







 """simple docstring"""



 assert (
     isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (number > 2) and is_even(SCREAMING_SNAKE_CASE     )
 ), "'number' must been an int, even and > 2"

 UpperCamelCase__					:    Dict          =   []  # this list will returned

 # creates a list of prime numbers between 2 up to 'number'
 UpperCamelCase__					:    Optional[int]          =   get_prime_numbers(SCREAMING_SNAKE_CASE     )
 UpperCamelCase__					:    Union[str, Any]          =   len(SCREAMING_SNAKE_CASE     )

 # run variable for while-loops.
 UpperCamelCase__					:    Any          =   0
 UpperCamelCase__					:    Optional[int]          =   None

 # exit variable. for break up the loops
 UpperCamelCase__					:    str          =   True

 while i < len_pn and loop:
  UpperCamelCase__					:    Tuple          =   i + 1

  while j < len_pn and loop:
   if prime_numbers[i] + prime_numbers[j] == number:
    UpperCamelCase__					:    Any          =   False
    ans.append(prime_numbers[i]     )
    ans.append(prime_numbers[j]     )

   j += 1

  i += 1

 # precondition
 assert (
     isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
     and (len(SCREAMING_SNAKE_CASE     ) == 2)
     and (ans[0] + ans[1] == number)
     and is_prime(ans[0]     )
     and is_prime(ans[1]     )
 ), "'ans' must contains two primes. And sum of elements must been eq 'number'"

 return ans

def 			_a  (				SCREAMING_SNAKE_CASE	:				Optional[Any]    , SCREAMING_SNAKE_CASE	:				Union[str, Any]     ):







 """simple docstring"""



 assert (
     isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
     and isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
     and (numbera >= 0)
     and (numbera >= 0)
 ), "'number1' and 'number2' must been positive integer."

 UpperCamelCase__					:    Tuple          =   0

 while numbera != 0:
  UpperCamelCase__					:    Any          =   numbera % numbera
  UpperCamelCase__					:    int          =   numbera
  UpperCamelCase__					:    str          =   rest

 # precondition
 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (
     numbera >= 0
 ), "'number' must been from type int and positive"

 return numbera

def 			_a  (				SCREAMING_SNAKE_CASE	:				Tuple    , SCREAMING_SNAKE_CASE	:				Optional[Any]     ):







 """simple docstring"""



 assert (
     isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
     and isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
     and (numbera >= 1)
     and (numbera >= 1)
 ), "'number1' and 'number2' must been positive integer."

 UpperCamelCase__					:    List[str]          =   1  # actual answer that will be return.

 # for kgV (x,1)
 if numbera > 1 and numbera > 1:
  # builds the prime factorization of 'number1' and 'number2'
  UpperCamelCase__					:    str          =   prime_factorization(SCREAMING_SNAKE_CASE     )
  UpperCamelCase__					:    Any          =   prime_factorization(SCREAMING_SNAKE_CASE     )

 elif numbera == 1 or numbera == 1:
  UpperCamelCase__					:    Optional[Any]          =   []
  UpperCamelCase__					:    Dict          =   []
  UpperCamelCase__					:    Dict          =   max(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )

 UpperCamelCase__					:    Any          =   0
 UpperCamelCase__					:    Dict          =   0

 UpperCamelCase__					:    Optional[Any]          =   []  # captured numbers int both 'primeFac1' and 'primeFac2'

 # iterates through primeFac1
 for n in prime_fac_a:
  if n not in done:
   if n in prime_fac_a:
    UpperCamelCase__					:    int          =   prime_fac_a.count(SCREAMING_SNAKE_CASE     )
    UpperCamelCase__					:    List[str]          =   prime_fac_a.count(SCREAMING_SNAKE_CASE     )

    for _ in range(max(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )     ):
     ans *= n

   else:
    UpperCamelCase__					:    str          =   prime_fac_a.count(SCREAMING_SNAKE_CASE     )

    for _ in range(SCREAMING_SNAKE_CASE     ):
     ans *= n

   done.append(SCREAMING_SNAKE_CASE     )

    # iterates through primeFac2
 for n in prime_fac_a:
  if n not in done:
   UpperCamelCase__					:    Tuple          =   prime_fac_a.count(SCREAMING_SNAKE_CASE     )

   for _ in range(SCREAMING_SNAKE_CASE     ):
    ans *= n

   done.append(SCREAMING_SNAKE_CASE     )

    # precondition
 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (
     ans >= 0
 ), "'ans' must been from type int and positive"

 return ans

def 			_a  (				SCREAMING_SNAKE_CASE	:				Optional[int]     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (n >= 0), "'number' must been a positive int"

 UpperCamelCase__					:    List[Any]          =   0
 UpperCamelCase__					:    Union[str, Any]          =   2  # this variable holds the answer

 while index < n:
  index += 1

  ans += 1  # counts to the next number

  # if ans not prime then
  # runs to the next prime number.
  while not is_prime(SCREAMING_SNAKE_CASE     ):
   ans += 1

    # precondition
 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and is_prime(
     SCREAMING_SNAKE_CASE     ), "'ans' must been a prime number and from type int"

 return ans

def 			_a  (				SCREAMING_SNAKE_CASE	:				List[Any]    , SCREAMING_SNAKE_CASE	:				List[str]     ):







 """simple docstring"""



 assert (
     is_prime(SCREAMING_SNAKE_CASE     ) and is_prime(SCREAMING_SNAKE_CASE     ) and (p_number_a < p_number_a)
 ), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

 UpperCamelCase__					:    Dict          =   p_number_a + 1  # jump to the next number

 UpperCamelCase__					:    List[str]          =   []  # this list will be returns.

 # if number is not prime then
 # fetch the next prime number.
 while not is_prime(SCREAMING_SNAKE_CASE     ):
  number += 1

 while number < p_number_a:
  ans.append(SCREAMING_SNAKE_CASE     )

  number += 1

  # fetch the next prime number.
  while not is_prime(SCREAMING_SNAKE_CASE     ):
   number += 1

    # precondition
 assert (
     isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
     and ans[0] != p_number_a
     and ans[len(SCREAMING_SNAKE_CASE     ) - 1] != p_number_a
 ), "'ans' must been a list without the arguments"

 # 'ans' contains not 'pNumber1' and 'pNumber2' !
 return ans

def 			_a  (				SCREAMING_SNAKE_CASE	:				Any     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (n >= 1), "'n' must been int and >= 1"

 UpperCamelCase__					:    Any          =   []  # will be returned.

 for divisor in range(1    , n + 1     ):
  if n % divisor == 0:
   ans.append(SCREAMING_SNAKE_CASE     )

    # precondition
 assert ans[0] == 1 and ans[len(SCREAMING_SNAKE_CASE     ) - 1] == n, "Error in function getDivisiors(...)"

 return ans

def 			_a  (				SCREAMING_SNAKE_CASE	:				Any     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (
     number > 1
 ), "'number' must been an int and >= 1"

 UpperCamelCase__					:    str          =   get_divisors(SCREAMING_SNAKE_CASE     )

 # precondition
 assert (
     isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
     and (divisors[0] == 1)
     and (divisors[len(SCREAMING_SNAKE_CASE     ) - 1] == number)
 ), "Error in help-function getDivisiors(...)"

 # summed all divisors up to 'number' (exclusive), hence [:-1]
 return sum(divisors[:-1]     ) == number

def 			_a  (				SCREAMING_SNAKE_CASE	:				str    , SCREAMING_SNAKE_CASE	:				Tuple     ):







 """simple docstring"""



 assert (
     isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
     and isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
     and (denominator != 0)
 ), "The arguments must been from type int and 'denominator' != 0"

 # build the greatest common divisor of numerator and denominator.
 UpperCamelCase__					:    List[str]          =   gcd(abs(SCREAMING_SNAKE_CASE     )    , abs(SCREAMING_SNAKE_CASE     )     )

 # precondition
 assert (
     isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
     and (numerator % gcd_of_fraction == 0)
     and (denominator % gcd_of_fraction == 0)
 ), "Error in function gcd(...,...)"

 return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)

def 			_a  (				SCREAMING_SNAKE_CASE	:				List[Any]     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (n >= 0), "'n' must been a int and >= 0"

 UpperCamelCase__					:    Any          =   1  # this will be return.

 for factor in range(1    , n + 1     ):
  ans *= factor

 return ans






def 			_a  (				SCREAMING_SNAKE_CASE	:				Union[str, Any]     ):







 """simple docstring"""



 assert isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and (n >= 0), "'n' must been an int and >= 0"

 UpperCamelCase__					:    List[Any]          =   0
 UpperCamelCase__					:    Union[str, Any]          =   1
 UpperCamelCase__					:    List[str]          =   1  # this will be return

 for _ in range(n - 1     ):
  UpperCamelCase__					:    Tuple          =   ans
  ans += fiba
  UpperCamelCase__					:    Optional[int]          =   tmp

 return ans






import os
import time
from dataclasses import dataclass, field
from enum import Enum
from typing import Dict, List, Optional, Union

import torch
from filelock import FileLock
from torch.utils.data import Dataset

from ...models.auto.modeling_auto import MODEL_FOR_QUESTION_ANSWERING_MAPPING
from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging
from ..processors.squad import SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features


__UpperCamelCase       :       List[str]						       =				logging.get_logger(__name__)

__UpperCamelCase       :       Union[str, Any]						       =				list(MODEL_FOR_QUESTION_ANSWERING_MAPPING.keys())
__UpperCamelCase       :       Dict						       =				tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)

@dataclass
class       __magic_name__	:
     A:		str			=      field(
         default=__lowerCAmelCase					,				metadata={"help": "Model type selected in the list: " + ", ".join(__lowerCAmelCase)})
     A:		str			=      field(
         default=__lowerCAmelCase					,				metadata={"help": "The input data dir. Should contain the .json files for the SQuAD task."})
     A:		int			=      field(
         default=1_2_8					,				metadata={
             "help": (
                 "The maximum total input sequence length after tokenization. Sequences longer "
                 "than this will be truncated, sequences shorter will be padded."
             )
         }					,				)
     A:		int			=      field(
         default=1_2_8					,				metadata={"help": "When splitting up a long document into chunks, how much stride to take between chunks."}					,				)
     A:		int			=      field(
         default=6_4					,				metadata={
             "help": (
                 "The maximum number of tokens for the question. Questions longer than this will "
                 "be truncated to this length."
             )
         }					,				)
     A:		int			=      field(
         default=3_0					,				metadata={
             "help": (
                 "The maximum length of an answer that can be generated. This is needed because the start "
                 "and end predictions are not conditioned on one another."
             )
         }					,				)
     A:		bool			=      field(
         default=__lowerCAmelCase					,				metadata={"help": "Overwrite the cached training and evaluation sets"})
     A:		bool			=      field(
         default=__lowerCAmelCase					,				metadata={"help": "If true, the SQuAD examples contain some that do not have an answer."})
     A:		float			=      field(
         default=0.0					,				metadata={"help": "If null_score - best_non_null is greater than the threshold predict null."})
     A:		int			=      field(
         default=2_0					,				metadata={"help": "If null_score - best_non_null is greater than the threshold predict null."})
     A:		int			=      field(
         default=0					,				metadata={
             "help": (
                 "language id of input for language-specific xlm models (see"
                 " tokenization_xlm.PRETRAINED_INIT_CONFIGURATION)"
             )
         }					,				)
     A:		int			=      field(default=1					,				metadata={"help": "multiple threads for converting example to features"})



class       __magic_name__	(     __lowerCAmelCase):
     A:		Union[str, Any]			=      "train"
     A:		List[str]			=      "dev"



class       __magic_name__	(     __lowerCAmelCase):
     A:		SquadDataTrainingArguments
     A:		List[SquadFeatures]
     A:		Split
     A:		bool


     def __init__(      self							:     Tuple							,	lowerCamelCase__							:     SquadDataTrainingArguments							,	lowerCamelCase__							:     PreTrainedTokenizer							,	lowerCamelCase__							:     Optional[int] = None							,	lowerCamelCase__							:     Union[str, Split] = Split.train							,	lowerCamelCase__							:     Optional[bool] = False							,	lowerCamelCase__							:     Optional[str] = None							,	lowerCamelCase__							:     Optional[str] = "pt"							,	)  ->      int:





      '''simple docstring'''






      UpperCamelCase__					:    Dict          =   args
      UpperCamelCase__					:    Union[str, Any]          =   is_language_sensitive
      UpperCamelCase__					:    List[Any]          =   SquadVaProcessor() if args.version_2_with_negative else SquadVaProcessor()
      if isinstance(lowerCamelCase__							,	lowerCamelCase__			):
       try:
        UpperCamelCase__					:    Union[str, Any]          =   Split[mode]
       except KeyError:
        raise KeyError('''mode is not a valid split name'''			)
      UpperCamelCase__					:    List[str]          =   mode
      # Load data features from cache or dataset file
      UpperCamelCase__					:    List[str]          =   '''v2''' if args.version_2_with_negative else '''v1'''
      UpperCamelCase__					:    str          =   os.path.join(
          cache_dir if cache_dir is not None else args.data_dir							,	F"cached_{mode.value}_{tokenizer.__class__.__name__}_{args.max_seq_length}_{version_tag}"							,	)

      # Make sure only the first process in distributed training processes the dataset,
      # and the others will use the cache.
      UpperCamelCase__					:    Tuple          =   cached_features_file + '''.lock'''
      with FileLock(lowerCamelCase__			):
       if os.path.exists(lowerCamelCase__			) and not args.overwrite_cache:
        UpperCamelCase__					:    int          =   time.time()
        UpperCamelCase__					:    List[str]          =   torch.load(lowerCamelCase__			)

        # Legacy cache files have only features, while new cache files
        # will have dataset and examples also.
        UpperCamelCase__					:    Any          =   self.old_features['''features''']
        UpperCamelCase__					:    Union[str, Any]          =   self.old_features.get('''dataset'''							,	lowerCamelCase__			)
        UpperCamelCase__					:    List[str]          =   self.old_features.get('''examples'''							,	lowerCamelCase__			)
        logger.info(
            F"Loading features from cached file {cached_features_file} [took %.3f s]"							,	time.time() - start			)

        if self.dataset is None or self.examples is None:
         logger.warning(
             F"Deleting cached file {cached_features_file} will allow dataset and examples to be cached in"
             ''' future run'''			)
       else:
        if mode == Split.dev:
         UpperCamelCase__					:    List[str]          =   self.processor.get_dev_examples(args.data_dir			)
        else:
         UpperCamelCase__					:    Any          =   self.processor.get_train_examples(args.data_dir			)

        UpperCamelCase__       ,				UpperCamelCase__					:    Union[str, Any]          =   squad_convert_examples_to_features(
            examples=self.examples							,	tokenizer=lowerCamelCase__							,	max_seq_length=args.max_seq_length							,	doc_stride=args.doc_stride							,	max_query_length=args.max_query_length							,	is_training=mode == Split.train							,	threads=args.threads							,	return_dataset=lowerCamelCase__							,	)

        UpperCamelCase__					:    Tuple          =   time.time()
        torch.save(
            {'''features''': self.features, '''dataset''': self.dataset, '''examples''': self.examples}							,	lowerCamelCase__							,	)
        # ^ This seems to take a lot of time so I want to investigate why and how we can improve.
        logger.info(
            F"Saving features into cached file {cached_features_file} [took {time.time() - start:.3f} s]"			)


     def __len__(      self							:     Any			)  ->      List[str]:





      '''simple docstring'''






      return len(self.features			)


     def __getitem__(      self							:     Dict							,	lowerCamelCase__							:     Any			)  ->      Dict[str, torch.Tensor]:





      '''simple docstring'''






      UpperCamelCase__					:    List[Any]          =   self.features[i]

      UpperCamelCase__					:    Optional[Any]          =   torch.tensor(feature.input_ids							,	dtype=torch.long			)
      UpperCamelCase__					:    Tuple          =   torch.tensor(feature.attention_mask							,	dtype=torch.long			)
      UpperCamelCase__					:    Optional[int]          =   torch.tensor(feature.token_type_ids							,	dtype=torch.long			)
      UpperCamelCase__					:    int          =   torch.tensor(feature.cls_index							,	dtype=torch.long			)
      UpperCamelCase__					:    List[Any]          =   torch.tensor(feature.p_mask							,	dtype=torch.float			)
      UpperCamelCase__					:    Any          =   torch.tensor(feature.is_impossible							,	dtype=torch.float			)

      UpperCamelCase__					:    Dict          =   {
          '''input_ids''': input_ids,
          '''attention_mask''': attention_mask,
          '''token_type_ids''': token_type_ids,
      }

      if self.args.model_type in ["xlm", "roberta", "distilbert", "camembert"]:
       del inputs["token_type_ids"]

      if self.args.model_type in ["xlnet", "xlm"]:
       inputs.update({'''cls_index''': cls_index, '''p_mask''': p_mask}			)
       if self.args.version_2_with_negative:
        inputs.update({'''is_impossible''': is_impossible}			)
       if self.is_language_sensitive:
        inputs.update({'''langs''': (torch.ones(input_ids.shape							,	dtype=torch.intaa			) * self.args.lang_id)}			)

      if self.mode == Split.train:
       UpperCamelCase__					:    Optional[Any]          =   torch.tensor(feature.start_position							,	dtype=torch.long			)
       UpperCamelCase__					:    Optional[int]          =   torch.tensor(feature.end_position							,	dtype=torch.long			)
       inputs.update({'''start_positions''': start_positions, '''end_positions''': end_positions}			)

      return inputs


