code: 
  
  import jax
  import jax.numpy as jnp
  from bigbird_flax import FlaxBigBirdForNaturalQuestions
  from datasets import load_from_disk
  
  from transformers import BigBirdTokenizerFast
  
  
  __snake_case             =	{0: '''null''', 1: '''short''', 2: '''long''', 3: '''yes''', 4: '''no'''}
  __snake_case             =	set(''''''.join(['''‘''', '''’''', '''´''', '''`''', '''.''', ''',''', '''-''', '''\"''']))
  
  
  
  
  
  
  def 		_A		(		_lowercase				,     _lowercase=0				,     _lowercase=None   )				->   str:
  
  
       """simple docstring"""
  
  
       return [" ".join(x.split(' '   )[begin:end]   ) for x in answers if len(x.split(' '   )   ) > 1]
  
  
  
  
  
  
  def 		_A		(		_lowercase				,     _lowercase=False   )				->   Union[str, Any]:
  
  
       """simple docstring"""
  
  
       if make_sub_answers:
            # if answers are longer than one word, make sure a predictions is correct if it coresponds to the complete 1: or :-1 sub word
            # *e.g.* if the correct answer contains a prefix such as "the", or "a"
            __UpperCamelCase   = (
                given_answers + get_sub_answers(lowercase__				,     begin=1   ) + get_sub_answers(lowercase__				,     end=-1   )
            )
       __UpperCamelCase   = []
       for answer in given_answers:
            __UpperCamelCase   = answer.replace('_'				,     ' '   ).lower()
            __UpperCamelCase   = "".join(c if c not in PUNCTUATION_SET_TO_EXCLUDE else ' ' for c in alias   )
            answers.append(' '.join(alias.split()   ).strip()   )
       return set(lowercase__   )
  
  
  
  
  
  
  def 		_A		(		_lowercase				,     _lowercase				,     _lowercase=1				,     _lowercase=1_00   )				->   List[str]:
  
  
       """simple docstring"""
  
  
       __UpperCamelCase   = jax.lax.top_k(lowercase__				,     lowercase__   )
       __UpperCamelCase   = jax.lax.top_k(lowercase__				,     lowercase__   )
  
       __UpperCamelCase   = best_end_idx[:, None] - best_start_idx[None, :]
       __UpperCamelCase   = jnp.logical_or(widths < 0				,     widths > max_size   )
       __UpperCamelCase   = (best_end_scores[:, None] + best_start_scores[None, :]) - (1e8 * mask)
       __UpperCamelCase   = jnp.argmax(lowercase__   ).item()
  
       return best_start_idx[best_score % top_k], best_end_idx[best_score // top_k]
  
  
  
  
  
  
  def 		_A		(		_lowercase   )				->   Any:
  
  
       """simple docstring"""
  
  
       __UpperCamelCase   = sample["question"]["text"]
       __UpperCamelCase   = sample["document"]["tokens"]["token"]
       __UpperCamelCase   = sample["document"]["tokens"]["is_html"]
       __UpperCamelCase   = sample["annotations"]["long_answer"]
       __UpperCamelCase   = sample["annotations"]["short_answers"]
  
       __UpperCamelCase   = " ".join([context[i] for i in range(len(lowercase__   )   ) if not is_html[i]]   )
  
       # 0 - No ; 1 - Yes
       for answer in sample["annotations"]["yes_no_answer"]:
            if answer == 0 or answer == 1:
                 return {
                     "question": question,
                     "context": context_string,
                     "short": [],
                     "long": [],
                     "category": "no" if answer == 0 else "yes",
                 }
  
       __UpperCamelCase   = []
       for s in short_answers:
            short_targets.extend(s['text']   )
       __UpperCamelCase   = list(set(lowercase__   )   )
  
       __UpperCamelCase   = []
       for s in long_answers:
            if s["start_token"] == -1:
                 continue
            __UpperCamelCase   = context[s["start_token"] : s["end_token"]]
            __UpperCamelCase   = is_html[s["start_token"] : s["end_token"]]
            __UpperCamelCase   = " ".join([answer[i] for i in range(len(lowercase__   )   ) if not html[i]]   )
            if new_answer not in long_targets:
                 long_targets.append(lowercase__   )
  
       __UpperCamelCase   = "long_short" if len(short_targets + long_targets   ) > 0 else "null"
  
       return {
           "question": question,
           "context": context_string,
           "short": short_targets,
           "long": long_targets,
           "category": category,
       }
  
  
  
  
  
  
  def 		_A		(		)				->   str:
  
  
       """simple docstring"""
  
  
       __UpperCamelCase   = load_from_disk('natural-questions-validation'   )
       __UpperCamelCase   = dataset.map(lowercase__   ).remove_columns(['annotations', 'document', 'id']   )
       print(lowercase__   )
  
       __UpperCamelCase   = dataset.filter(lambda _lowercase   : (len(x['question']   ) + len(x['context']   )) < 4 * 40_96   )
       __UpperCamelCase   = short_validation_dataset.filter(lambda _lowercase   : x["category"] != "null"   )
       short_validation_dataset
  
       __UpperCamelCase   = "vasudevgupta/flax-bigbird-natural-questions"
       __UpperCamelCase   = FlaxBigBirdForNaturalQuestions.from_pretrained(lowercase__   )
       __UpperCamelCase   = BigBirdTokenizerFast.from_pretrained(lowercase__   )
  
       @jax.jit
       def forward(*_lowercase				,     **_lowercase   ):
            __UpperCamelCase   = model(*lowercase__				,     **lowercase__   )
            return start_logits, end_logits, jnp.argmax(lowercase__				,     axis=-1   )
  
       def evaluate(_lowercase   ):
            # encode question and context so that they are separated by a tokenizer.sep_token and cut at max_length
            __UpperCamelCase   = tokenizer(
                example['question']				,     example['context']				,     return_tensors='np'				,     max_length=40_96				,     padding='max_length'				,     truncation=lowercase__				,     )
  
            __UpperCamelCase   = forward(**lowercase__   )
  
            __UpperCamelCase   = CATEGORY_MAPPING[category.item()]
  
            __UpperCamelCase   = example["long"] + example["short"]
            if example["category"] in ["yes", "no", "null"]:
                 __UpperCamelCase   = [example["category"]]
            __UpperCamelCase   = example["category"] != "null"
            # Now target can be: "yes", "no", "null", "list of long & short answers"
  
            if predicted_category in ["yes", "no", "null"]:
                 __UpperCamelCase   = [predicted_category]
                 __UpperCamelCase   = example["output"] == example["targets"]
                 __UpperCamelCase   = predicted_category != "null"
                 return example
  
            __UpperCamelCase   = 38 if predicted_category == "short" else 10_24
            __UpperCamelCase   = get_best_valid_start_end_idx(
                start_scores[0]				,     end_scores[0]				,     top_k=8				,     max_size=lowercase__   )
  
            __UpperCamelCase   = inputs["input_ids"][0].tolist()
            __UpperCamelCase   = [tokenizer.decode(input_ids[start_score : end_score + 1]   )]
  
            __UpperCamelCase   = expand_to_aliases(example['targets']				,     make_sub_answers=lowercase__   )
            __UpperCamelCase   = expand_to_aliases(example['output']   )
  
            # some preprocessing to both prediction and answer
            __UpperCamelCase   = {"".join(a.split()   ) for a in answers}
            __UpperCamelCase   = {"".join(p.split()   ) for p in predictions}
            __UpperCamelCase   = {s for s in predictions if s not in ["``", "''", "`", "'"]}
  
            # if there is a common element, it's a exact match
            __UpperCamelCase   = len(list(answers & predictions   )   ) > 0
            __UpperCamelCase   = predicted_category != "null" and len(lowercase__   ) > 0
  
            return example
  
       __UpperCamelCase   = short_validation_dataset.map(lowercase__   )
  
       __UpperCamelCase   = len(lowercase__   )
       __UpperCamelCase   = len(short_validation_dataset.filter(lambda _lowercase   : x["match"] == 1   )   )
       print('EM score:'				,     (matched / total) * 1_00				,     '%'   )
  
  
  if __name__ == "__main__":
      main()
  
  
  
style_context: 
  
  
  def 		_A		(		_lowercase   )				->   bool:
  
  
       """simple docstring"""
  
  
       if not isinstance(_lowercase				,     _lowercase   ):
            raise ValueError('Input series is not valid, valid series - [1, 2/3, 2]'   )
       if len(_lowercase   ) == 0:
            raise ValueError('Input list must be a non empty list'   )
       if len(_lowercase   ) == 1 and series[0] != 0:
            return True
       __UpperCamelCase   = []
       __UpperCamelCase   = len(_lowercase   )
       for i in range(0				,     _lowercase   ):
            if series[i] == 0:
                 raise ValueError('Input series cannot have 0 as an element'   )
            rec_series.append(1 / series[i]   )
       __UpperCamelCase   = rec_series[1] - rec_series[0]
       for index in range(2				,     _lowercase   ):
            if rec_series[index] - rec_series[index - 1] != common_diff:
                 return False
       return True
  
  
  
  
  
  
  def 		_A		(		_lowercase   )				->   float:
  
  
       """simple docstring"""
  
  
       if not isinstance(_lowercase				,     _lowercase   ):
            raise ValueError('Input series is not valid, valid series - [2, 4, 6]'   )
       if len(_lowercase   ) == 0:
            raise ValueError('Input list must be a non empty list'   )
       __UpperCamelCase   = 0
       for val in series:
            answer += 1 / val
       return len(_lowercase   ) / answer
  
  
  if __name__ == "__main__":
      import doctest
  
      doctest.testmod()
  
  
  