

"""simple docstring"""

from scipy.stats import spearmanr

import datasets


lowercase    			=       '''
The Spearman rank-order correlation coefficient is a measure of the
relationship between two datasets. Like other correlation coefficients,
this one varies between -1 and +1 with 0 implying no correlation.
Positive correlations imply that as data in dataset x increases, so
does data in dataset y. Negative correlations imply that as x increases,
y decreases. Correlations of -1 or +1 imply an exact monotonic relationship.

Unlike the Pearson correlation, the Spearman correlation does not
assume that both datasets are normally distributed.

The p-value roughly indicates the probability of an uncorrelated system
producing datasets that have a Spearman correlation at least as extreme
as the one computed from these datasets. The p-values are not entirely
reliable but are probably reasonable for datasets larger than 500 or so.
'''

lowercase    			=       '''
Args:
    predictions (`List[float]`): Predicted labels, as returned by a model.
    references (`List[float]`): Ground truth labels.
    return_pvalue (`bool`): If `True`, returns the p-value. If `False`, returns
            only the spearmanr score. Defaults to `False`.
Returns:
    spearmanr (`float`): Spearman correlation coefficient.
    p-value (`float`): p-value. **Note**: is only returned if `return_pvalue=True` is input.
Examples:
    Example 1:
        >>> spearmanr_metric = datasets.load_metric("spearmanr")
        >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5], predictions=[10, 9, 2.5, 6, 4])
        >>> print(results)
        {\'spearmanr\': -0.7}

    Example 2:
        >>> spearmanr_metric = datasets.load_metric("spearmanr")
        >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5],
        ...                                     predictions=[10, 9, 2.5, 6, 4],
        ...                                     return_pvalue=True)
        >>> print(results[\'spearmanr\'])
        -0.7
        >>> print(round(results[\'spearmanr_pvalue\'], 2))
        0.19
'''

lowercase    			=       r'''\
@book{kokoska2000crc,
  title={CRC standard probability and statistics tables and formulae},
  author={Kokoska, Stephen and Zwillinger, Daniel},
  year={2000},
  publisher={Crc Press}
}
@article{2020SciPy-NMeth,
  author  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and
            Haberland, Matt and Reddy, Tyler and Cournapeau, David and
            Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and
            Bright, Jonathan and {van der Walt}, St{\'e}fan J. and
            Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and
            Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and
            Kern, Robert and Larson, Eric and Carey, C J and
            Polat, {\.I}lhan and Feng, Yu and Moore, Eric W. and
            {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and
            Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and
            Harris, Charles R. and Archibald, Anne M. and
            Ribeiro, Ant{\^o}nio H. and Pedregosa, Fabian and
            {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},
  title   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific
            Computing in Python}},
  journal = {Nature Methods},
  year    = {2020},
  volume  = {17},
  pages   = {261--272},
  adsurl  = {https://rdcu.be/b08Wh},
  doi     = {10.1038/s41592-019-0686-2},
}
'''

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION					,							_KWARGS_DESCRIPTION  )
class 						A_							(      datasets.Metric  ):







				def     _snake_case					(							self							:						List[Any]	)				->					Optional[int]:
										return datasets.MetricInfo(
										    description=_DESCRIPTION						,    citation=_CITATION						,    inputs_description=_KWARGS_DESCRIPTION						,    features=datasets.Features(
										        {
										            "predictions": datasets.Value("float"	),
										            "references": datasets.Value("float"	),
										        }	)						,    reference_urls=["https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.spearmanr.html"]						,    )







				def     _snake_case					(							self							:						str						,    __lowerCamelCase							:						Union[str, Any]						,    __lowerCamelCase							:						Any						,    __lowerCamelCase							:						Tuple=False	)				->					Union[str, Any]:
										__magic_name__            =     spearmanr(__lowerCamelCase						,    __lowerCamelCase	)
										if return_pvalue:
																return {"spearmanr": results[0], "spearmanr_pvalue": results[1]}
										else:
																return {"spearmanr": results[0]}











