



import argparse
import logging

import numpy as np
import torch

from transformers import AutoModelForCausalLM, AutoTokenizer


logging.basicConfig(
    format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s''',
    datefmt='''%m/%d/%Y %H:%M:%S''',
    level=logging.INFO,
)
__lowerCamelCase								=      logging.getLogger(__name__)







def  _snake_case			(							__snake_case     )  ->  str:






      '''simple docstring'''







      np.random.seed(args.seed     )
      torch.manual_seed(args.seed     )
      if args.n_gpu > 0:
            torch.cuda.manual_seed_all(args.seed     )







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






      '''simple docstring'''







      UpperCAmelCase_	:						Optional[int]					   =		argparse.ArgumentParser()
      parser.add_argument(
          "--model_name_or_path"       ,	default=__snake_case       ,	type=__snake_case       ,	required=__snake_case       ,	)
      parser.add_argument("--prompt"       ,	type=__snake_case       ,	default=""     )
      parser.add_argument("--length"       ,	type=__snake_case       ,	default=2_0     )
      parser.add_argument("--stop_token"       ,	type=__snake_case       ,	default=__snake_case       ,	help="Token at which text generation is stopped"     )
      parser.add_argument(
          "--temperature"       ,	type=__snake_case       ,	default=1.0       ,	help="temperature of 1.0 has no effect, lower tend toward greedy sampling"       ,	)
      parser.add_argument(
          "--repetition_penalty"       ,	type=__snake_case       ,	default=1.0       ,	help="primarily useful for CTRL model; in that case, use 1.2"     )
      parser.add_argument("--k"       ,	type=__snake_case       ,	default=0     )
      parser.add_argument("--penalty_alpha"       ,	type=__snake_case       ,	default=0.0     )
      parser.add_argument("--p"       ,	type=__snake_case       ,	default=0.9     )

      parser.add_argument("--prefix"       ,	type=__snake_case       ,	default=""       ,	help="Text added prior to input."     )
      parser.add_argument("--padding_text"       ,	type=__snake_case       ,	default=""       ,	help="Deprecated, the use of `--prefix` is preferred."     )
      parser.add_argument("--xlm_language"       ,	type=__snake_case       ,	default=""       ,	help="Optional language when used with the XLM model."     )

      parser.add_argument("--seed"       ,	type=__snake_case       ,	default=4_2       ,	help="random seed for initialization"     )
      parser.add_argument("--no_cuda"       ,	action="store_true"       ,	help="Avoid using CUDA when available"     )
      parser.add_argument(
          "--fp16"       ,	action="store_true"       ,	help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit"       ,	)
      UpperCAmelCase_	:						Any					   =		parser.parse_args()

      UpperCAmelCase_	:						Any					   =		torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu"     )
      UpperCAmelCase_	:						int					   =		0 if args.no_cuda else torch.cuda.device_count()

      logger.warning(F"""device: {args.device}, n_gpu: {args.n_gpu}, 16-bits training: {args.fpaa}"""     )

      set_seed(__snake_case     )

      # Initialize the model and tokenizer
      UpperCAmelCase_	:						str					   =		AutoTokenizer.from_pretrained(args.model_name_or_path     )
      UpperCAmelCase_	:						List[Any]					   =		AutoModelForCausalLM.from_pretrained(args.model_name_or_path     )

      # tokenizer = GPT2Tokenizer.from_pretrained(args.model_name_or_path)
      # model = OPTForCausalLM.from_pretrained(args.model_name_or_path)
      model.to(args.device     )

      if args.fpaa:
            model.half()

      logger.info(__snake_case     )
      UpperCAmelCase_	:						Optional[int]					   =		args.prompt if args.prompt else input("Model prompt >>> "     )

      UpperCAmelCase_	:						Optional[Any]					   =		tokenizer(__snake_case       ,	return_tensors="pt"       ,	add_special_tokens=__snake_case     )
      UpperCAmelCase_	:						List[str]					   =		{key: value.to(args.device     ) for key, value in inputs.items()}

      UpperCAmelCase_	:						List[Any]					   =		model.generate(
          **__snake_case       ,	max_length=args.length + len(inputs["input_ids"][0]     )       ,	penalty_alpha=args.penalty_alpha       ,	top_k=args.k       ,	)

      UpperCAmelCase_	:						List[str]					   =		[]
      for generated_sequence_idx, generated_sequence in enumerate(__snake_case     ):
            print(F"""=== GENERATED SEQUENCE {generated_sequence_idx + 1} ==="""     )
            UpperCAmelCase_	:						Any					   =		generated_sequence.tolist()

            # Decode text
            UpperCAmelCase_	:						Optional[Any]					   =		tokenizer.decode(__snake_case       ,	clean_up_tokenization_spaces=__snake_case       ,	add_special_tokens=__snake_case     )

            # Remove all text after the stop token
            UpperCAmelCase_	:						List[Any]					   =		text[: text.find(args.stop_token     ) if args.stop_token else None]

            # Add the prompt at the beginning of the sequence. Remove the excess text that was used for pre-processing
            UpperCAmelCase_	:						str					   =		(
                prompt_text + text[len(tokenizer.decode(inputs["input_ids"][0]       ,	clean_up_tokenization_spaces=__snake_case     )     ) :]
            )

            generated_sequences.append(__snake_case     )
            print(__snake_case     )

      return generated_sequences


if __name__ == "__main__":
   main()






'''simple docstring'''





import jax
import jax.numpy as jnp
from bigbird_flax import FlaxBigBirdForNaturalQuestions
from datasets import load_from_disk

from transformers import BigBirdTokenizerFast


lowercase__								=						{0: '''null''', 1: '''short''', 2: '''long''', 3: '''yes''', 4: '''no'''}
lowercase__								=						set(''''''.join(['''‘''', '''’''', '''´''', '''`''', '''.''', ''',''', '''-''', '''"''']))


def 					UpperCamelCase						(	snake_case						,  snake_case=0						,  snake_case=None ):




   '''simple docstring'''

   return [" ".join(x.split(''' ''' )[begin:end] ) for x in answers if len(x.split(''' ''' ) ) > 1]


def 					UpperCamelCase						(	snake_case						,  snake_case=False ):




   '''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"
      SCREAMING_SNAKE_CASE__      :					Tuple							    =			(
          given_answers + get_sub_answers(snake_case						,  begin=1 ) + get_sub_answers(snake_case						,  end=-1 )
      )
   SCREAMING_SNAKE_CASE__      :					Any							    =			[]
   for answer in given_answers:
      SCREAMING_SNAKE_CASE__      :					int							    =			answer.replace('''_'''						,  ''' ''' ).lower()
      SCREAMING_SNAKE_CASE__      :					Tuple							    =			''''''.join(c if c not in PUNCTUATION_SET_TO_EXCLUDE else ''' ''' for c in alias )
      answers.append(''' '''.join(alias.split() ).strip() )
   return set(snake_case )


def 					UpperCamelCase						(	snake_case						,  snake_case						,  snake_case=1						,  snake_case=1_00 ):




   '''simple docstring'''

   SCREAMING_SNAKE_CASE__    ,					SCREAMING_SNAKE_CASE__      :					List[Any]							    =			jax.lax.top_k(snake_case						,  snake_case )
   SCREAMING_SNAKE_CASE__    ,					SCREAMING_SNAKE_CASE__      :					Optional[int]							    =			jax.lax.top_k(snake_case						,  snake_case )

   SCREAMING_SNAKE_CASE__      :					Optional[int]							    =			best_end_idx[:, None] - best_start_idx[None, :]
   SCREAMING_SNAKE_CASE__      :					Dict							    =			jnp.logical_or(widths < 0						,  widths > max_size )
   SCREAMING_SNAKE_CASE__      :					Any							    =			(best_end_scores[:, None] + best_start_scores[None, :]) - (1e8 * mask)
   SCREAMING_SNAKE_CASE__      :					str							    =			jnp.argmax(snake_case ).item()

   return best_start_idx[best_score % top_k], best_end_idx[best_score // top_k]


def 					UpperCamelCase						(	snake_case ):




   '''simple docstring'''

   SCREAMING_SNAKE_CASE__      :					Any							    =			sample['''question''']['''text''']
   SCREAMING_SNAKE_CASE__      :					Optional[int]							    =			sample['''document''']['''tokens''']['''token''']
   SCREAMING_SNAKE_CASE__      :					Tuple							    =			sample['''document''']['''tokens''']['''is_html''']
   SCREAMING_SNAKE_CASE__      :					Tuple							    =			sample['''annotations''']['''long_answer''']
   SCREAMING_SNAKE_CASE__      :					str							    =			sample['''annotations''']['''short_answers''']

   SCREAMING_SNAKE_CASE__      :					List[str]							    =			''' '''.join([context[i] for i in range(len(snake_case ) ) 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",
         }

   SCREAMING_SNAKE_CASE__      :					Optional[Any]							    =			[]
   for s in short_answers:
      short_targets.extend(s['''text'''] )
   SCREAMING_SNAKE_CASE__      :					Dict							    =			list(set(snake_case ) )

   SCREAMING_SNAKE_CASE__      :					Any							    =			[]
   for s in long_answers:
      if s["start_token"] == -1:
         continue
      SCREAMING_SNAKE_CASE__      :					List[Any]							    =			context[s['''start_token'''] : s['''end_token''']]
      SCREAMING_SNAKE_CASE__      :					Dict							    =			is_html[s['''start_token'''] : s['''end_token''']]
      SCREAMING_SNAKE_CASE__      :					List[str]							    =			''' '''.join([answer[i] for i in range(len(snake_case ) ) if not html[i]] )
      if new_answer not in long_targets:
         long_targets.append(snake_case )

   SCREAMING_SNAKE_CASE__      :					int							    =			'''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 					UpperCamelCase						(	):




   '''simple docstring'''

   SCREAMING_SNAKE_CASE__      :					List[Any]							    =			load_from_disk('''natural-questions-validation''' )
   SCREAMING_SNAKE_CASE__      :					List[Any]							    =			dataset.map(snake_case ).remove_columns(['''annotations''', '''document''', '''id'''] )
   print(snake_case )

   SCREAMING_SNAKE_CASE__      :					Dict							    =			dataset.filter(lambda snake_case : (len(x['''question'''] ) + len(x['''context'''] )) < 4 * 40_96 )
   SCREAMING_SNAKE_CASE__      :					Union[str, Any]							    =			short_validation_dataset.filter(lambda snake_case : x["category"] != "null" )
   short_validation_dataset

   SCREAMING_SNAKE_CASE__      :					List[Any]							    =			'''vasudevgupta/flax-bigbird-natural-questions'''
   SCREAMING_SNAKE_CASE__      :					Optional[Any]							    =			FlaxBigBirdForNaturalQuestions.from_pretrained(snake_case )
   SCREAMING_SNAKE_CASE__      :					List[str]							    =			BigBirdTokenizerFast.from_pretrained(snake_case )

   @jax.jit
   def forward(*snake_case						,  **snake_case ):
      SCREAMING_SNAKE_CASE__    ,					SCREAMING_SNAKE_CASE__    ,					SCREAMING_SNAKE_CASE__      :					str							    =			model(*snake_case						,  **snake_case )
      return start_logits, end_logits, jnp.argmax(snake_case						,  axis=-1 )

   def evaluate(snake_case ):
      # encode question and context so that they are separated by a tokenizer.sep_token and cut at max_length
      SCREAMING_SNAKE_CASE__      :					Any							    =			tokenizer(
          example['''question''']						,  example['''context''']						,  return_tensors='''np'''						,  max_length=40_96						,  padding='''max_length'''						,  truncation=snake_case						,  )

      SCREAMING_SNAKE_CASE__    ,					SCREAMING_SNAKE_CASE__    ,					SCREAMING_SNAKE_CASE__      :					Any							    =			forward(**snake_case )

      SCREAMING_SNAKE_CASE__      :					Union[str, Any]							    =			CATEGORY_MAPPING[category.item()]

      SCREAMING_SNAKE_CASE__      :					Union[str, Any]							    =			example['''long'''] + example['''short''']
      if example["category"] in ["yes", "no", "null"]:
         SCREAMING_SNAKE_CASE__      :					Tuple							    =			[example['''category''']]
      SCREAMING_SNAKE_CASE__      :					Tuple							    =			example['''category'''] != '''null'''
      # Now target can be: "yes", "no", "null", "list of long & short answers"

      if predicted_category in ["yes", "no", "null"]:
         SCREAMING_SNAKE_CASE__      :					str							    =			[predicted_category]
         SCREAMING_SNAKE_CASE__      :					Tuple							    =			example['''output'''] == example['''targets''']
         SCREAMING_SNAKE_CASE__      :					List[Any]							    =			predicted_category != '''null'''
         return example

      SCREAMING_SNAKE_CASE__      :					Any							    =			38 if predicted_category == '''short''' else 10_24
      SCREAMING_SNAKE_CASE__    ,					SCREAMING_SNAKE_CASE__      :					Tuple							    =			get_best_valid_start_end_idx(
          start_scores[0]						,  end_scores[0]						,  top_k=8						,  max_size=snake_case )

      SCREAMING_SNAKE_CASE__      :					Dict							    =			inputs['''input_ids'''][0].tolist()
      SCREAMING_SNAKE_CASE__      :					int							    =			[tokenizer.decode(input_ids[start_score : end_score + 1] )]

      SCREAMING_SNAKE_CASE__      :					Union[str, Any]							    =			expand_to_aliases(example['''targets''']						,  make_sub_answers=snake_case )
      SCREAMING_SNAKE_CASE__      :					Any							    =			expand_to_aliases(example['''output'''] )

      # some preprocessing to both prediction and answer
      SCREAMING_SNAKE_CASE__      :					Optional[Any]							    =			{''''''.join(a.split() ) for a in answers}
      SCREAMING_SNAKE_CASE__      :					List[Any]							    =			{''''''.join(p.split() ) for p in predictions}
      SCREAMING_SNAKE_CASE__      :					int							    =			{s for s in predictions if s not in ['''``''', '''\'\'''', '''`''', '''\'''']}

      # if there is a common element, it's a exact match
      SCREAMING_SNAKE_CASE__      :					Tuple							    =			len(list(answers & predictions ) ) > 0
      SCREAMING_SNAKE_CASE__      :					Optional[Any]							    =			predicted_category != '''null''' and len(snake_case ) > 0

      return example

   SCREAMING_SNAKE_CASE__      :					Optional[int]							    =			short_validation_dataset.map(snake_case )

   SCREAMING_SNAKE_CASE__      :					int							    =			len(snake_case )
   SCREAMING_SNAKE_CASE__      :					Union[str, Any]							    =			len(short_validation_dataset.filter(lambda snake_case : x["match"] == 1 ) )
   print('''EM score:'''						,  (matched / total) * 1_00						,  '''%''' )


if __name__ == "__main__":
       main()

