



class    __UpperCamelCase			:

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Dict:
  a__												= None
  a__												= None
  a__												= graph

  self._normalize_graph(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )
  a__												= len(SCREAMING_SNAKE_CASE      )
  a__												= None

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Any:
  if sources is int:
   a__												= [sources]
  if sinks is int:
   a__												= [sinks]

  if len(SCREAMING_SNAKE_CASE      ) == 0 or len(SCREAMING_SNAKE_CASE      ) == 0:
   return

  a__												= sources[0]
  a__												= sinks[0]

  # make fake vertex if there are more
  # than one source or sink
  if len(SCREAMING_SNAKE_CASE      ) > 1 or len(SCREAMING_SNAKE_CASE      ) > 1:
   a__												= 0
   for i in sources:
    max_input_flow += sum(self.graph[i]      )

   a__												= len(self.graph      ) + 1
   for room in self.graph:
    room.insert(0		,				0      )
   self.graph.insert(0		,				[0] * size      )
   for i in sources:
    a__												= max_input_flow
   a__												= 0

   a__												= len(self.graph      ) + 1
   for room in self.graph:
    room.append(0      )
   self.graph.append([0] * size      )
   for i in sinks:
    a__												= max_input_flow
   a__												= size - 1

 def 						_UpperCAmelCase       (	self      ) ->			Dict:
  if self.maximum_flow_algorithm is None:
   raise Exception('''You need to set maximum flow algorithm before.'''      )
  if self.source_index is None or self.sink_index is None:
   return 0

  self.maximum_flow_algorithm.execute()
  return self.maximum_flow_algorithm.getMaximumFlow()



 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE      ) ->			List[Any]:
  a__												= algorithm(self      )





class    __UpperCamelCase			:

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE      ) ->			Any:
  a__												= flow_network
  a__												= flow_network.verticesCount
  a__												= flow_network.sourceIndex
  a__												= flow_network.sinkIndex
  # it's just a reference, so you shouldn't change
  # it in your algorithms, use deep copy before doing that
  a__												= flow_network.graph
  a__												= False

 def 						_UpperCAmelCase       (	self      ) ->			int:
  if not self.executed:
   self._algorithm()
   a__												= True



 def 						_UpperCAmelCase       (	self      ) ->			Tuple:
  pass





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE      ) ->			Dict:
  super().__init__(SCREAMING_SNAKE_CASE      )
  # use this to save your result
  a__												= -1



 def 						_UpperCAmelCase       (	self      ) ->			Union[str, Any]:
  if not self.executed:
   raise Exception('''You should execute algorithm before using its result!'''      )

  return self.maximum_flow





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE      ) ->			Tuple:
  super().__init__(SCREAMING_SNAKE_CASE      )

  a__												= [[0] * self.verticies_count for i in range(self.verticies_count      )]

  a__												= [0] * self.verticies_count
  a__												= [0] * self.verticies_count

 def 						_UpperCAmelCase       (	self      ) ->			Optional[int]:
  a__												= self.verticies_count

  # push some substance to graph
  for nextvertex_index, bandwidth in enumerate(self.graph[self.source_index]      ):
   self.preflow[self.source_index][nextvertex_index] += bandwidth
   self.preflow[nextvertex_index][self.source_index] -= bandwidth
   self.excesses[nextvertex_index] += bandwidth

  # Relabel-to-front selection rule
  a__												= [
      i
      for i in range(self.verticies_count      )
      if i != self.source_index and i != self.sink_index
  ]

  # move through list
  a__												= 0
  while i < len(SCREAMING_SNAKE_CASE      ):
   a__												= vertices_list[i]
   a__												= self.heights[vertex_index]
   self.process_vertex(SCREAMING_SNAKE_CASE      )
   if self.heights[vertex_index] > previous_height:
    # if it was relabeled, swap elements
    # and start from 0 index
    vertices_list.insert(0		,				vertices_list.pop(SCREAMING_SNAKE_CASE      )      )
    a__												= 0
   else:
    i += 1

  a__												= sum(self.preflow[self.source_index]      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE      ) ->			List[str]:
  while self.excesses[vertex_index] > 0:
   for neighbour_index in range(self.verticies_count      ):
    # if it's neighbour and current vertex is higher
    if (
        self.graph[vertex_index][neighbour_index]
        - self.preflow[vertex_index][neighbour_index]
        > 0
        and self.heights[vertex_index] > self.heights[neighbour_index]
    ):
     self.push(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )

   self.relabel(SCREAMING_SNAKE_CASE      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Dict:
  a__												= min(
      self.excesses[from_index]		,				self.graph[from_index][to_index] - self.preflow[from_index][to_index]		,				)
  self.preflow[from_index][to_index] += preflow_delta
  self.preflow[to_index][from_index] -= preflow_delta
  self.excesses[from_index] -= preflow_delta
  self.excesses[to_index] += preflow_delta



 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE      ) ->			Any:
  a__												= None
  for to_index in range(self.verticies_count      ):
   if (
       self.graph[vertex_index][to_index]
       - self.preflow[vertex_index][to_index]
       > 0
   ) and (min_height is None or self.heights[to_index] < min_height):
    a__												= self.heights[to_index]

  if min_height is not None:
   a__												= min_height + 1