"""simple docstring"""

from __future__ import annotations

import copy
import inspect
import json
import math
import os
import tempfile
import unittest
from importlib import import_module

import numpy as np

from transformers import ViTMAEConfig
from transformers.file_utils import cached_property, is_tf_available, is_vision_available
from transformers.testing_utils import require_tf, require_vision, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
			import tensorflow as tf

			from transformers import TFViTMAEForPreTraining, TFViTMAEModel


if is_vision_available():
			from PIL import Image

			from transformers import ViTImageProcessor

class 						A_							:







				def __init__(							self							:						List[str]						,    __lowerCamelCase							:						str						,    __lowerCamelCase							:						Dict=1_3						,    __lowerCamelCase							:						int=3_0						,    __lowerCamelCase							:						List[Any]=2						,    __lowerCamelCase							:						List[Any]=3						,    __lowerCamelCase							:						Optional[int]=True						,    __lowerCamelCase							:						Optional[Any]=True						,    __lowerCamelCase							:						int=3_2						,    __lowerCamelCase							:						int=2						,    __lowerCamelCase							:						Optional[Any]=4						,    __lowerCamelCase							:						List[str]=3_7						,    __lowerCamelCase							:						List[str]="gelu"						,    __lowerCamelCase							:						Tuple=0.1						,    __lowerCamelCase							:						int=0.1						,    __lowerCamelCase							:						Optional[int]=1_0						,    __lowerCamelCase							:						Tuple=0.02						,    __lowerCamelCase							:						Any=3						,    __lowerCamelCase							:						Union[str, Any]=0.6						,    __lowerCamelCase							:						Optional[int]=None						,    )				->					Union[str, Any]:
										__magic_name__            =     parent
										__magic_name__            =     batch_size
										__magic_name__            =     image_size
										__magic_name__            =     patch_size
										__magic_name__            =     num_channels
										__magic_name__            =     is_training
										__magic_name__            =     use_labels
										__magic_name__            =     hidden_size
										__magic_name__            =     num_hidden_layers
										__magic_name__            =     num_attention_heads
										__magic_name__            =     intermediate_size
										__magic_name__            =     hidden_act
										__magic_name__            =     hidden_dropout_prob
										__magic_name__            =     attention_probs_dropout_prob
										__magic_name__            =     type_sequence_label_size
										__magic_name__            =     initializer_range
										__magic_name__            =     mask_ratio
										__magic_name__            =     scope

										# in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
										# (we add 1 for the [CLS] token)
										__magic_name__            =     (image_size // patch_size) ** 2
										__magic_name__            =     int(math.ceil((1 - mask_ratio) * (num_patches + 1)	)	)







				def     _snake_case					(							self							:						Optional[Any]	)				->					List[Any]:
										__magic_name__            =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

										__magic_name__            =     None
										if self.use_labels:
																__magic_name__            =     ids_tensor([self.batch_size]						,    self.type_sequence_label_size	)

										__magic_name__            =     self.get_config()

										return config, pixel_values, labels







				def     _snake_case					(							self							:						Optional[int]	)				->					Dict:
										return ViTMAEConfig(
										    image_size=self.image_size						,    patch_size=self.patch_size						,    num_channels=self.num_channels						,    hidden_size=self.hidden_size						,    num_hidden_layers=self.num_hidden_layers						,    num_attention_heads=self.num_attention_heads						,    intermediate_size=self.intermediate_size						,    decoder_hidden_size=self.hidden_size						,    decoder_num_hidden_layers=self.num_hidden_layers						,    decoder_num_attention_heads=self.num_attention_heads						,    decoder_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						,    is_decoder=__lowerCamelCase						,    initializer_range=self.initializer_range						,    mask_ratio=self.mask_ratio						,    )







				def     _snake_case					(							self							:						Tuple						,    __lowerCamelCase							:						Dict						,    __lowerCamelCase							:						Tuple						,    __lowerCamelCase							:						Optional[int]	)				->					Optional[int]:
										__magic_name__            =     TFViTMAEModel(config=__lowerCamelCase	)
										__magic_name__            =     model(__lowerCamelCase						,    training=__lowerCamelCase	)
										self.parent.assertEqual(result.last_hidden_state.shape						,    (self.batch_size, self.seq_length, self.hidden_size)	)







				def     _snake_case					(							self							:						Tuple						,    __lowerCamelCase							:						List[str]						,    __lowerCamelCase							:						List[Any]						,    __lowerCamelCase							:						str	)				->					Union[str, Any]:
										__magic_name__            =     TFViTMAEForPreTraining(__lowerCamelCase	)
										__magic_name__            =     model(__lowerCamelCase						,    training=__lowerCamelCase	)
										# expected sequence length = num_patches
										__magic_name__            =     (self.image_size // self.patch_size) ** 2
										__magic_name__            =     self.patch_size**2 * self.num_channels
										self.parent.assertEqual(result.logits.shape						,    (self.batch_size, num_patches, expected_num_channels)	)

										# test greyscale images
										__magic_name__            =     1
										__magic_name__            =     TFViTMAEForPreTraining(__lowerCamelCase	)

										__magic_name__            =     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
										__magic_name__            =     model(__lowerCamelCase						,    training=__lowerCamelCase	)
										__magic_name__            =     self.patch_size**2
										self.parent.assertEqual(result.logits.shape						,    (self.batch_size, num_patches, expected_num_channels)	)







				def     _snake_case					(							self							:						Tuple	)				->					Optional[Any]:
										__magic_name__            =     self.prepare_config_and_inputs()
										((__magic_name__)      ,    (__magic_name__)      ,    (__magic_name__))            =     config_and_inputs
										__magic_name__            =     {"pixel_values": pixel_values}
										return config, inputs_dict





@require_tf
class 						A_							(      snake_case_					,							snake_case_					,							unittest.TestCase  ):
				UpperCAmelCase__        =				(TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
				UpperCAmelCase__        =				{'''feature-extraction''': TFViTMAEModel} if is_tf_available() else {}

				UpperCAmelCase__        =				False
				UpperCAmelCase__        =				False
				UpperCAmelCase__        =				False
				UpperCAmelCase__        =				False







				def     _snake_case					(							self							:						Any	)				->					int:
										__magic_name__            =     TFViTMAEModelTester(self	)
										__magic_name__            =     ConfigTester(self						,    config_class=__lowerCamelCase						,    has_text_modality=__lowerCamelCase						,    hidden_size=3_7	)







				def     _snake_case					(							self							:						Dict	)				->					Any:
										self.config_tester.run_common_tests()







				@unittest.skip(reason="ViTMAE does not use inputs_embeds"	)
				def     _snake_case					(							self							:						Any	)				->					Optional[Any]:
										pass







				def     _snake_case					(							self							:						Optional[Any]	)				->					Tuple:
										__magic_name__      ,    __magic_name__            =     self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																__magic_name__            =     model_class(__lowerCamelCase	)
																self.assertIsInstance(model.get_input_embeddings()						,    (tf.keras.layers.Layer)	)
																__magic_name__            =     model.get_output_embeddings()
																self.assertTrue(x is None or isinstance(__lowerCamelCase						,    tf.keras.layers.Layer	)	)







				def     _snake_case					(							self							:						Optional[Any]	)				->					Optional[Any]:
										__magic_name__      ,    __magic_name__            =     self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																__magic_name__            =     model_class(__lowerCamelCase	)
																__magic_name__            =     inspect.signature(model.call	)
																# signature.parameters is an OrderedDict => so arg_names order is deterministic
																__magic_name__            =     [*signature.parameters.keys()]

																__magic_name__            =     ["pixel_values"]
																self.assertListEqual(arg_names[:1]						,    __lowerCamelCase	)







				def     _snake_case					(							self							:						int	)				->					Union[str, Any]:
										__magic_name__            =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*__lowerCamelCase	)







				def     _snake_case					(							self							:						str	)				->					Any:
										__magic_name__            =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_pretraining(*__lowerCamelCase	)







				def     _snake_case					(							self							:						str	)				->					List[Any]:
										# make the mask reproducible
										np.random.seed(2	)

										__magic_name__      ,    __magic_name__            =     self.model_tester.prepare_config_and_inputs_for_common()

										__magic_name__            =     int((config.image_size // config.patch_size) ** 2	)
										__magic_name__            =     np.random.uniform(size=(self.model_tester.batch_size, num_patches)	)

										for model_class in self.all_model_classes:
																__magic_name__            =     model_class(__lowerCamelCase	)
																__magic_name__            =     self._prepare_for_class(__lowerCamelCase						,    __lowerCamelCase	)

																__magic_name__            =     model(__lowerCamelCase						,    noise=__lowerCamelCase	)

																__magic_name__            =     copy.deepcopy(self._prepare_for_class(__lowerCamelCase						,    __lowerCamelCase	)	)
																__magic_name__            =     model(**__lowerCamelCase						,    noise=__lowerCamelCase	)
																__magic_name__            =     outputs_dict[0].numpy()
																__magic_name__            =     outputs_keywords[0].numpy()

																self.assertLess(np.sum(np.abs(output_dict - output_keywords	)	)						,    1e-6	)







				def     _snake_case					(							self							:						int	)				->					Union[str, Any]:
										# make the mask reproducible
										np.random.seed(2	)

										__magic_name__      ,    __magic_name__            =     self.model_tester.prepare_config_and_inputs_for_common()

										__magic_name__            =     int((config.image_size // config.patch_size) ** 2	)
										__magic_name__            =     np.random.uniform(size=(self.model_tester.batch_size, num_patches)	)

										def prepare_numpy_arrays(__lowerCamelCase							:						Tuple	):
																__magic_name__            =     {}
																for k, v in inputs_dict.items():
																						if tf.is_tensor(__lowerCamelCase	):
																												__magic_name__            =     v.numpy()
																						else:
																												__magic_name__            =     np.array(__lowerCamelCase	)

																return inputs_np_dict

										for model_class in self.all_model_classes:
																__magic_name__            =     model_class(__lowerCamelCase	)

																__magic_name__            =     self._prepare_for_class(__lowerCamelCase						,    __lowerCamelCase	)
																__magic_name__            =     prepare_numpy_arrays(__lowerCamelCase	)

																__magic_name__            =     model(__lowerCamelCase						,    noise=__lowerCamelCase	)
																__magic_name__            =     model(**__lowerCamelCase						,    noise=__lowerCamelCase	)
																self.assert_outputs_same(__lowerCamelCase						,    __lowerCamelCase	)







				def     _snake_case					(							self							:						int						,    __lowerCamelCase							:						Optional[int]						,    __lowerCamelCase							:						Any						,    __lowerCamelCase							:						Dict	)				->					List[Any]:
										# make masks reproducible
										np.random.seed(2	)

										__magic_name__            =     int((tf_model.config.image_size // tf_model.config.patch_size) ** 2	)
										__magic_name__            =     np.random.uniform(size=(self.model_tester.batch_size, num_patches)	)
										__magic_name__            =     tf.constant(__lowerCamelCase	)

										# Add `noise` argument.
										# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
										__magic_name__            =     tf_noise

										super().check_pt_tf_models(__lowerCamelCase						,    __lowerCamelCase						,    __lowerCamelCase	)







				def     _snake_case					(							self							:						List[Any]	)				->					List[str]:
										# make mask reproducible
										np.random.seed(2	)

										__magic_name__      ,    __magic_name__            =     self.model_tester.prepare_config_and_inputs_for_common()

										__magic_name__            =     {
										    module_member
										    for model_class in self.all_model_classes
										    for module in (import_module(model_class.__module__	),)
										    for module_member_name in dir(__lowerCamelCase	)
										    if module_member_name.endswith("MainLayer"	)
										    # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`.
										    and module_member_name[: -len("MainLayer"	)] == model_class.__name__[: -len("Model"	)]
										    for module_member in (getattr(__lowerCamelCase						,    __lowerCamelCase	),)
										    if isinstance(__lowerCamelCase						,    __lowerCamelCase	)
										    and tf.keras.layers.Layer in module_member.__bases__
										    and getattr(__lowerCamelCase						,    "_keras_serializable"						,    __lowerCamelCase	)
										}

										__magic_name__            =     int((config.image_size // config.patch_size) ** 2	)
										__magic_name__            =     np.random.uniform(size=(self.model_tester.batch_size, num_patches)	)
										__magic_name__            =     tf.convert_to_tensor(__lowerCamelCase	)
										inputs_dict.update({"noise": noise}	)

										for main_layer_class in tf_main_layer_classes:
																__magic_name__            =     main_layer_class(__lowerCamelCase	)

																__magic_name__            =     {
																    name: tf.keras.Input(tensor.shape[1:]						,    dtype=tensor.dtype	) for name, tensor in inputs_dict.items()
																}

																__magic_name__            =     tf.keras.Model(__lowerCamelCase						,    outputs=main_layer(__lowerCamelCase	)	)
																__magic_name__            =     model(__lowerCamelCase	)

																with tempfile.TemporaryDirectory() as tmpdirname:
																						__magic_name__            =     os.path.join(__lowerCamelCase						,    "keras_model.h5"	)
																						model.save(__lowerCamelCase	)
																						__magic_name__            =     tf.keras.models.load_model(
																						    __lowerCamelCase						,    custom_objects={main_layer_class.__name__: main_layer_class}	)
																						assert isinstance(__lowerCamelCase						,    tf.keras.Model	)
																						__magic_name__            =     model(__lowerCamelCase	)
																						self.assert_outputs_same(__lowerCamelCase						,    __lowerCamelCase	)







				@slow
				def     _snake_case					(							self							:						Union[str, Any]	)				->					str:
										# make mask reproducible
										np.random.seed(2	)

										__magic_name__      ,    __magic_name__            =     self.model_tester.prepare_config_and_inputs_for_common()

										__magic_name__            =     int((config.image_size // config.patch_size) ** 2	)
										__magic_name__            =     np.random.uniform(size=(self.model_tester.batch_size, num_patches)	)

										for model_class in self.all_model_classes:
																__magic_name__            =     model_class(__lowerCamelCase	)
																__magic_name__            =     self._prepare_for_class(__lowerCamelCase						,    __lowerCamelCase	)
																__magic_name__            =     model(__lowerCamelCase						,    noise=__lowerCamelCase	)

																if model_class.__name__ == "TFViTMAEModel":
																						__magic_name__            =     outputs.last_hidden_state.numpy()
																						__magic_name__            =     0
																else:
																						__magic_name__            =     outputs.logits.numpy()
																						__magic_name__            =     0

																with tempfile.TemporaryDirectory() as tmpdirname:
																						model.save_pretrained(__lowerCamelCase						,    saved_model=__lowerCamelCase	)
																						__magic_name__            =     model_class.from_pretrained(__lowerCamelCase	)
																						__magic_name__            =     model(__lowerCamelCase						,    noise=__lowerCamelCase	)

																						if model_class.__name__ == "TFViTMAEModel":
																												__magic_name__            =     after_outputs["last_hidden_state"].numpy()
																												__magic_name__            =     0
																						else:
																												__magic_name__            =     after_outputs["logits"].numpy()
																												__magic_name__            =     0

																						__magic_name__            =     np.amax(np.abs(out_a - out_a	)	)
																						self.assertLessEqual(__lowerCamelCase						,    1e-5	)







				def     _snake_case					(							self							:						List[str]	)				->					Optional[Any]:
										# make mask reproducible
										np.random.seed(2	)

										__magic_name__      ,    __magic_name__            =     self.model_tester.prepare_config_and_inputs_for_common()

										__magic_name__            =     int((config.image_size // config.patch_size) ** 2	)
										__magic_name__            =     np.random.uniform(size=(self.model_tester.batch_size, num_patches)	)

										for model_class in self.all_model_classes:
																__magic_name__            =     model_class(__lowerCamelCase	)
																__magic_name__            =     self._prepare_for_class(__lowerCamelCase						,    __lowerCamelCase	)

																__magic_name__            =     model(__lowerCamelCase						,    noise=__lowerCamelCase	)
																__magic_name__            =     model.get_config()
																# make sure that returned config is jsonifiable, which is required by keras
																json.dumps(__lowerCamelCase	)
																__magic_name__            =     model_class.from_config(model.get_config()	)
																# make sure it also accepts a normal config
																__magic_name__            =     model_class.from_config(model.config	)
																__magic_name__            =     new_model(__lowerCamelCase	)  # Build model
																new_model.set_weights(model.get_weights()	)
																__magic_name__            =     new_model(__lowerCamelCase						,    noise=__lowerCamelCase	)

																self.assert_outputs_same(__lowerCamelCase						,    __lowerCamelCase	)







				@unittest.skip(
				    reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."	)
				def     _snake_case					(							self							:						str	)				->					List[Any]:
										pass







				@unittest.skip(reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load"	)
				def     _snake_case					(							self							:						Any	)				->					List[str]:
										pass







				@slow
				def     _snake_case					(							self							:						List[Any]	)				->					Any:
										__magic_name__            =     TFViTMAEModel.from_pretrained("google/vit-base-patch16-224"	)
										self.assertIsNotNone(__lowerCamelCase	)






def _lowerCAmelCase	(  ):

						'''simple docstring'''






						__magic_name__            =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"   )
						return image


@require_tf
@require_vision
class 						A_							(      unittest.TestCase  ):







				@cached_property
				def     _snake_case					(							self							:						Union[str, Any]	)				->					Union[str, Any]:
										return ViTImageProcessor.from_pretrained("facebook/vit-mae-base"	) if is_vision_available() else None







				@slow
				def     _snake_case					(							self							:						Union[str, Any]	)				->					Union[str, Any]:
										# make random mask reproducible across the PT and TF model
										np.random.seed(2	)

										__magic_name__            =     TFViTMAEForPreTraining.from_pretrained("facebook/vit-mae-base"	)

										__magic_name__            =     self.default_image_processor
										__magic_name__            =     prepare_img()
										__magic_name__            =     image_processor(images=__lowerCamelCase						,    return_tensors="tf"	)

										# prepare a noise vector that will be also used for testing the TF model
										# (this way we can ensure that the PT and TF models operate on the same inputs)
										__magic_name__            =     ViTMAEConfig()
										__magic_name__            =     int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2	)
										__magic_name__            =     np.random.uniform(size=(1, num_patches)	)

										# forward pass
										__magic_name__            =     model(**__lowerCamelCase						,    noise=__lowerCamelCase	)

										# verify the logits
										__magic_name__            =     tf.convert_to_tensor([1, 1_9_6, 7_6_8]	)
										self.assertEqual(outputs.logits.shape						,    __lowerCamelCase	)

										__magic_name__            =     tf.convert_to_tensor(
										    [[-0.0548, -1.7023, -0.9325], [0.3721, -0.5670, -0.2233], [0.8235, -1.3878, -0.3524]]	)

										tf.debugging.assert_near(outputs.logits[0, :3, :3]						,    __lowerCamelCase						,    atol=1e-4	)



