




'''simple docstring'''


import os

import jsonlines
import numpy as np
from tqdm import tqdm


lowerCAmelCase_      :  Optional[int]				     =  2048
lowerCAmelCase_      :  int				     =  4096
lowerCAmelCase_      :  Optional[Any]				     =  42
lowerCAmelCase_      :  Union[str, Any]				     =  os.environ.pop('PROCESS_TRAIN', 'false')
lowerCAmelCase_      :  List[Any]				     =  {'null': 0, 'short': 1, 'long': 2, 'yes': 3, 'no': 4}



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					List[Any]				):




     """simple docstring"""


     def choose_first(UpperCamelCase__    :					List[Any] ,    UpperCamelCase__    :					Union[str, Any]=False				):
          assert isinstance(UpperCamelCase__ ,    UpperCamelCase__				)
          if len(UpperCamelCase__				) == 1:
               a_     :							List[Any]     						=  answer[0]
               return {k: [answer[k]] for k in answer} if is_long_answer else answer
          for a in answer:
               if is_long_answer:
                    a_     :							List[str]     						=  {k: [a[k]] for k in a}
               if len(a["""start_token"""]				) > 0:
                    break
          return a

     a_     :							str     						=  {"""id""": example["""id"""]}
     a_     :							Any     						=  example["""annotations"""]
     a_     :							int     						=  annotation["""yes_no_answer"""]
     if 0 in yes_no_answer or 1 in yes_no_answer:
          a_     :							Optional[Any]     						=  ["""yes"""] if 1 in yes_no_answer else ["""no"""]
          a_     :							int     						=  []
          a_     :							Optional[int]     						=  []
          a_     :							Dict     						=  ["""<cls>"""]
     else:
          a_     :							int     						=  ["""short"""]
          a_     :							Optional[int]     						=  choose_first(annotation["""short_answers"""]				)
          if len(out["""start_token"""]				) == 0:
               # answer will be long if short is not available
               a_     :							List[str]     						=  ["""long"""]
               a_     :							Any     						=  choose_first(annotation["""long_answer"""] ,    is_long_answer=UpperCamelCase__				)
               a_     :							Optional[Any]     						=  []
          answer.update(UpperCamelCase__				)

     # disregard some samples
     if len(answer["""start_token"""]				) > 1 or answer["start_token"] == answer["end_token"]:
          a_     :							Union[str, Any]     						=  True
     else:
          a_     :							Any     						=  False

     a_     :							str     						=  ["""start_token""", """end_token""", """start_byte""", """end_byte""", """text"""]
     if not all(isinstance(answer[k] ,    UpperCamelCase__				) for k in cols				):
          raise ValueError("""Issue in ID""" ,    example["""id"""]				)

     return answer



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					Optional[Any] ,    UpperCamelCase__    :					int=False				):




     """simple docstring"""


     a_     :							Tuple     						=  _get_single_answer(UpperCamelCase__				)
     # bytes are of no use
     del answer["start_byte"]
     del answer["end_byte"]

     # handle yes_no answers explicitly
     if answer["category"][0] in ["yes", "no"]:  # category is list with one element
          a_     :							Union[str, Any]     						=  example["""document"""]["""tokens"""]
          a_     :							Optional[int]     						=  []
          for i in range(len(doc["""token"""]				)				):
               if not doc["is_html"][i]:
                    context.append(doc["""token"""][i]				)
          return {
              "context": " ".join(UpperCamelCase__				),
              "answer": {
                  "start_token": -100,  # ignore index in cross-entropy
                  "end_token": -100,  # ignore index in cross-entropy
                  "category": answer["category"],
                  "span": answer["category"],  # extra
              },
          }

     # later, help in removing all no answers
     if answer["start_token"] == [-1]:
          return {
              "context": "None",
              "answer": {
                  "start_token": -1,
                  "end_token": -1,
                  "category": "null",
                  "span": "None",  # extra
              },
          }

     # handling normal samples

     a_     :							Dict     						=  ["""start_token""", """end_token"""]
     answer.update({k: answer[k][0] if len(answer[k]				) > 0 else answer[k] for k in cols}				)  # e.g. [10] == 10

     a_     :							Dict     						=  example["""document"""]["""tokens"""]
     a_     :							str     						=  answer["""start_token"""]
     a_     :							str     						=  answer["""end_token"""]

     a_     :							Optional[Any]     						=  []
     for i in range(len(doc["""token"""]				)				):
          if not doc["is_html"][i]:
               context.append(doc["""token"""][i]				)
          else:
               if answer["start_token"] > i:
                    start_token -= 1
               if answer["end_token"] > i:
                    end_token -= 1
     a_     :							Optional[Any]     						=  """ """.join(context[start_token:end_token]				)

     # checking above code
     if assertion:
          a_     :							Any     						=  doc["""is_html"""][answer["""start_token"""] : answer["""end_token"""]]
          a_     :							Union[str, Any]     						=  doc["""token"""][answer["""start_token"""] : answer["""end_token"""]]
          a_     :							Tuple     						=  """ """.join([old[i] for i in range(len(UpperCamelCase__				)				) if not is_html[i]]				)
          if new != old:
               print("""ID:""" ,    example["""id"""]				)
               print("""New:""" ,    UpperCamelCase__ ,    end="""\n"""				)
               print("""Old:""" ,    UpperCamelCase__ ,    end="""\n\n"""				)

     return {
         "context": " ".join(UpperCamelCase__				),
         "answer": {
             "start_token": start_token,
             "end_token": end_token - 1,  # this makes it inclusive
             "category": answer["category"],  # either long or short
             "span": new,  # extra
         },
     }



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					int ,    UpperCamelCase__    :					str ,    UpperCamelCase__    :					List[Any]=2048 ,    UpperCamelCase__    :					Union[str, Any]=4096 ,    UpperCamelCase__    :					Union[str, Any]=True				):




     """simple docstring"""


     a_     :							Any     						=  get_context_and_ans(UpperCamelCase__ ,    assertion=UpperCamelCase__				)
     a_     :							List[Any]     						=  out["""answer"""]

     # later, removing these samples
     if answer["start_token"] == -1:
          return {
              "example_id": example["id"],
              "input_ids": [[-1]],
              "labels": {
                  "start_token": [-1],
                  "end_token": [-1],
                  "category": ["null"],
              },
          }

     a_     :							Optional[Any]     						=  tokenizer(example["""question"""]["""text"""] ,    out["""context"""]				).input_ids
     a_     :							Tuple     						=  input_ids.index(tokenizer.sep_token_id				) + 1

     # return yes/no
     if answer["category"][0] in ["yes", "no"]:  # category is list with one element
          a_     :							List[str]     						=  []
          a_     :							Union[str, Any]     						=  []
          a_     :							Optional[int]     						=  input_ids[:q_len]
          a_     :							Optional[Any]     						=  range(UpperCamelCase__ ,    len(UpperCamelCase__				) ,    max_length - doc_stride				)
          for i in doc_start_indices:
               a_     :							Optional[Any]     						=  i + max_length - q_len
               a_     :							Optional[Any]     						=  input_ids[i:end_index]
               inputs.append(q_indices + slice				)
               category.append(answer["""category"""][0]				)
               if slice[-1] == tokenizer.sep_token_id:
                    break

          return {
              "example_id": example["id"],
              "input_ids": inputs,
              "labels": {
                  "start_token": [-100] * len(UpperCamelCase__				),
                  "end_token": [-100] * len(UpperCamelCase__				),
                  "category": category,
              },
          }

     a_     :							Any     						=  out["""context"""].split()
     a_     :							Any     						=  splitted_context[answer["""end_token"""]]
     a_     :							List[str]     						=  len(
         tokenizer(
             """ """.join(splitted_context[: answer["""start_token"""]]				) ,    add_special_tokens=UpperCamelCase__ ,    ).input_ids				)
     a_     :							Optional[int]     						=  len(
         tokenizer(""" """.join(splitted_context[: answer["""end_token"""]]				) ,    add_special_tokens=UpperCamelCase__				).input_ids				)

     answer["start_token"] += q_len
     answer["end_token"] += q_len

     # fixing end token
     a_     :							List[str]     						=  len(tokenizer(UpperCamelCase__ ,    add_special_tokens=UpperCamelCase__				).input_ids				)
     if num_sub_tokens > 1:
          answer["end_token"] += num_sub_tokens - 1

     a_     :							Tuple     						=  input_ids[answer["""start_token"""] : answer["""end_token"""] + 1]  # right & left are inclusive
     a_     :							Optional[Any]     						=  answer["""start_token"""]
     a_     :							Dict     						=  answer["""end_token"""]

     if assertion:
          a_     :							Tuple     						=  tokenizer.decode(UpperCamelCase__				)
          if answer["span"] != new:
               print("""ISSUE IN TOKENIZATION"""				)
               print("""OLD:""" ,    answer["""span"""]				)
               print("""NEW:""" ,    UpperCamelCase__ ,    end="""\n\n"""				)

     if len(UpperCamelCase__				) <= max_length:
          return {
              "example_id": example["id"],
              "input_ids": [input_ids],
              "labels": {
                  "start_token": [answer["start_token"]],
                  "end_token": [answer["end_token"]],
                  "category": answer["category"],
              },
          }

     a_     :							Any     						=  input_ids[:q_len]
     a_     :							Dict     						=  range(UpperCamelCase__ ,    len(UpperCamelCase__				) ,    max_length - doc_stride				)

     a_     :							Union[str, Any]     						=  []
     a_     :							int     						=  []
     a_     :							str     						=  []
     a_     :							Optional[int]     						=  []  # null, yes, no, long, short
     for i in doc_start_indices:
          a_     :							int     						=  i + max_length - q_len
          a_     :							Tuple     						=  input_ids[i:end_index]
          inputs.append(q_indices + slice				)
          assert len(inputs[-1]				) <= max_length, "Issue in truncating length"

          if start_token >= i and end_token <= end_index - 1:
               a_     :							str     						=  start_token - i + q_len
               a_     :							int     						=  end_token - i + q_len
               answers_category.append(answer["""category"""][0]				)  # ["short"] -> "short"
          else:
               a_     :							Optional[int]     						=  -100
               a_     :							str     						=  -100
               answers_category.append("""null"""				)
          a_     :							Dict     						=  inputs[-1][start_token : end_token + 1]

          answers_start_token.append(UpperCamelCase__				)
          answers_end_token.append(UpperCamelCase__				)
          if assertion:
               if new != old and new != [tokenizer.cls_token_id]:
                    print("""ISSUE in strided for ID:""" ,    example["""id"""]				)
                    print("""New:""" ,    tokenizer.decode(UpperCamelCase__				)				)
                    print("""Old:""" ,    tokenizer.decode(UpperCamelCase__				) ,    end="""\n\n"""				)
          if slice[-1] == tokenizer.sep_token_id:
               break

     return {
         "example_id": example["id"],
         "input_ids": inputs,
         "labels": {
             "start_token": answers_start_token,
             "end_token": answers_end_token,
             "category": answers_category,
         },
     }



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					Union[str, Any] ,    UpperCamelCase__    :					Dict ,    UpperCamelCase__    :					int=2048 ,    UpperCamelCase__    :					Union[str, Any]=4096 ,    UpperCamelCase__    :					Any=False				):




     """simple docstring"""


     a_     :							List[str]     						=  get_strided_contexts_and_ans(
         UpperCamelCase__ ,    UpperCamelCase__ ,    doc_stride=UpperCamelCase__ ,    max_length=UpperCamelCase__ ,    assertion=UpperCamelCase__ ,    )

     return example



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					Union[str, Any] ,    UpperCamelCase__    :					Dict				):




     """simple docstring"""


     with jsonlines.open(UpperCamelCase__ ,    """a"""				) as writer:
          for example in tqdm(UpperCamelCase__ ,    total=len(UpperCamelCase__				) ,    desc="""Saving samples ... """				):
               a_     :							Tuple     						=  example["""labels"""]
               for ids, start, end, cat in zip(
                   example["""input_ids"""] ,    labels["""start_token"""] ,    labels["""end_token"""] ,    labels["""category"""] ,    ):
                    if start == -1 and end == -1:
                         continue  # leave waste samples with no answer
                    if cat == "null" and np.random.rand() < 0.6:
                         continue  # removing 50 % samples
                    writer.write(
                        {
                            """input_ids""": ids,
                            """start_token""": start,
                            """end_token""": end,
                            """category""": CATEGORY_MAPPING[cat],
                        }				)


