

import unittest

import numpy as np
import torch

from diffusers import KarrasVePipeline, KarrasVeScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()






class  UpperCAmelCase__	( unittest.TestCase ):






  """simple docstring"""


  @property
  def    lowercase_	(							self		:	str      )	->							int:
       torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					UNetaDModel(
           block_out_channels=(32, 64)			,     layers_per_block=2			,     sample_size=32			,     in_channels=3			,     out_channels=3			,     down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''')			,     up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''')			,     )
       return model







  def    lowercase_	(							self		:	int      )	->							str:
       SCREAMING_SNAKE_CASE__					=					self.dummy_uncond_unet
       SCREAMING_SNAKE_CASE__					=					KarrasVeScheduler()

       SCREAMING_SNAKE_CASE__					=					KarrasVePipeline(unet=__lowerCamelCase			,     scheduler=__lowerCamelCase      )
       pipe.to(__lowerCamelCase      )
       pipe.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					pipe(num_inference_steps=2			,     generator=__lowerCamelCase			,     output_type='''numpy'''      ).images

       SCREAMING_SNAKE_CASE__					=					torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					pipe(num_inference_steps=2			,     generator=__lowerCamelCase			,     output_type='''numpy'''			,     return_dict=__lowerCamelCase      )[0]

       SCREAMING_SNAKE_CASE__					=					image[0, -3:, -3:, -1]
       SCREAMING_SNAKE_CASE__					=					image_from_tuple[0, -3:, -3:, -1]

       assert image.shape == (1, 32, 32, 3)
       SCREAMING_SNAKE_CASE__					=					np.array([0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]      )

       assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2
       assert np.abs(image_from_tuple_slice.flatten() - expected_slice      ).max() < 1e-2






