



import tempfile
import unittest

import numpy as np

import transformers
from transformers import GPTaConfig, GPTaTokenizer, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
							import jax
							import jax.numpy as jnp

							from transformers.modeling_flax_pytorch_utils import (
							    convert_pytorch_state_dict_to_flax,
							    load_flax_weights_in_pytorch_model,
							)
							from transformers.models.gpta.modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel

if is_torch_available():
							import torch







class 				a_    :

						def __init__(       self      :Any  ,		_lowercase      :List[Any]  ,		_lowercase      :List[str]=14  ,		_lowercase      :Optional[Any]=7  ,		_lowercase      :Union[str, Any]=True  ,		_lowercase      :List[Any]=True  ,		_lowercase      :List[Any]=False  ,		_lowercase      :List[Any]=True  ,		_lowercase      :Union[str, Any]=99  ,		_lowercase      :Dict=32  ,		_lowercase      :int=5  ,		_lowercase      :Optional[int]=4  ,		_lowercase      :int=37  ,		_lowercase      :Optional[int]="gelu"  ,		_lowercase      :List[Any]=0.1  ,		_lowercase      :str=0.1  ,		_lowercase      :Optional[int]=512  ,		_lowercase      :List[Any]=0.02  ,		)						->   Any:
												UpperCAmelCase_					=	parent
												UpperCAmelCase_					=	batch_size
												UpperCAmelCase_					=	seq_length
												UpperCAmelCase_					=	is_training
												UpperCAmelCase_					=	use_input_mask
												UpperCAmelCase_					=	use_token_type_ids
												UpperCAmelCase_					=	use_labels
												UpperCAmelCase_					=	vocab_size
												UpperCAmelCase_					=	hidden_size
												UpperCAmelCase_					=	num_hidden_layers
												UpperCAmelCase_					=	num_attention_heads
												UpperCAmelCase_					=	intermediate_size
												UpperCAmelCase_					=	hidden_act
												UpperCAmelCase_					=	hidden_dropout_prob
												UpperCAmelCase_					=	attention_probs_dropout_prob
												UpperCAmelCase_					=	max_position_embeddings
												UpperCAmelCase_					=	initializer_range
												UpperCAmelCase_					=	None
												UpperCAmelCase_					=	vocab_size - 1
												UpperCAmelCase_					=	vocab_size - 1
												UpperCAmelCase_					=	vocab_size - 1

						def       __a			(       self      :List[Any])						->   List[Any]:
												UpperCAmelCase_					=	ids_tensor([self.batch_size, self.seq_length]  ,		self.vocab_size)

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

												UpperCAmelCase_					=	GPTaConfig(
												    vocab_size=self.vocab_size  ,		n_embd=self.hidden_size  ,		n_layer=self.num_hidden_layers  ,		n_head=self.num_attention_heads  ,		n_positions=self.max_position_embeddings  ,		use_cache=_lowercase  ,		bos_token_id=self.bos_token_id  ,		eos_token_id=self.eos_token_id  ,		pad_token_id=self.pad_token_id  ,		)

												return (config, input_ids, input_mask)

						def       __a			(       self      :List[Any])						->   Tuple:
												UpperCAmelCase_					=	self.prepare_config_and_inputs()
												UpperCAmelCase_				, UpperCAmelCase_				, UpperCAmelCase_					=	config_and_inputs
												UpperCAmelCase_					=	{'''input_ids''': input_ids, '''attention_mask''': attention_mask}
												return config, inputs_dict

						def       __a			(       self      :List[str])						->   Tuple:
												UpperCAmelCase_				, UpperCAmelCase_				, UpperCAmelCase_					=	self.prepare_config_and_inputs()

												UpperCAmelCase_					=	floats_tensor([self.batch_size, self.seq_length, self.hidden_size])
												UpperCAmelCase_					=	ids_tensor([self.batch_size, self.seq_length]  ,		vocab_size=2)

												return (
												    config,
												    input_ids,
												    attention_mask,
												    encoder_hidden_states,
												    encoder_attention_mask,
												)

						def       __a			(       self      :Any  ,		_lowercase      :str  ,		_lowercase      :int  ,		_lowercase      :List[Any]  ,		_lowercase      :str)						->   int:
												UpperCAmelCase_					=	20
												UpperCAmelCase_					=	model_class_name(_lowercase)

												UpperCAmelCase_					=	model.init_cache(input_ids.shape[0]  ,		_lowercase)
												UpperCAmelCase_					=	jnp.ones((input_ids.shape[0], max_decoder_length)  ,		dtype='''i4''')

												UpperCAmelCase_					=	jnp.broadcast_to(
												    jnp.arange(input_ids.shape[-1] - 1)[None, :]  ,		(input_ids.shape[0], input_ids.shape[-1] - 1))
												UpperCAmelCase_					=	model(
												    input_ids[:, :-1]  ,		attention_mask=_lowercase  ,		past_key_values=_lowercase  ,		position_ids=_lowercase  ,		)

												UpperCAmelCase_					=	jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]  ,		dtype='''i4''')
												UpperCAmelCase_					=	model(
												    input_ids[:, -1:]  ,		attention_mask=_lowercase  ,		past_key_values=outputs_cache.past_key_values  ,		position_ids=_lowercase  ,		)

												UpperCAmelCase_					=	model(_lowercase)

												UpperCAmelCase_					=	np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])))
												self.parent.assertTrue(diff < 1E-3  ,		msg=f"Max diff is {diff}")




						def       __a			(       self      :Union[str, Any]  ,		_lowercase      :Optional[Any]  ,		_lowercase      :int  ,		_lowercase      :str  ,		_lowercase      :Dict)						->   Dict:
												UpperCAmelCase_					=	20
												UpperCAmelCase_					=	model_class_name(_lowercase)

												UpperCAmelCase_					=	jnp.concatenate(
												    [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1]))]  ,		axis=-1  ,		)

												UpperCAmelCase_					=	model.init_cache(input_ids.shape[0]  ,		_lowercase)
												UpperCAmelCase_					=	jnp.broadcast_to(
												    jnp.arange(input_ids.shape[-1] - 1)[None, :]  ,		(input_ids.shape[0], input_ids.shape[-1] - 1))

												UpperCAmelCase_					=	model(
												    input_ids[:, :-1]  ,		attention_mask=_lowercase  ,		past_key_values=_lowercase  ,		position_ids=_lowercase  ,		)
												UpperCAmelCase_					=	jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]  ,		dtype='''i4''')
												UpperCAmelCase_					=	model(
												    input_ids[:, -1:]  ,		past_key_values=outputs_cache.past_key_values  ,		attention_mask=_lowercase  ,		position_ids=_lowercase  ,		)

												UpperCAmelCase_					=	model(_lowercase  ,		attention_mask=_lowercase)

												UpperCAmelCase_					=	np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])))
												self.parent.assertTrue(diff < 1E-3  ,		msg=f"Max diff is {diff}")







