




import os
import warnings
from pathlib import Path
from typing import Optional, Union

from .dynamic_module_utils import custom_object_save
from .tokenization_utils_base import PreTrainedTokenizerBase
from .utils import PushToHubMixin, copy_func, direct_transformers_import, logging


UpperCAmelCase__    :							Optional[int]       		=     logging.get_logger(__name__)

# Dynamically import the Transformers module to grab the attribute classes of the processor form their names.
UpperCAmelCase__    :							int       		=     direct_transformers_import(Path(__file__).parent)


UpperCAmelCase__    :							Optional[Any]       		=     {
    'AutoTokenizer': 'PreTrainedTokenizerBase',
    'AutoFeatureExtractor': 'FeatureExtractionMixin',
    'AutoImageProcessor': 'ImageProcessingMixin',
}

class   UpperCAmelCase    (      __SCREAMING_SNAKE_CASE ):
   __SCREAMING_SNAKE_CASE		:				str      					=       ["feature_extractor", "tokenizer"]
   # Names need to be attr_class for attr in attributes
   __SCREAMING_SNAKE_CASE		:				Optional[int]      					=       None
   __SCREAMING_SNAKE_CASE		:				str      					=       None
   __SCREAMING_SNAKE_CASE		:				List[str]      					=       None






   def __init__(						self :							Optional[int]    ,       *UpperCamelCase_ :							Dict    ,       **UpperCamelCase_ :							Tuple  )->      Optional[int]:
     # Sanitize args and kwargs
     for key in kwargs:
       if key not in self.attributes:
         raise TypeError(f'Unexpected keyword argument {key}.'  )
     for arg, attribute_name in zip(__UpperCAmelCase    ,       self.attributes  ):
       if attribute_name in kwargs:
         raise TypeError(f'Got multiple values for argument {attribute_name}.'  )
       else:
         _lowercase:			int      =     arg

     if len(__UpperCAmelCase  ) != len(self.attributes  ):
       raise ValueError(
           f'This processor requires {len(self.attributes  )} arguments: {", ".join(self.attributes  )}. Got '
           f'{len(__UpperCAmelCase  )} arguments instead.'  )

     # Check each arg is of the proper class (this will also catch a user initializing in the wrong order)
     for attribute_name, arg in kwargs.items():
       _lowercase:			int      =     getattr(self    ,       f'{attribute_name}_class'  )
       # Nothing is ever going to be an instance of "AutoXxx", in that case we check the base class.
       _lowercase:			str      =     AUTO_TO_BASE_CLASS_MAPPING.get(__UpperCAmelCase    ,       __UpperCAmelCase  )
       if isinstance(__UpperCAmelCase    ,       __UpperCAmelCase  ):
         _lowercase:			str      =     tuple(getattr(__UpperCAmelCase    ,       __UpperCAmelCase  ) for n in class_name if n is not None  )
       else:
         _lowercase:			Optional[Any]      =     getattr(__UpperCAmelCase    ,       __UpperCAmelCase  )

       if not isinstance(__UpperCAmelCase    ,       __UpperCAmelCase  ):
         raise ValueError(
             f'Received a {type(__UpperCAmelCase  ).__name__} for argument {attribute_name}, but a {class_name} was expected.'  )

       setattr(self    ,       __UpperCAmelCase    ,       __UpperCAmelCase  )






   def __repr__(						self :							Optional[Any]  )->      List[str]:
     _lowercase:			Any      =     [f'- {name}: {repr(getattr(self    ,       __UpperCAmelCase  )  )}' for name in self.attributes]
     _lowercase:			List[Any]      =     """\n""".join(__UpperCAmelCase  )
     return f'{self.__class__.__name__}:\n{attributes_repr}'






   def 			_a    (						self :							Dict    ,       UpperCamelCase_ :							int    ,       UpperCamelCase_ :							Optional[Any] = False    ,       **UpperCamelCase_ :							List[Any]  )->      Any:
     os.makedirs(__UpperCAmelCase    ,       exist_ok=__UpperCAmelCase  )

     if push_to_hub:
       _lowercase:			Optional[int]      =     kwargs.pop('commit_message'    ,       __UpperCAmelCase  )
       _lowercase:			List[Any]      =     kwargs.pop('repo_id'    ,       save_directory.split(os.path.sep  )[-1]  )
       _lowercase:			Any      =     self._create_repo(__UpperCAmelCase    ,       **__UpperCAmelCase  )
       _lowercase:			List[str]      =     self._get_files_timestamps(__UpperCAmelCase  )
     # If we have a custom config, we copy the file defining it in the folder and set the attributes so it can be
     # loaded from the Hub.
     if self._auto_class is not None:
       _lowercase:			Union[str, Any]      =     [getattr(self    ,       __UpperCAmelCase  ) for attribute_name in self.attributes]
       _lowercase:			Dict      =     [(a.init_kwargs if isinstance(__UpperCAmelCase    ,       __UpperCAmelCase  ) else a) for a in attrs]
       custom_object_save(self    ,       __UpperCAmelCase    ,       config=__UpperCAmelCase  )

     for attribute_name in self.attributes:
       _lowercase:			Optional[int]      =     getattr(self    ,       __UpperCAmelCase  )
       # Include the processor class in the attribute config so this processor can then be reloaded with the
       # `AutoProcessor` API.
       if hasattr(__UpperCAmelCase    ,       '_set_processor_class'  ):
         attribute._set_processor_class(self.__class__.__name__  )
       attribute.save_pretrained(__UpperCAmelCase  )

     if self._auto_class is not None:
       # We added an attribute to the init_kwargs of the tokenizers, which needs to be cleaned up.
       for attribute_name in self.attributes:
         _lowercase:			str      =     getattr(self    ,       __UpperCAmelCase  )
         if isinstance(__UpperCAmelCase    ,       __UpperCAmelCase  ):
           del attribute.init_kwargs["auto_map"]

     if push_to_hub:
       self._upload_modified_files(
           __UpperCAmelCase    ,       __UpperCAmelCase    ,       __UpperCAmelCase    ,       commit_message=__UpperCAmelCase    ,       token=kwargs.get('use_auth_token'  )    ,       )






   @classmethod
   def 			_a    (						cls :							Optional[int]    ,       UpperCamelCase_ :							List[str]    ,       UpperCamelCase_ :							str = None    ,       UpperCamelCase_ :							Tuple = False    ,       UpperCamelCase_ :							int = False    ,       UpperCamelCase_ :							Optional[int] = None    ,       UpperCamelCase_ :							Optional[Any] = "main"    ,       **UpperCamelCase_ :							List[Any]    ,       )->      Optional[int]:
     _lowercase:			List[str]      =     cache_dir
     _lowercase:			Tuple      =     force_download
     _lowercase:			Optional[int]      =     local_files_only
     _lowercase:			str      =     revision

     _lowercase:			int      =     kwargs.pop('use_auth_token'    ,       __UpperCAmelCase  )
     if use_auth_token is not None:
       warnings.warn(
           'The `use_auth_token` argument is deprecated and will be removed in v5 of Transformers.'    ,       __UpperCAmelCase  )
       if token is not None:
         raise ValueError(
             '`token` and `use_auth_token` are both specified. Please set only the argument `token`.'  )
       _lowercase:			Any      =     use_auth_token

     if token is not None:
       # change to `token` in a follow-up PR
       _lowercase:			Dict      =     token

     _lowercase:			Optional[int]      =     cls._get_arguments_from_pretrained(__UpperCAmelCase    ,       **__UpperCAmelCase  )
     return cls(*__UpperCAmelCase  )






   @classmethod
   def 			_a    (						cls :							int    ,       UpperCamelCase_ :							Dict="AutoProcessor"  )->      Dict:
     if not isinstance(__UpperCAmelCase    ,       __UpperCAmelCase  ):
       _lowercase:			List[Any]      =     auto_class.__name__

     import transformers.models.auto as auto_module

     if not hasattr(__UpperCAmelCase    ,       __UpperCAmelCase  ):
       raise ValueError(f'{auto_class} is not a valid auto class.'  )

     _lowercase:			Optional[Any]      =     auto_class






   @classmethod
   def 			_a    (						cls :							List[Any]    ,       UpperCamelCase_ :							Optional[int]    ,       **UpperCamelCase_ :							Tuple  )->      List[str]:
     _lowercase:			Union[str, Any]      =     []
     for attribute_name in cls.attributes:
       _lowercase:			List[Any]      =     getattr(cls    ,       f'{attribute_name}_class'  )
       if isinstance(__UpperCAmelCase    ,       __UpperCAmelCase  ):
         _lowercase:			str      =     tuple(getattr(__UpperCAmelCase    ,       __UpperCAmelCase  ) if n is not None else None for n in class_name  )
         _lowercase:			int      =     kwargs.get('use_fast'    ,       __UpperCAmelCase  )
         if use_fast and classes[1] is not None:
           _lowercase:			int      =     classes[1]
         else:
           _lowercase:			Optional[Any]      =     classes[0]
       else:
         _lowercase:			str      =     getattr(__UpperCAmelCase    ,       __UpperCAmelCase  )

       args.append(attribute_class.from_pretrained(__UpperCAmelCase    ,       **__UpperCAmelCase  )  )
     return args






   @property
   def 			_a    (						self :							int  )->      Tuple:
     _lowercase:			Optional[Any]      =     getattr(self    ,       self.attributes[0]  )
     return getattr(__UpperCAmelCase    ,       'model_input_names'    ,       __UpperCAmelCase  )
