



import inspect
import unittest

from transformers import MobileNetVaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers import MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation, MobileNetVaModel
			from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image

			from transformers import MobileNetVaImageProcessor


class 						lowercase    (							SCREAMING_SNAKE_CASE_):
						'''simple docstring'''


						def       lowerCamelCase_				(  self    :				Any	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     str						=				self.config_class(**self.inputs_dict	)
											self.parent.assertTrue(hasattr(snake_case       ,	'tf_padding'	)	)
											self.parent.assertTrue(hasattr(snake_case       ,	'depth_multiplier'	)	)


class 						lowercase    :
						'''simple docstring'''


						def __init__(  self    :				Tuple       ,	snake_case    :				List[Any]       ,	snake_case    :				Union[str, Any]=13       ,	snake_case    :				Tuple=3       ,	snake_case    :				Dict=32       ,	snake_case    :				Union[str, Any]=0.25       ,	snake_case    :				str=8       ,	snake_case    :				List[str]=8       ,	snake_case    :				Union[str, Any]=6       ,	snake_case    :				List[Any]=32       ,	snake_case    :				List[str]=True       ,	snake_case    :				Tuple=True       ,	snake_case    :				Dict=True       ,	snake_case    :				Optional[Any]="relu6"       ,	snake_case    :				List[str]=1280       ,	snake_case    :				Optional[int]=0.1       ,	snake_case    :				Any=0.02       ,	snake_case    :				int=True       ,	snake_case    :				Optional[Any]=True       ,	snake_case    :				Dict=10       ,	snake_case    :				Any=None       ,	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				parent
											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				batch_size
											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				num_channels
											SCREAMING_SNAKE_CASE							:     str						=				image_size
											SCREAMING_SNAKE_CASE							:     Tuple						=				depth_multiplier
											SCREAMING_SNAKE_CASE							:     Dict						=				depth_divisible_by
											SCREAMING_SNAKE_CASE							:     List[Any]						=				min_depth
											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				expand_ratio
											SCREAMING_SNAKE_CASE							:     Tuple						=				tf_padding
											SCREAMING_SNAKE_CASE							:     Tuple						=				output_stride
											SCREAMING_SNAKE_CASE							:     Tuple						=				first_layer_is_expansion
											SCREAMING_SNAKE_CASE							:     Dict						=				finegrained_output
											SCREAMING_SNAKE_CASE							:     List[str]						=				hidden_act
											SCREAMING_SNAKE_CASE							:     List[str]						=				last_hidden_size if finegrained_output else int(last_hidden_size * depth_multiplier	)
											SCREAMING_SNAKE_CASE							:     Dict						=				classifier_dropout_prob
											SCREAMING_SNAKE_CASE							:     int						=				use_labels
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				is_training
											SCREAMING_SNAKE_CASE							:     Dict						=				num_labels
											SCREAMING_SNAKE_CASE							:     Dict						=				initializer_range
											SCREAMING_SNAKE_CASE							:     List[Any]						=				scope







						def       lowerCamelCase_				(  self    :				int	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Dict						=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

											SCREAMING_SNAKE_CASE							:     Dict						=				None
											SCREAMING_SNAKE_CASE							:     str						=				None
											if self.use_labels:
																SCREAMING_SNAKE_CASE							:     str						=				ids_tensor([self.batch_size]       ,	self.num_labels	)
																SCREAMING_SNAKE_CASE							:     List[str]						=				ids_tensor([self.batch_size, self.image_size, self.image_size]       ,	self.num_labels	)

											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				self.get_config()

											return config, pixel_values, labels, pixel_labels







						def       lowerCamelCase_				(  self    :				Tuple	):



											'''simple docstring'''


											return MobileNetVaConfig(
											    num_channels=self.num_channels       ,	image_size=self.image_size       ,	depth_multiplier=self.depth_multiplier       ,	depth_divisible_by=self.depth_divisible_by       ,	min_depth=self.min_depth       ,	expand_ratio=self.expand_ratio       ,	output_stride=self.output_stride       ,	first_layer_is_expansion=self.first_layer_is_expansion       ,	finegrained_output=self.finegrained_output       ,	hidden_act=self.hidden_act       ,	tf_padding=self.tf_padding       ,	classifier_dropout_prob=self.classifier_dropout_prob       ,	initializer_range=self.initializer_range       ,	)







						def       lowerCamelCase_				(  self    :				Tuple       ,	snake_case    :				str       ,	snake_case    :				Any       ,	snake_case    :				Any       ,	snake_case    :				Tuple	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Dict						=				MobileNetVaModel(config=snake_case	)
											model.to(snake_case	)
											model.eval()
											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				model(snake_case	)
											self.parent.assertEqual(
											    result.last_hidden_state.shape       ,	(
											        self.batch_size,
											        self.last_hidden_size,
											        self.image_size // self.output_stride,
											        self.image_size // self.output_stride,
											    )       ,	)
											self.parent.assertEqual(
											    result.pooler_output.shape       ,	(self.batch_size, self.last_hidden_size)       ,	)







						def       lowerCamelCase_				(  self    :				Any       ,	snake_case    :				Tuple       ,	snake_case    :				Any       ,	snake_case    :				Dict       ,	snake_case    :				Any	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     int						=				self.num_labels
											SCREAMING_SNAKE_CASE							:     int						=				MobileNetVaForImageClassification(snake_case	)
											model.to(snake_case	)
											model.eval()
											SCREAMING_SNAKE_CASE							:     Tuple						=				model(snake_case       ,	labels=snake_case	)
											self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.num_labels)	)







						def       lowerCamelCase_				(  self    :				Dict       ,	snake_case    :				Tuple       ,	snake_case    :				List[Any]       ,	snake_case    :				Optional[int]       ,	snake_case    :				Optional[Any]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				self.num_labels
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				MobileNetVaForSemanticSegmentation(snake_case	)
											model.to(snake_case	)
											model.eval()
											SCREAMING_SNAKE_CASE							:     int						=				model(snake_case	)
											self.parent.assertEqual(
											    result.logits.shape       ,	(
											        self.batch_size,
											        self.num_labels,
											        self.image_size // self.output_stride,
											        self.image_size // self.output_stride,
											    )       ,	)
											SCREAMING_SNAKE_CASE							:     Tuple						=				model(snake_case       ,	labels=snake_case	)
											self.parent.assertEqual(
											    result.logits.shape       ,	(
											        self.batch_size,
											        self.num_labels,
											        self.image_size // self.output_stride,
											        self.image_size // self.output_stride,
											    )       ,	)







						def       lowerCamelCase_				(  self    :				List[str]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     str						=				self.prepare_config_and_inputs()
											SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     str						=				config_and_inputs
											SCREAMING_SNAKE_CASE							:     int						=				{'pixel_values': pixel_values}
											return config, inputs_dict


@require_torch
class 						lowercase    (							SCREAMING_SNAKE_CASE_      ,    SCREAMING_SNAKE_CASE_      ,    unittest.TestCase):
						'''simple docstring'''


						UpperCAmelCase			:		Union[str, Any]		=		(
						    (MobileNetVaModel, MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation)
						    if is_torch_available()
						    else ()
						)
						UpperCAmelCase			:		Optional[Any]		=		(
						    {
						        'feature-extraction': MobileNetVaModel,
						        'image-classification': MobileNetVaForImageClassification,
						        'image-segmentation': MobileNetVaForSemanticSegmentation,
						    }
						    if is_torch_available()
						    else {}
						)

						UpperCAmelCase			:		Optional[Any]		=		False
						UpperCAmelCase			:		Tuple		=		False
						UpperCAmelCase			:		Union[str, Any]		=		False
						UpperCAmelCase			:		Union[str, Any]		=		False







						def       lowerCamelCase_				(  self    :				List[str]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				MobileNetVaModelTester(self	)
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				MobileNetVaConfigTester(self       ,	config_class=snake_case       ,	has_text_modality=snake_case	)







						def       lowerCamelCase_				(  self    :				Union[str, Any]	):



											'''simple docstring'''


											self.config_tester.run_common_tests()







						@unittest.skip(reason='MobileNetV2 does not use inputs_embeds'	)
						def       lowerCamelCase_				(  self    :				int	):



											'''simple docstring'''


											pass







						@unittest.skip(reason='MobileNetV2 does not support input and output embeddings'	)
						def       lowerCamelCase_				(  self    :				str	):



											'''simple docstring'''


											pass







						@unittest.skip(reason='MobileNetV2 does not output attentions'	)
						def       lowerCamelCase_				(  self    :				Optional[Any]	):



											'''simple docstring'''


											pass







						def       lowerCamelCase_				(  self    :				List[str]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Any						=				self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																SCREAMING_SNAKE_CASE							:     int						=				model_class(snake_case	)
																SCREAMING_SNAKE_CASE							:     List[str]						=				inspect.signature(model.forward	)
																# signature.parameters is an OrderedDict => so arg_names order is deterministic
																SCREAMING_SNAKE_CASE							:     List[str]						=				[*signature.parameters.keys()]

																SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				['pixel_values']
																self.assertListEqual(arg_names[:1]       ,	snake_case	)







						def       lowerCamelCase_				(  self    :				List[str]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Tuple						=				self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*snake_case	)







						def       lowerCamelCase_				(  self    :				Optional[Any]	):



											'''simple docstring'''


											def check_hidden_states_output(snake_case    :				List[str]       ,	snake_case    :				Any       ,	snake_case    :				Tuple	):
																SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				model_class(snake_case	)
																model.to(snake_case	)
																model.eval()

																with torch.no_grad():
																					SCREAMING_SNAKE_CASE							:     Optional[int]						=				model(**self._prepare_for_class(snake_case       ,	snake_case	)	)

																SCREAMING_SNAKE_CASE							:     int						=				outputs.hidden_states

																SCREAMING_SNAKE_CASE							:     Any						=				16
																self.assertEqual(len(snake_case	)       ,	snake_case	)

											SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Tuple						=				self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																SCREAMING_SNAKE_CASE							:     Optional[int]						=				True
																check_hidden_states_output(snake_case       ,	snake_case       ,	snake_case	)

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																SCREAMING_SNAKE_CASE							:     Optional[Any]						=				True

																check_hidden_states_output(snake_case       ,	snake_case       ,	snake_case	)







						def       lowerCamelCase_				(  self    :				int	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     List[str]						=				self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*snake_case	)







						def       lowerCamelCase_				(  self    :				Any	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Tuple						=				self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_semantic_segmentation(*snake_case	)







						@slow
						def       lowerCamelCase_				(  self    :				int	):



											'''simple docstring'''


											for model_name in MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																SCREAMING_SNAKE_CASE							:     List[Any]						=				MobileNetVaModel.from_pretrained(snake_case	)
																self.assertIsNotNone(snake_case	)


def        __a			(   )     ->     Optional[int]:
					SCREAMING_SNAKE_CASE							:     str						=				Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
					return image



@require_torch
@require_vision
class 						lowercase    (							unittest.TestCase):
						'''simple docstring'''


						@cached_property
						def       lowerCamelCase_				(  self    :				Union[str, Any]	):



											'''simple docstring'''


											return (
											    MobileNetVaImageProcessor.from_pretrained('google/mobilenet_v2_1.0_224'	) if is_vision_available() else None
											)







						@slow
						def       lowerCamelCase_				(  self    :				Union[str, Any]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     List[Any]						=				MobileNetVaForImageClassification.from_pretrained('google/mobilenet_v2_1.0_224'	).to(snake_case	)

											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				self.default_image_processor
											SCREAMING_SNAKE_CASE							:     int						=				prepare_img()
											SCREAMING_SNAKE_CASE							:     str						=				image_processor(images=snake_case       ,	return_tensors='pt'	).to(snake_case	)

											# forward pass
											with torch.no_grad():
																SCREAMING_SNAKE_CASE							:     Optional[int]						=				model(**snake_case	)

											# verify the logits
											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				torch.Size((1, 1001)	)
											self.assertEqual(outputs.logits.shape       ,	snake_case	)

											SCREAMING_SNAKE_CASE							:     Any						=				torch.tensor([0.2445, -1.1993, 0.1905]	).to(snake_case	)

											self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,	snake_case       ,	atol=1E-4	)	)







						@slow
						def       lowerCamelCase_				(  self    :				Optional[int]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     List[str]						=				MobileNetVaForSemanticSegmentation.from_pretrained('google/deeplabv3_mobilenet_v2_1.0_513'	)
											SCREAMING_SNAKE_CASE							:     int						=				model.to(snake_case	)

											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				MobileNetVaImageProcessor.from_pretrained('google/deeplabv3_mobilenet_v2_1.0_513'	)

											SCREAMING_SNAKE_CASE							:     Any						=				prepare_img()
											SCREAMING_SNAKE_CASE							:     List[Any]						=				image_processor(images=snake_case       ,	return_tensors='pt'	).to(snake_case	)

											# forward pass
											with torch.no_grad():
																SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				model(**snake_case	)
											SCREAMING_SNAKE_CASE							:     int						=				outputs.logits

											# verify the logits
											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				torch.Size((1, 21, 65, 65)	)
											self.assertEqual(logits.shape       ,	snake_case	)

											SCREAMING_SNAKE_CASE							:     List[Any]						=				torch.tensor(
											    [
											        [[17.5790, 17.7581, 18.3355], [18.3257, 18.4230, 18.8973], [18.6169, 18.8650, 19.2187]],
											        [[-2.1595, -2.0977, -2.3741], [-2.4226, -2.3028, -2.6835], [-2.7819, -2.5991, -2.7706]],
											        [[4.2058, 4.8317, 4.7638], [4.4136, 5.0361, 4.9383], [4.5028, 4.9644, 4.8734]],
											    ]       ,	device=snake_case       ,	)

											self.assertTrue(torch.allclose(logits[0, :3, :3, :3]       ,	snake_case       ,	atol=1E-4	)	)




import unittest

import numpy as np

from transformers import DistilBertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
			import jax.numpy as jnp

			from transformers.models.distilbert.modeling_flax_distilbert import (
			    FlaxDistilBertForMaskedLM,
			    FlaxDistilBertForMultipleChoice,
			    FlaxDistilBertForQuestionAnswering,
			    FlaxDistilBertForSequenceClassification,
			    FlaxDistilBertForTokenClassification,
			    FlaxDistilBertModel,
			)


class 						lowercase    (							unittest.TestCase):
						'''simple docstring'''


						def __init__(  self    :				int       ,	snake_case    :				Optional[Any]       ,	snake_case    :				Optional[Any]=13       ,	snake_case    :				str=7       ,	snake_case    :				Optional[Any]=True       ,	snake_case    :				int=True       ,	snake_case    :				str=True       ,	snake_case    :				List[str]=True       ,	snake_case    :				Optional[Any]=99       ,	snake_case    :				Optional[int]=32       ,	snake_case    :				Optional[int]=5       ,	snake_case    :				Optional[Any]=4       ,	snake_case    :				Optional[Any]=37       ,	snake_case    :				str="gelu"       ,	snake_case    :				List[str]=0.1       ,	snake_case    :				List[str]=0.1       ,	snake_case    :				int=512       ,	snake_case    :				Union[str, Any]=16       ,	snake_case    :				Optional[Any]=2       ,	snake_case    :				int=0.02       ,	snake_case    :				str=4       ,	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Tuple						=				parent
											SCREAMING_SNAKE_CASE							:     str						=				batch_size
											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				seq_length
											SCREAMING_SNAKE_CASE							:     int						=				is_training
											SCREAMING_SNAKE_CASE							:     List[str]						=				use_attention_mask
											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				use_token_type_ids
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				use_labels
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				vocab_size
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				hidden_size
											SCREAMING_SNAKE_CASE							:     Any						=				num_hidden_layers
											SCREAMING_SNAKE_CASE							:     Tuple						=				num_attention_heads
											SCREAMING_SNAKE_CASE							:     Any						=				intermediate_size
											SCREAMING_SNAKE_CASE							:     Tuple						=				hidden_act
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				hidden_dropout_prob
											SCREAMING_SNAKE_CASE							:     str						=				attention_probs_dropout_prob
											SCREAMING_SNAKE_CASE							:     Tuple						=				max_position_embeddings
											SCREAMING_SNAKE_CASE							:     Any						=				type_vocab_size
											SCREAMING_SNAKE_CASE							:     List[Any]						=				type_sequence_label_size
											SCREAMING_SNAKE_CASE							:     Tuple						=				initializer_range
											SCREAMING_SNAKE_CASE							:     List[str]						=				num_choices







						def       lowerCamelCase_				(  self    :				List[Any]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				ids_tensor([self.batch_size, self.seq_length]       ,	self.vocab_size	)

											SCREAMING_SNAKE_CASE							:     Optional[int]						=				None
											if self.use_attention_mask:
																SCREAMING_SNAKE_CASE							:     Any						=				random_attention_mask([self.batch_size, self.seq_length]	)

											SCREAMING_SNAKE_CASE							:     Tuple						=				DistilBertConfig(
											    vocab_size=self.vocab_size       ,	dim=self.hidden_size       ,	n_layers=self.num_hidden_layers       ,	n_heads=self.num_attention_heads       ,	hidden_dim=self.intermediate_size       ,	hidden_act=self.hidden_act       ,	dropout=self.hidden_dropout_prob       ,	attention_dropout=self.attention_probs_dropout_prob       ,	max_position_embeddings=self.max_position_embeddings       ,	initializer_range=self.initializer_range       ,	tie_weights_=snake_case       ,	)

											return config, input_ids, attention_mask







						def       lowerCamelCase_				(  self    :				int	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Tuple						=				self.prepare_config_and_inputs()
											SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Optional[int]						=				config_and_inputs
											SCREAMING_SNAKE_CASE							:     int						=				{'input_ids': input_ids, 'attention_mask': attention_mask}
											return config, inputs_dict


@require_flax
class 						lowercase    (							SCREAMING_SNAKE_CASE_      ,    unittest.TestCase):
						'''simple docstring'''


						UpperCAmelCase			:		int		=		(
						    (
						        FlaxDistilBertModel,
						        FlaxDistilBertForMaskedLM,
						        FlaxDistilBertForMultipleChoice,
						        FlaxDistilBertForQuestionAnswering,
						        FlaxDistilBertForSequenceClassification,
						        FlaxDistilBertForTokenClassification,
						        FlaxDistilBertForQuestionAnswering,
						    )
						    if is_flax_available()
						    else ()
						)







						def       lowerCamelCase_				(  self    :				Optional[int]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     str						=				FlaxDistilBertModelTester(self	)







						@slow
						def       lowerCamelCase_				(  self    :				Any	):



											'''simple docstring'''


											for model_class_name in self.all_model_classes:
																SCREAMING_SNAKE_CASE							:     Dict						=				model_class_name.from_pretrained('distilbert-base-uncased'	)
																SCREAMING_SNAKE_CASE							:     Dict						=				model(np.ones((1, 1)	)	)
																self.assertIsNotNone(snake_case	)


@require_flax
class 						lowercase    (							unittest.TestCase):
						'''simple docstring'''


						@slow
						def       lowerCamelCase_				(  self    :				Tuple	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     List[Any]						=				FlaxDistilBertModel.from_pretrained('distilbert-base-uncased'	)
											SCREAMING_SNAKE_CASE							:     List[str]						=				np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]	)
											SCREAMING_SNAKE_CASE							:     Dict						=				np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]	)
											SCREAMING_SNAKE_CASE							:     str						=				model(snake_case       ,	attention_mask=snake_case	)[0]
											SCREAMING_SNAKE_CASE							:     int						=				(1, 11, 768)
											self.assertEqual(output.shape       ,	snake_case	)
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				np.array([[[-0.1639, 0.3299, 0.1648], [-0.1746, 0.3289, 0.1710], [-0.1884, 0.3357, 0.1810]]]	)

											self.assertTrue(jnp.allclose(output[:, 1:4, 1:4]       ,	snake_case       ,	atol=1E-4	)	)