@require_flax
class 				a_    (						_snake_case   ,					_snake_case   ,					unittest.TestCase							):
						UpperCamelCase__ :		Optional[int]										=(FlaxGPTaModel, FlaxGPTaLMHeadModel) if is_flax_available() else ()
						UpperCamelCase__ :		Optional[Any]										=(FlaxGPTaLMHeadModel,) if is_flax_available() else ()

						def       __a			(       self      :Optional[Any])						->   Optional[int]:
												UpperCAmelCase_					=	FlaxGPTaModelTester(self)

						def       __a			(       self      :str)						->   Any:
												for model_class_name in self.all_model_classes:
																		UpperCAmelCase_				, UpperCAmelCase_				, UpperCAmelCase_					=	self.model_tester.prepare_config_and_inputs()
																		self.model_tester.check_use_cache_forward(_lowercase  ,		_lowercase  ,		_lowercase  ,		_lowercase)

						def       __a			(       self      :Tuple)						->   int:
												for model_class_name in self.all_model_classes:
																		UpperCAmelCase_				, UpperCAmelCase_				, UpperCAmelCase_					=	self.model_tester.prepare_config_and_inputs()
																		self.model_tester.check_use_cache_forward_with_attn_mask(
																		    _lowercase  ,		_lowercase  ,		_lowercase  ,		_lowercase)

						@slow
						def       __a			(       self      :Union[str, Any])						->   Optional[Any]:
												UpperCAmelCase_					=	GPTaTokenizer.from_pretrained('''gpt2'''  ,		pad_token='''</s>'''  ,		padding_side='''left''')
												UpperCAmelCase_					=	tokenizer(['''Hello this is a long string''', '''Hey''']  ,		return_tensors='''np'''  ,		padding=_lowercase  ,		truncation=_lowercase)

												UpperCAmelCase_					=	FlaxGPTaLMHeadModel.from_pretrained('''gpt2''')
												UpperCAmelCase_					=	False
												UpperCAmelCase_					=	model.config.eos_token_id

												UpperCAmelCase_					=	jax.jit(model.generate)

												UpperCAmelCase_					=	jit_generate(inputs['''input_ids''']  ,		attention_mask=inputs['''attention_mask''']).sequences

												UpperCAmelCase_					=	tokenizer.batch_decode(_lowercase  ,		skip_special_tokens=_lowercase)

												UpperCAmelCase_					=	[
												    '''Hello this is a long string of words. I\'m going to start with the first one.\n''',
												    '''Hey, I\'m not sure if I\'m going to be able to do''',
												]

												self.assertListEqual(_lowercase  ,		_lowercase)

						@is_pt_flax_cross_test
						def       __a			(       self      :List[str])						->   List[Any]:
												UpperCAmelCase_				, UpperCAmelCase_					=	self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		with self.subTest(model_class.__name__):
																								# prepare inputs
																								UpperCAmelCase_					=	self._prepare_for_class(_lowercase  ,		_lowercase)
																								UpperCAmelCase_					=	{k: torch.tensor(v.tolist()) for k, v in prepared_inputs_dict.items()}

																								# load corresponding PyTorch class
																								UpperCAmelCase_					=	model_class.__name__[4:]  # Skip the "Flax" at the beginning
																								UpperCAmelCase_					=	getattr(_lowercase  ,		_lowercase)

																								UpperCAmelCase_				, UpperCAmelCase_					=	pt_inputs['''input_ids'''].shape
																								UpperCAmelCase_					=	np.random.randint(0  ,		seq_length - 1  ,		size=(batch_size,))
																								for batch_idx, start_index in enumerate(_lowercase):
																														UpperCAmelCase_					=	0
																														UpperCAmelCase_					=	1
																														UpperCAmelCase_					=	0
																														UpperCAmelCase_					=	1
																								UpperCAmelCase_					=	pt_model_class(_lowercase).eval()
																								UpperCAmelCase_					=	model_class(_lowercase  ,		dtype=jnp.floataa)

																								UpperCAmelCase_					=	convert_pytorch_state_dict_to_flax(pt_model.state_dict()  ,		_lowercase)
																								UpperCAmelCase_					=	fx_state

																								with torch.no_grad():
																														UpperCAmelCase_					=	pt_model(**_lowercase).to_tuple()

																								UpperCAmelCase_					=	fx_model(**_lowercase).to_tuple()
																								self.assertEqual(len(_lowercase)  ,		len(_lowercase)  ,		'''Output lengths differ between Flax and PyTorch''')
																								for fx_output, pt_output in zip(_lowercase  ,		_lowercase):
																														self.assert_almost_equals(fx_output[:, -1]  ,		pt_output[:, -1].numpy()  ,		4E-2)

																								with tempfile.TemporaryDirectory() as tmpdirname:
																														pt_model.save_pretrained(_lowercase)
																														UpperCAmelCase_					=	model_class.from_pretrained(_lowercase  ,		from_pt=_lowercase)

																								UpperCAmelCase_					=	fx_model_loaded(**_lowercase).to_tuple()
																								self.assertEqual(
																								    len(_lowercase)  ,		len(_lowercase)  ,		'''Output lengths differ between Flax and PyTorch''')
																								for fx_output_loaded, pt_output in zip(_lowercase  ,		_lowercase):
																														self.assert_almost_equals(fx_output_loaded[:, -1]  ,		pt_output[:, -1].numpy()  ,		4E-2)

						@is_pt_flax_cross_test
						def       __a			(       self      :Dict)						->   str:
												UpperCAmelCase_				, UpperCAmelCase_					=	self.model_tester.prepare_config_and_inputs_for_common()
												for model_class in self.all_model_classes:
																		with self.subTest(model_class.__name__):
																								# prepare inputs
																								UpperCAmelCase_					=	self._prepare_for_class(_lowercase  ,		_lowercase)
																								UpperCAmelCase_					=	{k: torch.tensor(v.tolist()) for k, v in prepared_inputs_dict.items()}

																								# load corresponding PyTorch class
																								UpperCAmelCase_					=	model_class.__name__[4:]  # Skip the "Flax" at the beginning
																								UpperCAmelCase_					=	getattr(_lowercase  ,		_lowercase)

																								UpperCAmelCase_					=	pt_model_class(_lowercase).eval()
																								UpperCAmelCase_					=	model_class(_lowercase  ,		dtype=jnp.floataa)

																								UpperCAmelCase_					=	load_flax_weights_in_pytorch_model(_lowercase  ,		fx_model.params)
																								UpperCAmelCase_				, UpperCAmelCase_					=	pt_inputs['''input_ids'''].shape
																								UpperCAmelCase_					=	np.random.randint(0  ,		seq_length - 1  ,		size=(batch_size,))
																								for batch_idx, start_index in enumerate(_lowercase):
																														UpperCAmelCase_					=	0
																														UpperCAmelCase_					=	1
																														UpperCAmelCase_					=	0
																														UpperCAmelCase_					=	1

																								# make sure weights are tied in PyTorch
																								pt_model.tie_weights()

																								with torch.no_grad():
																														UpperCAmelCase_					=	pt_model(**_lowercase).to_tuple()

																								UpperCAmelCase_					=	fx_model(**_lowercase).to_tuple()
																								self.assertEqual(len(_lowercase)  ,		len(_lowercase)  ,		'''Output lengths differ between Flax and PyTorch''')
																								for fx_output, pt_output in zip(_lowercase  ,		_lowercase):
																														self.assert_almost_equals(fx_output[:, -1]  ,		pt_output[:, -1].numpy()  ,		4E-2)

																								with tempfile.TemporaryDirectory() as tmpdirname:
																														fx_model.save_pretrained(_lowercase)
																														UpperCAmelCase_					=	pt_model_class.from_pretrained(_lowercase  ,		from_flax=_lowercase)

																								with torch.no_grad():
																														UpperCAmelCase_					=	pt_model_loaded(**_lowercase).to_tuple()

																								self.assertEqual(
																								    len(_lowercase)  ,		len(_lowercase)  ,		'''Output lengths differ between Flax and PyTorch''')
																								for fx_output, pt_output in zip(_lowercase  ,		_lowercase):
																														self.assert_almost_equals(fx_output[:, -1]  ,		pt_output[:, -1].numpy()  ,		4E-2)




						@slow
						def       __a			(       self      :Optional[Any])						->   Dict:
												for model_class_name in self.all_model_classes:
																		UpperCAmelCase_					=	model_class_name.from_pretrained('''gpt2'''  ,		from_pt=_lowercase)
																		UpperCAmelCase_					=	model(np.ones((1, 1)))
																		self.assertIsNotNone(_lowercase)