if __name__ == "__main__":
     a_      :      Optional[int]    =     [0]
     a_      :      str    =     [3]
     # graph = [
     #     [0, 0, 4, 6, 0, 0],
     #     [0, 0, 5, 2, 0, 0],
     #     [0, 0, 0, 0, 4, 4],
     #     [0, 0, 0, 0, 6, 6],
     #     [0, 0, 0, 0, 0, 0],
     #     [0, 0, 0, 0, 0, 0],
     # ]
     a_      :      Union[str, Any]    =     [[0, 7, 0, 0], [0, 0, 6, 0], [0, 0, 0, 8], [9, 0, 0, 0]]

     # prepare our network
     a_      :      List[Any]    =     FlowNetwork(graph, entrances, exits)
     # set algorithm
     flow_network.set_maximum_flow_algorithm(PushRelabelExecutor)
     # and calculate
     a_      :      int    =     flow_network.find_maximum_flow()

     print(f'maximum flow is {maximum_flow}')










import unittest

from transformers import AlbertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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 (
         MODEL_FOR_PRETRAINING_MAPPING,
         AlbertForMaskedLM,
         AlbertForMultipleChoice,
         AlbertForPreTraining,
         AlbertForQuestionAnswering,
         AlbertForSequenceClassification,
         AlbertForTokenClassification,
         AlbertModel,
     )
     from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST
