


'''simple docstring'''





import math
import unittest

from transformers import BioGptConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    BioGptForCausalLM,
	    BioGptForSequenceClassification,
	    BioGptForTokenClassification,
	    BioGptModel,
	    BioGptTokenizer,
	)
	from transformers.models.biogpt.modeling_biogpt import BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST
class 	lowerCamelCase_       :



					'''simple docstring'''







					def __init__(				self ,       snake_case_ ,       snake_case_=1_3 ,       snake_case_=7 ,       snake_case_=True ,       snake_case_=True ,       snake_case_=False ,       snake_case_=True ,       snake_case_=9_9 ,       snake_case_=3_2 ,       snake_case_=5 ,       snake_case_=4 ,       snake_case_=3_7 ,       snake_case_="gelu" ,       snake_case_=0.1 ,       snake_case_=0.1 ,       snake_case_=5_1_2 ,       snake_case_=1_6 ,       snake_case_=2 ,       snake_case_=0.0_2 ,       snake_case_=3 ,       snake_case_=4 ,       snake_case_=None ,       )   ->			List[Any]:







								'''simple docstring'''

								__lowercase 					=   parent
								__lowercase 					=   batch_size
								__lowercase 					=   seq_length
								__lowercase 					=   is_training
								__lowercase 					=   use_input_mask
								__lowercase 					=   use_token_type_ids
								__lowercase 					=   use_labels
								__lowercase 					=   vocab_size
								__lowercase 					=   hidden_size
								__lowercase 					=   num_hidden_layers
								__lowercase 					=   num_attention_heads
								__lowercase 					=   intermediate_size
								__lowercase 					=   hidden_act
								__lowercase 					=   hidden_dropout_prob
								__lowercase 					=   attention_probs_dropout_prob
								__lowercase 					=   max_position_embeddings
								__lowercase 					=   type_vocab_size
								__lowercase 					=   type_sequence_label_size
								__lowercase 					=   initializer_range
								__lowercase 					=   num_labels
								__lowercase 					=   num_choices
								__lowercase 					=   scope






					def A      (				self						)   ->			Dict:







								'''simple docstring'''

								__lowercase 					=   ids_tensor([self.batch_size, self.seq_length] ,       self.vocab_size						)

								__lowercase 					=   None
								if self.use_input_mask:
											__lowercase 					=   random_attention_mask([self.batch_size, self.seq_length]						)

								__lowercase 					=   None
								if self.use_token_type_ids:
											__lowercase 					=   ids_tensor([self.batch_size, self.seq_length] ,       self.type_vocab_size						)

								__lowercase 					=   None
								__lowercase 					=   None
								__lowercase 					=   None
								if self.use_labels:
											__lowercase 					=   ids_tensor([self.batch_size] ,       self.type_sequence_label_size						)
											__lowercase 					=   ids_tensor([self.batch_size, self.seq_length] ,       self.num_labels						)
											__lowercase 					=   ids_tensor([self.batch_size] ,       self.num_choices						)

								__lowercase 					=   self.get_config()

								return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






					def A      (				self						)   ->			List[str]:







								'''simple docstring'''

								return BioGptConfig(
								    vocab_size=self.vocab_size ,       hidden_size=self.hidden_size ,       num_hidden_layers=self.num_hidden_layers ,       num_attention_heads=self.num_attention_heads ,       intermediate_size=self.intermediate_size ,       hidden_act=self.hidden_act ,       hidden_dropout_prob=self.hidden_dropout_prob ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob ,       max_position_embeddings=self.max_position_embeddings ,       type_vocab_size=self.type_vocab_size ,       is_decoder=snake_case_ ,       initializer_range=self.initializer_range ,       )






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_						)   ->			Dict:







								'''simple docstring'''

								__lowercase 					=   BioGptModel(config=snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   model(snake_case_ ,       attention_mask=snake_case_						)
								__lowercase 					=   model(snake_case_						)
								self.parent.assertEqual(result.last_hidden_state.shape ,       (self.batch_size, self.seq_length, self.hidden_size)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       )   ->			List[Any]:







								'''simple docstring'''

								__lowercase 					=   BioGptForCausalLM(config=snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   model(snake_case_ ,       attention_mask=snake_case_ ,       token_type_ids=snake_case_ ,       labels=snake_case_						)
								self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.vocab_size)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       *snake_case_						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   BioGptModel(config=snake_case_						)
								model.to(snake_case_						)
								model.eval()

								# create attention mask
								__lowercase 					=   torch.ones(input_ids.shape ,       dtype=torch.long ,       device=snake_case_						)
								__lowercase 					=   self.seq_length // 2
								__lowercase 					=   0

								# first forward pass
								__lowercase					, __lowercase 					=   model(snake_case_ ,       attention_mask=snake_case_						).to_tuple()

								# create hypothetical next token and extent to next_input_ids
								__lowercase 					=   ids_tensor((self.batch_size, 1) ,       config.vocab_size						)

								# change a random masked slice from input_ids
								__lowercase 					=   ids_tensor((1,) ,       snake_case_						).item() + 1
								__lowercase 					=   ids_tensor((self.batch_size, 1) ,       config.vocab_size						).squeeze(-1						)
								__lowercase 					=   random_other_next_tokens

								# append to next input_ids and attn_mask
								__lowercase 					=   torch.cat([input_ids, next_tokens] ,       dim=-1						)
								__lowercase 					=   torch.cat(
								    [attn_mask, torch.ones((attn_mask.shape[0], 1) ,       dtype=torch.long ,       device=snake_case_						)] ,       dim=1 ,       )

								# get two different outputs
								__lowercase 					=   model(snake_case_ ,       attention_mask=snake_case_						)['''last_hidden_state''']
								__lowercase 					=   model(snake_case_ ,       past_key_values=snake_case_ ,       attention_mask=snake_case_						)['''last_hidden_state''']

								# select random slice
								__lowercase 					=   ids_tensor((1,) ,       output_from_past.shape[-1]						).item()
								__lowercase 					=   output_from_no_past[:, -1, random_slice_idx].detach()
								__lowercase 					=   output_from_past[:, 0, random_slice_idx].detach()

								# test that outputs are equal for slice
								self.parent.assertTrue(torch.allclose(snake_case_ ,       snake_case_ ,       atol=1e-3						)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       *snake_case_						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   BioGptModel(config=snake_case_						).to(snake_case_						).eval()

								__lowercase 					=   torch.ones(input_ids.shape ,       dtype=torch.long ,       device=snake_case_						)

								# first forward pass
								__lowercase 					=   model(snake_case_ ,       attention_mask=snake_case_ ,       use_cache=snake_case_						)

								__lowercase					, __lowercase 					=   outputs.to_tuple()

								# create hypothetical multiple next token and extent to next_input_ids
								__lowercase 					=   ids_tensor((self.batch_size, 3) ,       config.vocab_size						)
								__lowercase 					=   ids_tensor((self.batch_size, 3) ,       2						)

								# append to next input_ids and
								__lowercase 					=   torch.cat([input_ids, next_tokens] ,       dim=-1						)
								__lowercase 					=   torch.cat([attention_mask, next_attn_mask] ,       dim=-1						)

								__lowercase 					=   model(snake_case_ ,       attention_mask=snake_case_						)['''last_hidden_state''']
								__lowercase 					=   model(snake_case_ ,       attention_mask=snake_case_ ,       past_key_values=snake_case_						)[
								    '''last_hidden_state'''
								]

								# select random slice
								__lowercase 					=   ids_tensor((1,) ,       output_from_past.shape[-1]						).item()
								__lowercase 					=   output_from_no_past[:, -3:, random_slice_idx].detach()
								__lowercase 					=   output_from_past[:, :, random_slice_idx].detach()

								self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]						)

								# test that outputs are equal for slice
								self.parent.assertTrue(torch.allclose(snake_case_ ,       snake_case_ ,       atol=1e-3						)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       *snake_case_ ,       snake_case_=False						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   BioGptForCausalLM(snake_case_						)
								model.to(snake_case_						)
								if gradient_checkpointing:
											model.gradient_checkpointing_enable()

								__lowercase 					=   model(snake_case_ ,       labels=snake_case_						)
								self.parent.assertEqual(result.loss.shape ,       ()						)
								self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.vocab_size)						)
								result.loss.backward()






					def A      (				self ,       snake_case_ ,       *snake_case_						)   ->			Optional[int]:







								'''simple docstring'''

								__lowercase 					=   BioGptModel(snake_case_						)
								__lowercase 					=   model.config.initializer_range / math.sqrt(2 * model.config.num_hidden_layers						)
								for key in model.state_dict().keys():
											if "c_proj" in key and "weight" in key:
														self.parent.assertLessEqual(abs(torch.std(model.state_dict()[key]						) - model_std						) ,       0.0_0_1						)
														self.parent.assertLessEqual(abs(torch.mean(model.state_dict()[key]						) - 0.0						) ,       0.0_1						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       *snake_case_						)   ->			Dict:







								'''simple docstring'''

								__lowercase 					=   self.num_labels
								__lowercase 					=   BioGptForTokenClassification(snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   model(snake_case_ ,       attention_mask=snake_case_ ,       token_type_ids=snake_case_						)
								self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.num_labels)						)






					def A      (				self						)   ->			Dict:







								'''simple docstring'''

								__lowercase 					=   self.prepare_config_and_inputs()
								(
								    (
								    __lowercase 
								)					, (
								    __lowercase 
								)					, (
								    __lowercase 
								)					, (
								    __lowercase 
								)					, (
								    __lowercase 
								)					, (
								    __lowercase 
								)					, (
								    __lowercase 
								)					,  
								) 					=   config_and_inputs
								__lowercase 					=   {'''input_ids''': input_ids, '''attention_mask''': input_mask}
								return config, inputs_dict