if __name__ == "__main__":
 from datasets import load_dataset

 from transformers import BigBirdTokenizer

 lowerCAmelCase_      :  Optional[int]				     =  load_dataset('natural_questions')
 lowerCAmelCase_      :  Dict				     =  BigBirdTokenizer.from_pretrained('google/bigbird-roberta-base')

 lowerCAmelCase_      :  List[str]				     =  data['train' if PROCESS_TRAIN == 'true' else 'validation']

 lowerCAmelCase_      :  List[str]				     =  {
     'tokenizer': tokenizer,
     'doc_stride': DOC_STRIDE,
     'max_length': MAX_LENGTH,
     'assertion': False,
 }
 lowerCAmelCase_      :  Optional[int]				     =  data.map(prepare_inputs, fn_kwargs=fn_kwargs)
 lowerCAmelCase_      :  Tuple				     =  data.remove_columns(['annotations', 'document', 'id', 'question'])
 print(data)

 np.random.seed(SEED)
 lowerCAmelCase_      :  List[Any]				     =  'nq-training.jsonl' if PROCESS_TRAIN == 'true' else 'nq-validation.jsonl'
 save_to_disk(data, file_name=cache_file_name)






'''simple docstring'''


import math
import random



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					float ,    UpperCamelCase__    :					bool = False				):




     """simple docstring"""


     if deriv:
          return value * (1 - value)
     return 1 / (1 + math.exp(-value				))


# Initial Value
lowerCAmelCase_      :  Optional[Any]				     =  0.02



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					int ,    UpperCamelCase__    :					int				):




     """simple docstring"""


     a_     :							Tuple     						=  float(2 * (random.randint(1 ,    100				)) - 1				)

     for _ in range(UpperCamelCase__				):
          # Forward propagation
          a_     :							Dict     						=  sigmoid_function(INITIAL_VALUE * weight				)
          # How much did we miss?
          a_     :							Dict     						=  (expected / 100) - layer_a
          # Error delta
          a_     :							Optional[Any]     						=  layer_1_error * sigmoid_function(UpperCamelCase__ ,    UpperCamelCase__				)
          # Update weight
          weight += INITIAL_VALUE * layer_1_delta

     return layer_a * 100


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 lowerCAmelCase_      :  str				     =  int(input('Expected value: '))
 lowerCAmelCase_      :  str				     =  int(input('Number of propagations: '))
 print(forward_propagation(expected, number_propagations))