UpperCAmelCase__    :							str       		=     copy_func(ProcessorMixin.push_to_hub)
if ProcessorMixin.push_to_hub.__doc__ is not None:
   UpperCAmelCase__    :							List[str]       		=     ProcessorMixin.push_to_hub.__doc__.format(
       object='processor', object_class='AutoProcessor', object_files='processor files'
   )





'''simple docstring'''
from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import ConvNextConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

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 TFConvNextForImageClassification, TFConvNextModel


if is_vision_available():
					from PIL import Image

					from transformers import ConvNextImageProcessor



class _A	:





		def __init__(  self			,							__UpperCAmelCase			,							__UpperCAmelCase=13			,							__UpperCAmelCase=32			,							__UpperCAmelCase=3			,							__UpperCAmelCase=4			,							__UpperCAmelCase=[10, 20, 30, 40]			,							__UpperCAmelCase=[2, 2, 3, 2]			,							__UpperCAmelCase=True			,							__UpperCAmelCase=True			,							__UpperCAmelCase=37			,							__UpperCAmelCase="gelu"			,							__UpperCAmelCase=10			,							__UpperCAmelCase=0.02			,							__UpperCAmelCase=3			,							__UpperCAmelCase=None			,							)							->  Any:

					'''simple docstring'''
					__UpperCAmelCase :   Optional[int]    					=  parent
					__UpperCAmelCase :   Optional[Any]    					=  batch_size
					__UpperCAmelCase :   List[str]    					=  image_size
					__UpperCAmelCase :   Optional[Any]    					=  num_channels
					__UpperCAmelCase :   int    					=  num_stages
					__UpperCAmelCase :   List[Any]    					=  hidden_sizes
					__UpperCAmelCase :   Optional[Any]    					=  depths
					__UpperCAmelCase :   List[str]    					=  is_training
					__UpperCAmelCase :   Tuple    					=  use_labels
					__UpperCAmelCase :   Optional[Any]    					=  intermediate_size
					__UpperCAmelCase :   Dict    					=  hidden_act
					__UpperCAmelCase :   List[str]    					=  type_sequence_label_size
					__UpperCAmelCase :   Union[str, Any]    					=  initializer_range
					__UpperCAmelCase :   Optional[Any]    					=  scope





		def 				__A							(  self					)							->  Optional[Any]:

					'''simple docstring'''
					__UpperCAmelCase :   List[Any]    					=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

					__UpperCAmelCase :   str    					=  None
					if self.use_labels:
								__UpperCAmelCase :   Optional[Any]    					=  ids_tensor([self.batch_size]			,							self.type_sequence_label_size					)

					__UpperCAmelCase :   Optional[int]    					=  self.get_config()

					return config, pixel_values, labels





		def 				__A							(  self					)							->  Optional[Any]:

					'''simple docstring'''
					return ConvNextConfig(
					    num_channels=self.num_channels			,							hidden_sizes=self.hidden_sizes			,							depths=self.depths			,							num_stages=self.num_stages			,							hidden_act=self.hidden_act			,							is_decoder=__UpperCAmelCase			,							initializer_range=self.initializer_range			,							)





		def 				__A							(  self			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase					)							->  List[Any]:

					'''simple docstring'''
					__UpperCAmelCase :   List[Any]    					=  TFConvNextModel(config=__UpperCAmelCase					)
					__UpperCAmelCase :   List[Any]    					=  model(__UpperCAmelCase			,							training=__UpperCAmelCase					)
					# expected last hidden states: B, C, H // 32, W // 32
					self.parent.assertEqual(
					    result.last_hidden_state.shape			,							(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)			,							)





		def 				__A							(  self			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase					)							->  Optional[int]:

					'''simple docstring'''
					__UpperCAmelCase :   Optional[int]    					=  self.type_sequence_label_size
					__UpperCAmelCase :   List[Any]    					=  TFConvNextForImageClassification(__UpperCAmelCase					)
					__UpperCAmelCase :   List[str]    					=  model(__UpperCAmelCase			,							labels=__UpperCAmelCase			,							training=__UpperCAmelCase					)
					self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.type_sequence_label_size)					)





		def 				__A							(  self					)							->  Union[str, Any]:

					'''simple docstring'''
					__UpperCAmelCase :   List[str]    					=  self.prepare_config_and_inputs()
					__UpperCAmelCase					,	__UpperCAmelCase					,	__UpperCAmelCase :   Optional[int]    					=  config_and_inputs
					__UpperCAmelCase :   Union[str, Any]    					=  {"""pixel_values""": pixel_values}
					return config, inputs_dict