def 							A     (						__UpperCAmelCase				,   __UpperCAmelCase      )			->			int:



						'''simple docstring'''






						print('''\nVertex Distance'''      )
						for i in range(__UpperCAmelCase      ):
												if dist[i] != float('''inf'''      ):
																		print(__UpperCAmelCase				,   '''\t'''				,   int(dist[i]      )				,   end='''\t'''      )
												else:
																		print(__UpperCAmelCase				,   '''\t'''				,   '''INF'''				,   end='''\t'''      )
												print()







def 							A     (						__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase      )			->			str:



						'''simple docstring'''






						UpperCAmelCase_					=	float('''inf'''      )
						UpperCAmelCase_					=	-1
						for i in range(__UpperCAmelCase      ):
												if (not vset[i]) and mdist[i] < min_val:
																		UpperCAmelCase_					=	i
																		UpperCAmelCase_					=	mdist[i]
						return min_ind







def 							A     (						__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase      )			->			Optional[Any]:



						'''simple docstring'''






						UpperCAmelCase_					=	[float('''inf'''      ) for _ in range(__UpperCAmelCase      )]
						UpperCAmelCase_					=	[False for _ in range(__UpperCAmelCase      )]
						UpperCAmelCase_					=	0.0

						for _ in range(v - 1      ):
												UpperCAmelCase_					=	min_dist(__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase      )
												UpperCAmelCase_					=	True

												for i in range(__UpperCAmelCase      ):
																		if (
																		    (not vset[i])
																		    and graph[u][i] != float('''inf'''      )
																		    and mdist[u] + graph[u][i] < mdist[i]
																		):
																								UpperCAmelCase_					=	mdist[u] + graph[u][i]

						print_dist(__UpperCAmelCase				,   __UpperCAmelCase      )


if __name__ == "__main__":
							UpperCamelCase_      			=  int(input("Enter number of vertices: ").strip())
							UpperCamelCase_      			=  int(input("Enter number of edges: ").strip())

							UpperCamelCase_      			=  [[float("inf") for i in range(V)] for j in range(V)]

							for i in range(V):
														UpperCamelCase_      			=  0.0

							for i in range(E):
														print("\nEdge ", i + 1)
														UpperCamelCase_      			=  int(input("Enter source:").strip())
														UpperCamelCase_      			=  int(input("Enter destination:").strip())
														UpperCamelCase_      			=  float(input("Enter weight:").strip())
														UpperCamelCase_      			=  weight

							UpperCamelCase_      			=  int(input("\nEnter shortest path source:").strip())
							dijkstra(graph, V, gsrc)