@slow
@require_torch
class  UpperCAmelCase__	( unittest.TestCase ):






  """simple docstring"""


  def    lowercase_	(							self		:	int      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					'''google/ncsnpp-celebahq-256'''
       SCREAMING_SNAKE_CASE__					=					UNetaDModel.from_pretrained(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					KarrasVeScheduler()

       SCREAMING_SNAKE_CASE__					=					KarrasVePipeline(unet=__lowerCamelCase			,     scheduler=__lowerCamelCase      )
       pipe.to(__lowerCamelCase      )
       pipe.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					pipe(num_inference_steps=20			,     generator=__lowerCamelCase			,     output_type='''numpy'''      ).images

       SCREAMING_SNAKE_CASE__					=					image[0, -3:, -3:, -1]
       assert image.shape == (1, 256, 256, 3)
       SCREAMING_SNAKE_CASE__					=					np.array([0.578, 0.5811, 0.5924, 0.5809, 0.587, 0.5886, 0.5861, 0.5802, 0.586]      )

       assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2





import unittest

from transformers import MobileBertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, 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,
           MobileBertForMaskedLM,
           MobileBertForMultipleChoice,
           MobileBertForNextSentencePrediction,
           MobileBertForPreTraining,
           MobileBertForQuestionAnswering,
           MobileBertForSequenceClassification,
           MobileBertForTokenClassification,
           MobileBertModel,
       )






class  UpperCAmelCase__	:






  """simple docstring"""


  def __init__(							self		:	Optional[int]			,     __lowerCamelCase		:	Tuple			,     __lowerCamelCase		:	List[str]=13			,     __lowerCamelCase		:	Any=7			,     __lowerCamelCase		:	str=True			,     __lowerCamelCase		:	Tuple=True			,     __lowerCamelCase		:	Tuple=True			,     __lowerCamelCase		:	str=True			,     __lowerCamelCase		:	int=99			,     __lowerCamelCase		:	Optional[int]=64			,     __lowerCamelCase		:	Dict=32			,     __lowerCamelCase		:	Dict=5			,     __lowerCamelCase		:	Optional[Any]=4			,     __lowerCamelCase		:	Optional[Any]=37			,     __lowerCamelCase		:	Dict="gelu"			,     __lowerCamelCase		:	Any=0.1			,     __lowerCamelCase		:	str=0.1			,     __lowerCamelCase		:	Optional[Any]=512			,     __lowerCamelCase		:	List[Any]=16			,     __lowerCamelCase		:	Optional[int]=2			,     __lowerCamelCase		:	Union[str, Any]=0.02			,     __lowerCamelCase		:	List[str]=3			,     __lowerCamelCase		:	Any=4			,     __lowerCamelCase		:	Dict=None			,     )	->							int:
       SCREAMING_SNAKE_CASE__					=					parent
       SCREAMING_SNAKE_CASE__					=					batch_size
       SCREAMING_SNAKE_CASE__					=					seq_length
       SCREAMING_SNAKE_CASE__					=					is_training
       SCREAMING_SNAKE_CASE__					=					use_input_mask
       SCREAMING_SNAKE_CASE__					=					use_token_type_ids
       SCREAMING_SNAKE_CASE__					=					use_labels
       SCREAMING_SNAKE_CASE__					=					vocab_size
       SCREAMING_SNAKE_CASE__					=					hidden_size
       SCREAMING_SNAKE_CASE__					=					embedding_size
       SCREAMING_SNAKE_CASE__					=					num_hidden_layers
       SCREAMING_SNAKE_CASE__					=					num_attention_heads
       SCREAMING_SNAKE_CASE__					=					intermediate_size
       SCREAMING_SNAKE_CASE__					=					hidden_act
       SCREAMING_SNAKE_CASE__					=					hidden_dropout_prob
       SCREAMING_SNAKE_CASE__					=					attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE__					=					max_position_embeddings
       SCREAMING_SNAKE_CASE__					=					type_vocab_size
       SCREAMING_SNAKE_CASE__					=					type_sequence_label_size
       SCREAMING_SNAKE_CASE__					=					initializer_range
       SCREAMING_SNAKE_CASE__					=					num_labels
       SCREAMING_SNAKE_CASE__					=					num_choices
       SCREAMING_SNAKE_CASE__					=					scope






  def    lowercase_	(							self		:	List[str]      )	->							Optional[int]:
       SCREAMING_SNAKE_CASE__					=					ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size      )

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

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

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

       SCREAMING_SNAKE_CASE__					=					self.get_config()

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






  def    lowercase_	(							self		:	Dict      )	->							Any:
       return MobileBertConfig(
           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			,     embedding_size=self.embedding_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=__lowerCamelCase			,     initializer_range=self.initializer_range			,     )






  def    lowercase_	(							self		:	List[str]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	Tuple			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Optional[Any]			,     __lowerCamelCase		:	List[Any]      )	->							Any:
       SCREAMING_SNAKE_CASE__					=					MobileBertModel(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase			,     token_type_ids=__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase      )

       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    lowercase_	(							self		:	Dict			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	Any      )	->							Optional[Any]:
       SCREAMING_SNAKE_CASE__					=					MobileBertForMaskedLM(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     labels=__lowerCamelCase      )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)      )






  def    lowercase_	(							self		:	int			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	List[Any]      )	->							int:
       SCREAMING_SNAKE_CASE__					=					MobileBertForNextSentencePrediction(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(
           __lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     labels=__lowerCamelCase			,     )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, 2)      )






  def    lowercase_	(							self		:	str			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Optional[Any]			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	Any      )	->							int:
       SCREAMING_SNAKE_CASE__					=					MobileBertForPreTraining(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(
           __lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     labels=__lowerCamelCase			,     next_sentence_label=__lowerCamelCase			,     )
       self.parent.assertEqual(result.prediction_logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)      )
       self.parent.assertEqual(result.seq_relationship_logits.shape			,     (self.batch_size, 2)      )






  def    lowercase_	(							self		:	List[Any]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Tuple			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Optional[Any]			,     __lowerCamelCase		:	Any      )	->							Dict:
       SCREAMING_SNAKE_CASE__					=					MobileBertForQuestionAnswering(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(
           __lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     start_positions=__lowerCamelCase			,     end_positions=__lowerCamelCase			,     )
       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    lowercase_	(							self		:	Optional[Any]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Optional[Any]			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Union[str, Any]      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					self.num_labels
       SCREAMING_SNAKE_CASE__					=					MobileBertForSequenceClassification(__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     labels=__lowerCamelCase      )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels)      )






  def    lowercase_	(							self		:	int			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	Union[str, Any]      )	->							int:
       SCREAMING_SNAKE_CASE__					=					self.num_labels
       SCREAMING_SNAKE_CASE__					=					MobileBertForTokenClassification(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     labels=__lowerCamelCase      )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.num_labels)      )






  def    lowercase_	(							self		:	Union[str, Any]			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Tuple      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					self.num_choices
       SCREAMING_SNAKE_CASE__					=					MobileBertForMultipleChoice(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					input_ids.unsqueeze(1      ).expand(-1			,     self.num_choices			,     -1      ).contiguous()
       SCREAMING_SNAKE_CASE__					=					token_type_ids.unsqueeze(1      ).expand(-1			,     self.num_choices			,     -1      ).contiguous()
       SCREAMING_SNAKE_CASE__					=					input_mask.unsqueeze(1      ).expand(-1			,     self.num_choices			,     -1      ).contiguous()
       SCREAMING_SNAKE_CASE__					=					model(
           __lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     labels=__lowerCamelCase			,     )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_choices)      )







  def    lowercase_	(							self		:	List[str]      )	->							Tuple:
       SCREAMING_SNAKE_CASE__					=					self.prepare_config_and_inputs()
       (
           (
           SCREAMING_SNAKE_CASE__
       ),(
           SCREAMING_SNAKE_CASE__
       ),(
           SCREAMING_SNAKE_CASE__
       ),(
           SCREAMING_SNAKE_CASE__
       ),(
           SCREAMING_SNAKE_CASE__
       ),(
           SCREAMING_SNAKE_CASE__
       ),(
           SCREAMING_SNAKE_CASE__
       ),
       )					=					config_and_inputs
       SCREAMING_SNAKE_CASE__					=					{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
       return config, inputs_dict






@require_torch
class  UpperCAmelCase__	( A__		,  A__		,  unittest.TestCase ):






  """simple docstring"""


  a     =      (
      (
          MobileBertModel,
          MobileBertForMaskedLM,
          MobileBertForMultipleChoice,
          MobileBertForNextSentencePrediction,
          MobileBertForPreTraining,
          MobileBertForQuestionAnswering,
          MobileBertForSequenceClassification,
          MobileBertForTokenClassification,
      )
      if is_torch_available()
      else ()
  )
  a     =      (
      {
          "feature-extraction": MobileBertModel,
          "fill-mask": MobileBertForMaskedLM,
          "question-answering": MobileBertForQuestionAnswering,
          "text-classification": MobileBertForSequenceClassification,
          "token-classification": MobileBertForTokenClassification,
          "zero-shot": MobileBertForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )
  a     =      True






  def    lowercase_	(							self		:	int			,     __lowerCamelCase		:	Optional[Any]			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	Optional[int]=False      )	->							str:
       SCREAMING_SNAKE_CASE__					=					super()._prepare_for_class(__lowerCamelCase			,     __lowerCamelCase			,     return_labels=__lowerCamelCase      )

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






  def    lowercase_	(							self		:	Optional[Any]      )	->							List[str]:
       SCREAMING_SNAKE_CASE__					=					MobileBertModelTester(self      )
       SCREAMING_SNAKE_CASE__					=					ConfigTester(self			,     config_class=__lowerCamelCase			,     hidden_size=37      )






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






  def    lowercase_	(							self		:	Optional[int]      )	->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_model(*__lowerCamelCase      )






  def    lowercase_	(							self		:	Tuple      )	->							Any:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_masked_lm(*__lowerCamelCase      )






  def    lowercase_	(							self		:	Dict      )	->							Optional[Any]:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_multiple_choice(*__lowerCamelCase      )






  def    lowercase_	(							self		:	Union[str, Any]      )	->							Optional[Any]:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*__lowerCamelCase      )






  def    lowercase_	(							self		:	Any      )	->							str:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_pretraining(*__lowerCamelCase      )






  def    lowercase_	(							self		:	Dict      )	->							str:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_question_answering(*__lowerCamelCase      )






  def    lowercase_	(							self		:	List[str]      )	->							str:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_sequence_classification(*__lowerCamelCase      )







  def    lowercase_	(							self		:	Tuple      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_token_classification(*__lowerCamelCase      )



def        UpperCAmelCase_     (		_A       ):





     '''simple docstring'''




     return torch.tensor(
         _A   ,	dtype=torch.long   ,	device=_A   ,	)


_SCREAMING_SNAKE_CASE  :						Optional[Any]         =    1e-3







@require_torch
@require_sentencepiece
@require_tokenizers
class  UpperCAmelCase__	( unittest.TestCase ):






  """simple docstring"""


  @slow
  def    lowercase_	(							self		:	List[str]      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					MobileBertModel.from_pretrained('''google/mobilebert-uncased'''      ).to(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					_long_tensor([[101, 7110, 1005, 1056, 2023, 1_1333, 1_7413, 1029, 102]]      )
       with torch.no_grad():
            SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase      )[0]
       SCREAMING_SNAKE_CASE__					=					torch.Size((1, 9, 512)      )
       self.assertEqual(output.shape			,     __lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					torch.tensor(
           [
               [
                   [-2.4_73_65_26e07, 8.2_69_16_56e04, 1.6_52_18_38e05],
                   [-5.7_54_17_04e-01, 3.9_05_60_22e00, 4.4_01_15_07e00],
                   [2.6_04_73_59e00, 1.5_67_76_52e00, -1.7_32_41_88e-01],
               ]
           ]			,     device=__lowerCamelCase			,     )

       # MobileBERT results range from 10e0 to 10e8. Even a 0.0000001% difference with a value of 10e8 results in a
       # ~1 difference, it's therefore not a good idea to measure using addition.
       # Here, we instead divide the expected result with the result in order to obtain ~1. We then check that the
       # result is held between bounds: 1 - TOLERANCE < expected_result / result < 1 + TOLERANCE
       SCREAMING_SNAKE_CASE__					=					torch.all((expected_slice / output[..., :3, :3]) >= 1 - TOLERANCE      )
       SCREAMING_SNAKE_CASE__					=					torch.all((expected_slice / output[..., :3, :3]) <= 1 + TOLERANCE      )

       self.assertTrue(lower_bound and upper_bound      )