@require_torch
class 	lowerCamelCase_       (				lowerCAmelCase__     ,     lowerCAmelCase__     ,     lowerCAmelCase__     ,     unittest.TestCase				):



					'''simple docstring'''







					__UpperCAmelCase            =				(
					    (BioGptModel, BioGptForCausalLM, BioGptForSequenceClassification, BioGptForTokenClassification)
					    if is_torch_available()
					    else ()
					)
					__UpperCAmelCase            =				(BioGptForCausalLM,) if is_torch_available() else ()
					__UpperCAmelCase            =				(
					    {
					        "feature-extraction": BioGptModel,
					        "text-classification": BioGptForSequenceClassification,
					        "text-generation": BioGptForCausalLM,
					        "token-classification": BioGptForTokenClassification,
					        "zero-shot": BioGptForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					__UpperCAmelCase            =				False






					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   BioGptModelTester(self						)
								__lowercase 					=   ConfigTester(self ,       config_class=snake_case_ ,       hidden_size=3_7						)






					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								self.config_tester.run_common_tests()






					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case_						)






					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
											__lowercase 					=   type
											self.model_tester.create_and_check_model(*snake_case_						)






					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_biogpt_model_attention_mask_past(*snake_case_						)






					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_forward_and_backwards(*snake_case_ ,       gradient_checkpointing=snake_case_						)






					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_biogpt_model_past_large_inputs(*snake_case_						)






					def A      (				self						)   ->			List[Any]:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_biogpt_weight_initialization(*snake_case_						)






					def A      (				self						)   ->			List[str]:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_biogpt_for_token_classification(*snake_case_						)






					@slow
					def A      (				self						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   BioGptForCausalLM.from_pretrained('''microsoft/biogpt'''						)
								model.to(snake_case_						)
								__lowercase 					=   BioGptTokenizer.from_pretrained('''microsoft/biogpt'''						)

								__lowercase 					=   '''left'''

								# Define PAD Token = EOS Token = 50256
								__lowercase 					=   tokenizer.eos_token
								__lowercase 					=   model.config.eos_token_id

								# use different length sentences to test batching
								__lowercase 					=   [
								    '''Hello, my dog is a little''',
								    '''Today, I''',
								]

								__lowercase 					=   tokenizer(snake_case_ ,       return_tensors='''pt''' ,       padding=snake_case_						)
								__lowercase 					=   inputs['''input_ids'''].to(snake_case_						)

								__lowercase 					=   model.generate(
								    input_ids=snake_case_ ,       attention_mask=inputs['''attention_mask'''].to(snake_case_						) ,       )

								__lowercase 					=   tokenizer(sentences[0] ,       return_tensors='''pt'''						).input_ids.to(snake_case_						)
								__lowercase 					=   model.generate(input_ids=snake_case_						)

								__lowercase 					=   inputs_non_padded.shape[-1] - inputs['''attention_mask'''][-1].long().sum().cpu().item()
								__lowercase 					=   tokenizer(sentences[1] ,       return_tensors='''pt'''						).input_ids.to(snake_case_						)
								__lowercase 					=   model.generate(input_ids=snake_case_ ,       max_length=model.config.max_length - num_paddings						)

								__lowercase 					=   tokenizer.batch_decode(snake_case_ ,       skip_special_tokens=snake_case_						)
								__lowercase 					=   tokenizer.decode(output_non_padded[0] ,       skip_special_tokens=snake_case_						)
								__lowercase 					=   tokenizer.decode(output_padded[0] ,       skip_special_tokens=snake_case_						)

								__lowercase 					=   [
								    '''Hello, my dog is a little bit bigger than a little bit.''',
								    '''Today, I have a good idea of how to use the information''',
								]
								self.assertListEqual(snake_case_ ,       snake_case_						)
								self.assertListEqual(snake_case_ ,       [non_padded_sentence, padded_sentence]						)






					@slow
					def A      (				self						)   ->			Tuple:







								'''simple docstring'''

								for model_name in BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase 					=   BioGptModel.from_pretrained(snake_case_						)
											self.assertIsNotNone(snake_case_						)






					def A      (				self						)   ->			Dict:







								'''simple docstring'''

								__lowercase					, __lowercase 					=   self.model_tester.prepare_config_and_inputs_for_common()
								__lowercase 					=   3
								__lowercase 					=   input_dict['''input_ids''']
								__lowercase 					=   input_ids.ne(1						).to(snake_case_						)
								__lowercase 					=   ids_tensor([self.model_tester.batch_size] ,       self.model_tester.type_sequence_label_size						)
								__lowercase 					=   BioGptForSequenceClassification(snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   model(snake_case_ ,       attention_mask=snake_case_ ,       labels=snake_case_						)
								self.assertEqual(result.logits.shape ,       (self.model_tester.batch_size, self.model_tester.num_labels)						)






					def A      (				self						)   ->			Any:







								'''simple docstring'''

								__lowercase					, __lowercase 					=   self.model_tester.prepare_config_and_inputs_for_common()
								__lowercase 					=   3
								__lowercase 					=   '''multi_label_classification'''
								__lowercase 					=   input_dict['''input_ids''']
								__lowercase 					=   input_ids.ne(1						).to(snake_case_						)
								__lowercase 					=   ids_tensor(
								    [self.model_tester.batch_size, config.num_labels] ,       self.model_tester.type_sequence_label_size						).to(torch.float						)
								__lowercase 					=   BioGptForSequenceClassification(snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   model(snake_case_ ,       attention_mask=snake_case_ ,       labels=snake_case_						)
								self.assertEqual(result.logits.shape ,       (self.model_tester.batch_size, self.model_tester.num_labels)						)




@require_torch
class 	lowerCamelCase_       (				unittest.TestCase				):



					'''simple docstring'''







					@slow
					def A      (				self						)   ->			Any:







								'''simple docstring'''

								__lowercase 					=   BioGptForCausalLM.from_pretrained('''microsoft/biogpt'''						)
								__lowercase 					=   torch.tensor([[2, 4_8_0_5, 9, 6_5_6, 2_1]]						)
								__lowercase 					=   model(snake_case_						)[0]

								__lowercase 					=   4_2_3_8_4

								__lowercase 					=   torch.Size((1, 5, vocab_size)						)
								self.assertEqual(output.shape ,       snake_case_						)

								__lowercase 					=   torch.tensor(
								    [[[-9.5_2_3_6, -9.8_9_1_8, 1_0.4_5_5_7], [-1_1.0_4_6_9, -9.6_4_2_3, 8.1_0_2_2], [-8.8_6_6_4, -7.8_8_2_6, 5.5_3_2_5]]]						)

								self.assertTrue(torch.allclose(output[:, :3, :3] ,       snake_case_ ,       atol=1e-4						)						)






					@slow
					def A      (				self						)   ->			List[str]:







								'''simple docstring'''

								__lowercase 					=   BioGptTokenizer.from_pretrained('''microsoft/biogpt'''						)
								__lowercase 					=   BioGptForCausalLM.from_pretrained('''microsoft/biogpt'''						)
								model.to(snake_case_						)

								torch.manual_seed(0						)
								__lowercase 					=   tokenizer('''COVID-19 is''' ,       return_tensors='''pt'''						).to(snake_case_						)
								__lowercase 					=   model.generate(
								    **snake_case_ ,       min_length=1_0_0 ,       max_length=1_0_2_4 ,       num_beams=5 ,       early_stopping=snake_case_ ,       )
								__lowercase 					=   tokenizer.decode(output_ids[0] ,       skip_special_tokens=snake_case_						)

								__lowercase 					=   (
								    '''COVID-19 is a global pandemic caused by severe acute respiratory syndrome coronavirus 2 (SARS-CoV-2), the'''
								    ''' causative agent of coronavirus disease 2019 (COVID-19), which has spread to more than 200 countries and'''
								    ''' territories, including the United States (US), Canada, Australia, New Zealand, the United Kingdom (UK),'''
								    ''' and the United States of America (USA), as of March 11, 2020, with more than 800,000 confirmed cases and'''
								    ''' more than 800,000 deaths.'''
								)
								self.assertEqual(snake_case_ ,       snake_case_						)






from __future__ import annotations

import typing
from collections.abc import Iterable

import numpy as np

a : Optional[int]		=				typing.Union[Iterable[float], Iterable[int], np.ndarray]  # noqa: UP007
a : Union[str, Any]		=				typing.Union[np.floataa, int, float]  # noqa: UP007


def 		lowercase_  (     _UpperCamelCase       ,			_UpperCamelCase  ):


			'''simple docstring'''







			return np.sqrt(np.sum((np.asarray(_UpperCamelCase  ) - np.asarray(_UpperCamelCase  )) ** 2  )  )


def 		lowercase_  (     _UpperCamelCase       ,			_UpperCamelCase  ):


			'''simple docstring'''







			return sum((va - va) ** 2 for va, va in zip(_UpperCamelCase       ,			_UpperCamelCase  )  ) ** (1 / 2)


if __name__ == "__main__":


	def 		lowercase_  (     ):


				'''simple docstring'''







				from timeit import timeit

				print('''Without Numpy'''  )
				print(
				    timeit(
				        '''euclidean_distance_no_np([1, 2, 3], [4, 5, 6])'''       ,			number=1_00_00       ,			globals=globals()       ,			)  )
				print('''With Numpy'''  )
				print(
				    timeit(
				        '''euclidean_distance([1, 2, 3], [4, 5, 6])'''       ,			number=1_00_00       ,			globals=globals()       ,			)  )





	benchmark()


