code: import jax
  import jax.numpy as jnp
  from bigbird_flax import FlaxBigBirdForNaturalQuestions
  from datasets import load_from_disk
  
  from transformers import BigBirdTokenizerFast
  
  
  UpperCAmelCase					=				{0: '''null''', 1: '''short''', 2: '''long''', 3: '''yes''', 4: '''no'''}
  UpperCAmelCase					=				set(''''''.join(['''‘''', '''’''', '''´''', '''`''', '''.''', ''',''', '''-''', '''"''']))
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	int		,						lowercase_:	Optional[Any]=0		,						lowercase_:	int=None				):
         return [" ".join(x.split(' '				)[begin:end]				) for x in answers if len(x.split(' '				)				) > 1]
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	Any		,						lowercase_:	List[str]=False				):
  
  
  
  
  
  
         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     :       int  						=  (
                    given_answers + get_sub_answers(_UpperCAmelCase		,						begin=1				) + get_sub_answers(_UpperCAmelCase		,						end=-1				)
                )
         _UpperCamelCase     :       Dict  						=  []
         for answer in given_answers:
                _UpperCamelCase     :       int  						=  answer.replace('_'		,						' '				).lower()
                _UpperCamelCase     :       Optional[int]  						=  ''.join(c if c not in PUNCTUATION_SET_TO_EXCLUDE else ' ' for c in alias				)
                answers.append(' '.join(alias.split()				).strip()				)
         return set(_UpperCAmelCase				)
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	Tuple		,						lowercase_:	Dict		,						lowercase_:	int=1		,						lowercase_:	Optional[Any]=100				):
         _UpperCamelCase     :       Optional[Any]  						=  jax.lax.top_k(_UpperCAmelCase		,						_UpperCAmelCase				)
         _UpperCamelCase     :       List[Any]  						=  jax.lax.top_k(_UpperCAmelCase		,						_UpperCAmelCase				)
  
         _UpperCamelCase     :       Any  						=  best_end_idx[:, None] - best_start_idx[None, :]
         _UpperCamelCase     :       Union[str, Any]  						=  jnp.logical_or(widths < 0		,						widths > max_size				)
         _UpperCamelCase     :       str  						=  (best_end_scores[:, None] + best_start_scores[None, :]) - (1e8 * mask)
         _UpperCamelCase     :       Tuple  						=  jnp.argmax(_UpperCAmelCase				).item()
  
         return best_start_idx[best_score % top_k], best_end_idx[best_score // top_k]
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	List[str]				):
         _UpperCamelCase     :       Tuple  						=  sample['question']['text']
         _UpperCamelCase     :       int  						=  sample['document']['tokens']['token']
         _UpperCamelCase     :       str  						=  sample['document']['tokens']['is_html']
         _UpperCamelCase     :       Dict  						=  sample['annotations']['long_answer']
         _UpperCamelCase     :       Union[str, Any]  						=  sample['annotations']['short_answers']
  
         _UpperCamelCase     :       Any  						=  ' '.join([context[i] for i in range(len(_UpperCAmelCase				)				) 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     :       Tuple  						=  []
         for s in short_answers:
                short_targets.extend(s['text']				)
         _UpperCamelCase     :       Any  						=  list(set(_UpperCAmelCase				)				)
  
         _UpperCamelCase     :       Union[str, Any]  						=  []
         for s in long_answers:
                if s["start_token"] == -1:
                       continue
                _UpperCamelCase     :       Any  						=  context[s['start_token'] : s['end_token']]
                _UpperCamelCase     :       int  						=  is_html[s['start_token'] : s['end_token']]
                _UpperCamelCase     :       Optional[int]  						=  ' '.join([answer[i] for i in range(len(_UpperCAmelCase				)				) if not html[i]]				)
                if new_answer not in long_targets:
                       long_targets.append(_UpperCAmelCase				)
  
         _UpperCamelCase     :       Dict  						=  '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 SCREAMING_SNAKE_CASE				(     ):
         _UpperCamelCase     :       Union[str, Any]  						=  load_from_disk('natural-questions-validation'				)
         _UpperCamelCase     :       Tuple  						=  dataset.map(_UpperCAmelCase				).remove_columns(['annotations', 'document', 'id']				)
         print(_UpperCAmelCase				)
  
         _UpperCamelCase     :       Optional[Any]  						=  dataset.filter(lambda lowercase_				: (len(x['question']				) + len(x['context']				)) < 4 * 4096				)
         _UpperCamelCase     :       int  						=  short_validation_dataset.filter(lambda lowercase_				: x["category"] != "null"				)
         short_validation_dataset
  
         _UpperCamelCase     :       Dict  						=  'vasudevgupta/flax-bigbird-natural-questions'
         _UpperCamelCase     :       Any  						=  FlaxBigBirdForNaturalQuestions.from_pretrained(_UpperCAmelCase				)
         _UpperCamelCase     :       int  						=  BigBirdTokenizerFast.from_pretrained(_UpperCAmelCase				)
  
         @jax.jit
         def forward(*lowercase_:	Tuple		,						**lowercase_:	int				):
                _UpperCamelCase     :       List[Any]  						=  model(*_UpperCAmelCase		,						**_UpperCAmelCase				)
                return start_logits, end_logits, jnp.argmax(_UpperCAmelCase		,						axis=-1				)
  
         def evaluate(lowercase_:	Union[str, Any]				):
                # encode question and context so that they are separated by a tokenizer.sep_token and cut at max_length
                _UpperCamelCase     :       List[str]  						=  tokenizer(
                    example['question']		,						example['context']		,						return_tensors='np'		,						max_length=4096		,						padding='max_length'		,						truncation=_UpperCAmelCase		,						)
  
                _UpperCamelCase     :       Optional[int]  						=  forward(**_UpperCAmelCase				)
  
                _UpperCamelCase     :       str  						=  CATEGORY_MAPPING[category.item()]
  
                _UpperCamelCase     :       List[Any]  						=  example['long'] + example['short']
                if example["category"] in ["yes", "no", "null"]:
                       _UpperCamelCase     :       Dict  						=  [example['category']]
                _UpperCamelCase     :       Dict  						=  example['category'] != 'null'
                # Now target can be: "yes", "no", "null", "list of long & short answers"
  
                if predicted_category in ["yes", "no", "null"]:
                       _UpperCamelCase     :       Dict  						=  [predicted_category]
                       _UpperCamelCase     :       Any  						=  example['output'] == example['targets']
                       _UpperCamelCase     :       Union[str, Any]  						=  predicted_category != 'null'
                       return example
  
                _UpperCamelCase     :       Optional[Any]  						=  38 if predicted_category == 'short' else 1024
                _UpperCamelCase     :       str  						=  get_best_valid_start_end_idx(
                    start_scores[0]		,						end_scores[0]		,						top_k=8		,						max_size=_UpperCAmelCase				)
  
                _UpperCamelCase     :       Optional[int]  						=  inputs['input_ids'][0].tolist()
                _UpperCamelCase     :       str  						=  [tokenizer.decode(input_ids[start_score : end_score + 1]				)]
  
                _UpperCamelCase     :       Optional[int]  						=  expand_to_aliases(example['targets']		,						make_sub_answers=_UpperCAmelCase				)
                _UpperCamelCase     :       List[Any]  						=  expand_to_aliases(example['output']				)
  
                # some preprocessing to both prediction and answer
                _UpperCamelCase     :       str  						=  {''.join(a.split()				) for a in answers}
                _UpperCamelCase     :       List[Any]  						=  {''.join(p.split()				) for p in predictions}
                _UpperCamelCase     :       Union[str, Any]  						=  {s for s in predictions if s not in ['``', '\'\'', '`', '\'']}
  
                # if there is a common element, it's a exact match
                _UpperCamelCase     :       Tuple  						=  len(list(answers & predictions				)				) > 0
                _UpperCamelCase     :       Optional[Any]  						=  predicted_category != 'null' and len(_UpperCAmelCase				) > 0
  
                return example
  
         _UpperCamelCase     :       Optional[Any]  						=  short_validation_dataset.map(_UpperCAmelCase				)
  
         _UpperCamelCase     :       List[str]  						=  len(_UpperCAmelCase				)
         _UpperCamelCase     :       int  						=  len(short_validation_dataset.filter(lambda lowercase_				: x["match"] == 1				)				)
         print('EM score:'		,						(matched / total) * 100		,						'%'				)
  
  
  if __name__ == "__main__":
   main()
  
  
  
  
style_context: from .chunk_utils import chunk_layer
  from .data_transforms import make_atomaa_masks
  from .feats import atomaa_to_atomaa, frames_and_literature_positions_to_atomaa_pos, torsion_angles_to_frames
  from .loss import compute_predicted_aligned_error, compute_tm
  from .protein import Protein as OFProtein
  from .protein import to_pdb
  from .rigid_utils import Rigid, Rotation
  from .tensor_utils import dict_multimap, flatten_final_dims, permute_final_dims
  
  
  
  