class    __UpperCamelCase			:

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE=1_3		,				SCREAMING_SNAKE_CASE=7		,				SCREAMING_SNAKE_CASE=True		,				SCREAMING_SNAKE_CASE=True		,				SCREAMING_SNAKE_CASE=True		,				SCREAMING_SNAKE_CASE=True		,				SCREAMING_SNAKE_CASE=9_9		,				SCREAMING_SNAKE_CASE=1_6		,				SCREAMING_SNAKE_CASE=3_6		,				SCREAMING_SNAKE_CASE=6		,				SCREAMING_SNAKE_CASE=6		,				SCREAMING_SNAKE_CASE=6		,				SCREAMING_SNAKE_CASE=3_7		,				SCREAMING_SNAKE_CASE="gelu"		,				SCREAMING_SNAKE_CASE=0.1		,				SCREAMING_SNAKE_CASE=0.1		,				SCREAMING_SNAKE_CASE=5_1_2		,				SCREAMING_SNAKE_CASE=1_6		,				SCREAMING_SNAKE_CASE=2		,				SCREAMING_SNAKE_CASE=0.02		,				SCREAMING_SNAKE_CASE=3		,				SCREAMING_SNAKE_CASE=4		,				SCREAMING_SNAKE_CASE=None		,				) ->			Union[str, Any]:
  a__												= parent
  a__												= batch_size
  a__												= seq_length
  a__												= is_training
  a__												= use_input_mask
  a__												= use_token_type_ids
  a__												= use_labels
  a__												= vocab_size
  a__												= embedding_size
  a__												= hidden_size
  a__												= num_hidden_layers
  a__												= num_hidden_groups
  a__												= num_attention_heads
  a__												= intermediate_size
  a__												= hidden_act
  a__												= hidden_dropout_prob
  a__												= attention_probs_dropout_prob
  a__												= max_position_embeddings
  a__												= type_vocab_size
  a__												= type_sequence_label_size
  a__												= initializer_range
  a__												= num_labels
  a__												= num_choices
  a__												= scope

 def 						_UpperCAmelCase       (	self      ) ->			List[str]:
  a__												= ids_tensor([self.batch_size, self.seq_length]		,				self.vocab_size      )

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

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

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

  a__												= self.get_config()

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

 def 						_UpperCAmelCase       (	self      ) ->			Any:
  return AlbertConfig(
      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		,				initializer_range=self.initializer_range		,				num_hidden_groups=self.num_hidden_groups		,				)

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Optional[int]:
  a__												= AlbertModel(config=SCREAMING_SNAKE_CASE      )
  model.to(SCREAMING_SNAKE_CASE      )
  model.eval()
  a__												= model(SCREAMING_SNAKE_CASE		,				attention_mask=SCREAMING_SNAKE_CASE		,				token_type_ids=SCREAMING_SNAKE_CASE      )
  a__												= model(SCREAMING_SNAKE_CASE		,				token_type_ids=SCREAMING_SNAKE_CASE      )
  a__												= model(SCREAMING_SNAKE_CASE      )
  self.parent.assertEqual(result.last_hidden_state.shape		,				(self.batch_size, self.seq_length, self.hidden_size)      )
  self.parent.assertEqual(result.pooler_output.shape		,				(self.batch_size, self.hidden_size)      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			List[Any]:
  a__												= AlbertForPreTraining(config=SCREAMING_SNAKE_CASE      )
  model.to(SCREAMING_SNAKE_CASE      )
  model.eval()
  a__												= model(
      SCREAMING_SNAKE_CASE		,				attention_mask=SCREAMING_SNAKE_CASE		,				token_type_ids=SCREAMING_SNAKE_CASE		,				labels=SCREAMING_SNAKE_CASE		,				sentence_order_label=SCREAMING_SNAKE_CASE		,				)
  self.parent.assertEqual(result.prediction_logits.shape		,				(self.batch_size, self.seq_length, self.vocab_size)      )
  self.parent.assertEqual(result.sop_logits.shape		,				(self.batch_size, config.num_labels)      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Dict:
  a__												= AlbertForMaskedLM(config=SCREAMING_SNAKE_CASE      )
  model.to(SCREAMING_SNAKE_CASE      )
  model.eval()
  a__												= model(SCREAMING_SNAKE_CASE		,				attention_mask=SCREAMING_SNAKE_CASE		,				token_type_ids=SCREAMING_SNAKE_CASE		,				labels=SCREAMING_SNAKE_CASE      )
  self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.seq_length, self.vocab_size)      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Any:
  a__												= AlbertForQuestionAnswering(config=SCREAMING_SNAKE_CASE      )
  model.to(SCREAMING_SNAKE_CASE      )
  model.eval()
  a__												= model(
      SCREAMING_SNAKE_CASE		,				attention_mask=SCREAMING_SNAKE_CASE		,				token_type_ids=SCREAMING_SNAKE_CASE		,				start_positions=SCREAMING_SNAKE_CASE		,				end_positions=SCREAMING_SNAKE_CASE		,				)
  self.parent.assertEqual(result.start_logits.shape		,				(self.batch_size, self.seq_length)      )
  self.parent.assertEqual(result.end_logits.shape		,				(self.batch_size, self.seq_length)      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Union[str, Any]:
  a__												= self.num_labels
  a__												= AlbertForSequenceClassification(SCREAMING_SNAKE_CASE      )
  model.to(SCREAMING_SNAKE_CASE      )
  model.eval()
  a__												= model(SCREAMING_SNAKE_CASE		,				attention_mask=SCREAMING_SNAKE_CASE		,				token_type_ids=SCREAMING_SNAKE_CASE		,				labels=SCREAMING_SNAKE_CASE      )
  self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.num_labels)      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Tuple:
  a__												= self.num_labels
  a__												= AlbertForTokenClassification(config=SCREAMING_SNAKE_CASE      )
  model.to(SCREAMING_SNAKE_CASE      )
  model.eval()
  a__												= model(SCREAMING_SNAKE_CASE		,				attention_mask=SCREAMING_SNAKE_CASE		,				token_type_ids=SCREAMING_SNAKE_CASE		,				labels=SCREAMING_SNAKE_CASE      )
  self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.seq_length, self.num_labels)      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Optional[int]:
  a__												= self.num_choices
  a__												= AlbertForMultipleChoice(config=SCREAMING_SNAKE_CASE      )
  model.to(SCREAMING_SNAKE_CASE      )
  model.eval()
  a__												= input_ids.unsqueeze(1      ).expand(-1		,				self.num_choices		,				-1      ).contiguous()
  a__												= token_type_ids.unsqueeze(1      ).expand(-1		,				self.num_choices		,				-1      ).contiguous()
  a__												= input_mask.unsqueeze(1      ).expand(-1		,				self.num_choices		,				-1      ).contiguous()
  a__												= model(
      SCREAMING_SNAKE_CASE		,				attention_mask=SCREAMING_SNAKE_CASE		,				token_type_ids=SCREAMING_SNAKE_CASE		,				labels=SCREAMING_SNAKE_CASE		,				)
  self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.num_choices)      )



 def 						_UpperCAmelCase       (	self      ) ->			Tuple:
  a__												= self.prepare_config_and_inputs()
  (
      (
      a__
  )							,			(
      a__
  )							,			(
      a__
  )							,			(
      a__
  )							,			(
      a__
  )							,			(
      a__
  )							,			(
      a__
  )							,			
  )												= config_and_inputs
  a__												= {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
  return config, inputs_dict





@require_torch
class    __UpperCamelCase			(       _lowercase	,	_lowercase	,	unittest.TestCase				):

 """simple docstring"""



 _lowercase   :    List[str]      						=					(
     (
         AlbertModel,
         AlbertForPreTraining,
         AlbertForMaskedLM,
         AlbertForMultipleChoice,
         AlbertForSequenceClassification,
         AlbertForTokenClassification,
         AlbertForQuestionAnswering,
     )
     if is_torch_available()
     else ()
 )
 _lowercase   :    List[str]      						=					(
     {
         '''feature-extraction''': AlbertModel,
         '''fill-mask''': AlbertForMaskedLM,
         '''question-answering''': AlbertForQuestionAnswering,
         '''text-classification''': AlbertForSequenceClassification,
         '''token-classification''': AlbertForTokenClassification,
         '''zero-shot''': AlbertForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 _lowercase   :    List[str]      						=					True

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE=False      ) ->			List[str]:
  a__												= super()._prepare_for_class(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				return_labels=SCREAMING_SNAKE_CASE      )

  if return_labels:
   if model_class in get_values(SCREAMING_SNAKE_CASE      ):
    a__												= torch.zeros(
        (self.model_tester.batch_size, self.model_tester.seq_length)		,				dtype=torch.long		,				device=SCREAMING_SNAKE_CASE      )
    a__												= torch.zeros(
        self.model_tester.batch_size		,				dtype=torch.long		,				device=SCREAMING_SNAKE_CASE      )
  return inputs_dict

 def 						_UpperCAmelCase       (	self      ) ->			Dict:
  a__												= AlbertModelTester(self      )
  a__												= ConfigTester(self		,				config_class=SCREAMING_SNAKE_CASE		,				hidden_size=3_7      )

 def 						_UpperCAmelCase       (	self      ) ->			Union[str, Any]:
  self.config_tester.run_common_tests()

 def 						_UpperCAmelCase       (	self      ) ->			Union[str, Any]:
  a__												= self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE      )

 def 						_UpperCAmelCase       (	self      ) ->			Union[str, Any]:
  a__												= self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_pretraining(*SCREAMING_SNAKE_CASE      )

 def 						_UpperCAmelCase       (	self      ) ->			Any:
  a__												= self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE      )

 def 						_UpperCAmelCase       (	self      ) ->			List[Any]:
  a__												= self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_multiple_choice(*SCREAMING_SNAKE_CASE      )

 def 						_UpperCAmelCase       (	self      ) ->			Union[str, Any]:
  a__												= self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE      )

 def 						_UpperCAmelCase       (	self      ) ->			Optional[Any]:
  a__												= self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE      )

 def 						_UpperCAmelCase       (	self      ) ->			List[Any]:
  a__												= self.model_tester.prepare_config_and_inputs()
  for type in ["absolute", "relative_key", "relative_key_query"]:
   a__												= type
   self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE      )



 @slow
 def 						_UpperCAmelCase       (	self      ) ->			List[str]:
  for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
   a__												= AlbertModel.from_pretrained(SCREAMING_SNAKE_CASE      )
   self.assertIsNotNone(SCREAMING_SNAKE_CASE      )





@require_torch
class    __UpperCamelCase			(       unittest.TestCase				):

 """simple docstring"""



 @slow
 def 						_UpperCAmelCase       (	self      ) ->			Optional[Any]:
  a__												= AlbertModel.from_pretrained('''albert-base-v2'''      )
  a__												= torch.tensor([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]]      )
  a__												= torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]      )
  with torch.no_grad():
   a__												= model(SCREAMING_SNAKE_CASE		,				attention_mask=SCREAMING_SNAKE_CASE      )[0]
  a__												= torch.Size((1, 1_1, 7_6_8)      )
  self.assertEqual(output.shape		,				SCREAMING_SNAKE_CASE      )
  a__												= torch.tensor(
      [[[-0.65_13, 1.50_35, -0.27_66], [-0.65_15, 1.50_46, -0.27_80], [-0.65_12, 1.50_49, -0.27_84]]]      )

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





