def        UpperCamelCase_							(			lowerCAmelCase__						,	lowerCAmelCase__  ):



					"""simple docstring"""

					print("\nThe shortest path matrix using Floyd Warshall algorithm\n"  )
					for i in range(__a  ):
										for j in range(__a  ):
															if dist[i][j] != float("inf"  ):
																				print(int(dist[i][j]  )						,	end="\t"  )
															else:
																				print("INF"						,	end="\t"  )
										print()






def        UpperCamelCase_							(			lowerCAmelCase__						,	lowerCAmelCase__  ):



					"""simple docstring"""

					_lowerCAmelCase			:		str          = [[float("inf"  ) for _ in range(__a  )] for _ in range(__a  )]

					for i in range(__a  ):
										for j in range(__a  ):
															_lowerCAmelCase			:		List[str]          = graph[i][j]

															# check vertex k against all other vertices (i, j)
					for k in range(__a  ):
										# looping through rows of graph array
										for i in range(__a  ):
															# looping through columns of graph array
															for j in range(__a  ):
																				if (
																				    dist[i][k] != float("inf"  )
																				    and dist[k][j] != float("inf"  )
																				    and dist[i][k] + dist[k][j] < dist[i][j]
																				):
																									_lowerCAmelCase			:		Dict          = dist[i][k] + dist[k][j]

					_print_dist(__a						,	__a  )
					return dist, v


if __name__ == "__main__":
						snake_case      =    int(input("Enter number of vertices: "))
						snake_case      =    int(input("Enter number of edges: "))

						snake_case      =    [[float("inf") for i in range(v)] for j in range(v)]

						for i in range(v):
												snake_case      =    0.0

												# src and dst are indices that must be within the array size graph[e][v]
												# failure to follow this will result in an error
						for i in range(e):
												print("\nEdge ", i + 1)
												snake_case      =    int(input("Enter source:"))
												snake_case      =    int(input("Enter destination:"))
												snake_case      =    float(input("Enter weight:"))
												snake_case      =    weight

						floyd_warshall(graph, v)

						# Example Input
						# Enter number of vertices: 3
						# Enter number of edges: 2

						# # generated graph from vertex and edge inputs
						# [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
						# [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

						# specify source, destination and weight for edge #1
						# Edge  1
						# Enter source:1
						# Enter destination:2
						# Enter weight:2

						# specify source, destination and weight for edge #2
						# Edge  2
						# Enter source:2
						# Enter destination:1
						# Enter weight:1

						# # Expected Output from the vertice, edge and src, dst, weight inputs!!
						# 0		INF	INF
						# INF	0	2
						# INF	1	0










'''simple docstring'''
import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow


if is_torch_available():
		import torch

		from transformers import XLMRobertaModel
@require_sentencepiece
@require_tokenizers
@require_torch
class   lowercase      (				unittest.TestCase   ):

		"""simple docstring"""

		@slow
		def        lowerCAmelCase__							(						self				):

							'''simple docstring'''


							UpperCamelCase__  :Optional[Any]				   =					XLMRobertaModel.from_pretrained('''xlm-roberta-base'''				)
							UpperCamelCase__  :List[str]				   =					torch.tensor([[0, 581, 10269, 83, 99942, 136, 60742, 23, 70, 80583, 18276, 2]]				)
							# The dog is cute and lives in the garden house

							UpperCamelCase__  :Union[str, Any]				   =					torch.Size((1, 12, 768)				)  # batch_size, sequence_length, embedding_vector_dim
							UpperCamelCase__  :Union[str, Any]				   =					torch.tensor(
							    [[-0.0101, 0.1218, -0.0803, 0.0801, 0.1327, 0.0776, -0.1215, 0.2383, 0.3338, 0.3106, 0.0300, 0.0252]]				)
							#  xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base')
							#  xlmr.eval()
							#  expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1]
							with torch.no_grad():
												UpperCamelCase__  :Any				   =					model(UpperCamelCase_				)['''last_hidden_state'''].detach()
							self.assertEqual(output.shape       ,  UpperCamelCase_				)
							# compare the actual values for a slice of last dim
							self.assertTrue(torch.allclose(output[:, :, -1]       ,  UpperCamelCase_       ,  atol=1e-3				)				)




		@slow
		def        lowerCAmelCase__							(						self				):

							'''simple docstring'''


							UpperCamelCase__  :int				   =					XLMRobertaModel.from_pretrained('''xlm-roberta-large'''				)
							UpperCamelCase__  :List[str]				   =					torch.tensor([[0, 581, 10269, 83, 99942, 136, 60742, 23, 70, 80583, 18276, 2]]				)
							# The dog is cute and lives in the garden house

							UpperCamelCase__  :Any				   =					torch.Size((1, 12, 1024)				)  # batch_size, sequence_length, embedding_vector_dim
							UpperCamelCase__  :List[Any]				   =					torch.tensor(
							    [[-0.0699, -0.0318, 0.0705, -0.1241, 0.0999, -0.0520, 0.1004, -0.1838, -0.4704, 0.1437, 0.0821, 0.0126]]				)
							#  xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.large')
							#  xlmr.eval()
							#  expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1]
							with torch.no_grad():
												UpperCamelCase__  :Optional[int]				   =					model(UpperCamelCase_				)['''last_hidden_state'''].detach()
							self.assertEqual(output.shape       ,  UpperCamelCase_				)
							# compare the actual values for a slice of last dim
							self.assertTrue(torch.allclose(output[:, :, -1]       ,  UpperCamelCase_       ,  atol=1e-3				)				)