@require_tf
class _A	(     __SCREAMING_SNAKE_CASE						,					__SCREAMING_SNAKE_CASE						,					unittest.TestCase     ):
		_SCREAMING_SNAKE_CASE       :     Dict       =      (TFConvNextModel, TFConvNextForImageClassification) if is_tf_available() else ()
		_SCREAMING_SNAKE_CASE       :     Optional[Any]       =      (
		    {"feature-extraction": TFConvNextModel, "image-classification": TFConvNextForImageClassification}
		    if is_tf_available()
		    else {}
		)

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





		def 				__A							(  self					)							->  List[Any]:

					'''simple docstring'''
					__UpperCAmelCase :   Dict    					=  TFConvNextModelTester(self					)
					__UpperCAmelCase :   Optional[int]    					=  ConfigTester(
					    self			,							config_class=__UpperCAmelCase			,							has_text_modality=__UpperCAmelCase			,							hidden_size=37			,							)





		@unittest.skip(reason="""ConvNext does not use inputs_embeds"""					)
		def 				__A							(  self					)							->  str:

					'''simple docstring'''
					pass





		@unittest.skipIf(
		    not is_tf_available() or len(tf.config.list_physical_devices("""GPU"""					)					) == 0			,							reason="""TF does not support backprop for grouped convolutions on CPU."""			,							)
		@slow
		def 				__A							(  self					)							->  Optional[int]:

					'''simple docstring'''
					super().test_keras_fit()





		@unittest.skip(reason="""ConvNext does not support input and output embeddings"""					)
		def 				__A							(  self					)							->  Dict:

					'''simple docstring'''
					pass





		def 				__A							(  self					)							->  str:

					'''simple docstring'''
					__UpperCAmelCase					,	__UpperCAmelCase :   List[str]    					=  self.model_tester.prepare_config_and_inputs_for_common()

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

								__UpperCAmelCase :   Tuple    					=  ["""pixel_values"""]
								self.assertListEqual(arg_names[:1]			,							__UpperCAmelCase					)





		def 				__A							(  self					)							->  Dict:

					'''simple docstring'''
					__UpperCAmelCase :   Dict    					=  self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*__UpperCAmelCase					)





		@unittest.skipIf(
		    not is_tf_available() or len(tf.config.list_physical_devices("""GPU"""					)					) == 0			,							reason="""TF does not support backprop for grouped convolutions on CPU."""			,							)
		def 				__A							(  self					)							->  Union[str, Any]:

					'''simple docstring'''
					super().test_dataset_conversion()





		def 				__A							(  self					)							->  Optional[int]:

					'''simple docstring'''
					def check_hidden_states_output(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase					):
								__UpperCAmelCase :   Optional[int]    					=  model_class(__UpperCAmelCase					)

								__UpperCAmelCase :   str    					=  model(**self._prepare_for_class(__UpperCAmelCase			,							__UpperCAmelCase					)					)
								__UpperCAmelCase :   List[str]    					=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

								__UpperCAmelCase :   Optional[int]    					=  self.model_tester.num_stages
								self.assertEqual(len(__UpperCAmelCase					)			,							expected_num_stages + 1					)

								# ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
								self.assertListEqual(
								    list(hidden_states[0].shape[-2:]					)			,							[self.model_tester.image_size // 4, self.model_tester.image_size // 4]			,							)

					__UpperCAmelCase					,	__UpperCAmelCase :   Union[str, Any]    					=  self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
								__UpperCAmelCase :   List[str]    					=  True
								check_hidden_states_output(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase					)

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

								check_hidden_states_output(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase					)





		def 				__A							(  self					)							->  Tuple:

					'''simple docstring'''
					__UpperCAmelCase					,	__UpperCAmelCase :   Any    					=  self.model_tester.prepare_config_and_inputs_for_common()

					def check_equivalence(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase={}					):
								__UpperCAmelCase :   Optional[Any]    					=  model(__UpperCAmelCase			,							return_dict=__UpperCAmelCase			,							**__UpperCAmelCase					)
								__UpperCAmelCase :   Optional[int]    					=  model(__UpperCAmelCase			,							return_dict=__UpperCAmelCase			,							**__UpperCAmelCase					).to_tuple()

								def recursive_check(__UpperCAmelCase			,							__UpperCAmelCase					):
											if isinstance(__UpperCAmelCase			,							(List, Tuple)					):
														for tuple_iterable_value, dict_iterable_value in zip(__UpperCAmelCase			,							__UpperCAmelCase					):
																	recursive_check(__UpperCAmelCase			,							__UpperCAmelCase					)
											elif tuple_object is None:
														return
											else:
														self.assertTrue(
														    all(tf.equal(__UpperCAmelCase			,							__UpperCAmelCase					)					)			,							msg=(
														        """Tuple and dict output are not equal. Difference:"""
														        f' {tf.math.reduce_max(tf.abs(tuple_object - dict_object					)					)}'
														    )			,							)

											recursive_check(__UpperCAmelCase			,							__UpperCAmelCase					)

					for model_class in self.all_model_classes:
								__UpperCAmelCase :   Dict    					=  model_class(__UpperCAmelCase					)

								__UpperCAmelCase :   Optional[int]    					=  self._prepare_for_class(__UpperCAmelCase			,							__UpperCAmelCase					)
								__UpperCAmelCase :   Tuple    					=  self._prepare_for_class(__UpperCAmelCase			,							__UpperCAmelCase					)
								check_equivalence(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase					)

								__UpperCAmelCase :   Union[str, Any]    					=  self._prepare_for_class(__UpperCAmelCase			,							__UpperCAmelCase			,							return_labels=__UpperCAmelCase					)
								__UpperCAmelCase :   Union[str, Any]    					=  self._prepare_for_class(__UpperCAmelCase			,							__UpperCAmelCase			,							return_labels=__UpperCAmelCase					)
								check_equivalence(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase					)

								__UpperCAmelCase :   Optional[Any]    					=  self._prepare_for_class(__UpperCAmelCase			,							__UpperCAmelCase					)
								__UpperCAmelCase :   List[str]    					=  self._prepare_for_class(__UpperCAmelCase			,							__UpperCAmelCase					)
								check_equivalence(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							{"""output_hidden_states""": True}					)

								__UpperCAmelCase :   List[Any]    					=  self._prepare_for_class(__UpperCAmelCase			,							__UpperCAmelCase			,							return_labels=__UpperCAmelCase					)
								__UpperCAmelCase :   Dict    					=  self._prepare_for_class(__UpperCAmelCase			,							__UpperCAmelCase			,							return_labels=__UpperCAmelCase					)
								check_equivalence(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							{"""output_hidden_states""": True}					)





		def 				__A							(  self					)							->  Tuple:

					'''simple docstring'''
					__UpperCAmelCase :   int    					=  self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase					)





		@slow
		def 				__A							(  self					)							->  Tuple:

					'''simple docstring'''
					__UpperCAmelCase :   Union[str, Any]    					=  TFConvNextModel.from_pretrained("""facebook/convnext-tiny-224"""					)
					self.assertIsNotNone(__UpperCAmelCase					)


def 	lowercase_						( ):

			"""simple docstring"""





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






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





		@cached_property
		def 				__A							(  self					)							->  Any:

					'''simple docstring'''
					return ConvNextImageProcessor.from_pretrained("""facebook/convnext-tiny-224"""					) if is_vision_available() else None





		@slow
		def 				__A							(  self					)							->  int:

					'''simple docstring'''
					__UpperCAmelCase :   Tuple    					=  TFConvNextForImageClassification.from_pretrained("""facebook/convnext-tiny-224"""					)

					__UpperCAmelCase :   List[Any]    					=  self.default_image_processor
					__UpperCAmelCase :   int    					=  prepare_img()
					__UpperCAmelCase :   Optional[Any]    					=  image_processor(images=__UpperCAmelCase			,							return_tensors="""tf"""					)

					# forward pass
					__UpperCAmelCase :   List[Any]    					=  model(**__UpperCAmelCase					)

					# verify the logits
					__UpperCAmelCase :   List[str]    					=  tf.TensorShape((1, 1_000)					)
					self.assertEqual(outputs.logits.shape			,							__UpperCAmelCase					)

					__UpperCAmelCase :   str    					=  tf.constant([-0.0260, -0.4739, 0.1911]					)

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




