

'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


lowerCAmelCase_     =      {
    "auto_factory": ["get_values"],
    "configuration_auto": ["ALL_PRETRAINED_CONFIG_ARCHIVE_MAP", "CONFIG_MAPPING", "MODEL_NAMES_MAPPING", "AutoConfig"],
    "feature_extraction_auto": ["FEATURE_EXTRACTOR_MAPPING", "AutoFeatureExtractor"],
    "image_processing_auto": ["IMAGE_PROCESSOR_MAPPING", "AutoImageProcessor"],
    "processing_auto": ["PROCESSOR_MAPPING", "AutoProcessor"],
    "tokenization_auto": ["TOKENIZER_MAPPING", "AutoTokenizer"],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase_     =      [
						    "MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_AUDIO_XVECTOR_MAPPING",
						    "MODEL_FOR_BACKBONE_MAPPING",
						    "MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING",
						    "MODEL_FOR_CAUSAL_LM_MAPPING",
						    "MODEL_FOR_CTC_MAPPING",
						    "MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING",
						    "MODEL_FOR_DEPTH_ESTIMATION_MAPPING",
						    "MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_IMAGE_SEGMENTATION_MAPPING",
						    "MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING",
						    "MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING",
						    "MODEL_FOR_MASKED_LM_MAPPING",
						    "MODEL_FOR_MASK_GENERATION_MAPPING",
						    "MODEL_FOR_MULTIPLE_CHOICE_MAPPING",
						    "MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING",
						    "MODEL_FOR_OBJECT_DETECTION_MAPPING",
						    "MODEL_FOR_PRETRAINING_MAPPING",
						    "MODEL_FOR_QUESTION_ANSWERING_MAPPING",
						    "MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING",
						    "MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING",
						    "MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING",
						    "MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING",
						    "MODEL_FOR_TEXT_ENCODING_MAPPING",
						    "MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING",
						    "MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_VISION_2_SEQ_MAPPING",
						    "MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING",
						    "MODEL_MAPPING",
						    "MODEL_WITH_LM_HEAD_MAPPING",
						    "MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING",
						    "AutoModel",
						    "AutoBackbone",
						    "AutoModelForAudioClassification",
						    "AutoModelForAudioFrameClassification",
						    "AutoModelForAudioXVector",
						    "AutoModelForCausalLM",
						    "AutoModelForCTC",
						    "AutoModelForDepthEstimation",
						    "AutoModelForImageClassification",
						    "AutoModelForImageSegmentation",
						    "AutoModelForInstanceSegmentation",
						    "AutoModelForMaskGeneration",
						    "AutoModelForTextEncoding",
						    "AutoModelForMaskedImageModeling",
						    "AutoModelForMaskedLM",
						    "AutoModelForMultipleChoice",
						    "AutoModelForNextSentencePrediction",
						    "AutoModelForObjectDetection",
						    "AutoModelForPreTraining",
						    "AutoModelForQuestionAnswering",
						    "AutoModelForSemanticSegmentation",
						    "AutoModelForSeq2SeqLM",
						    "AutoModelForSequenceClassification",
						    "AutoModelForSpeechSeq2Seq",
						    "AutoModelForTableQuestionAnswering",
						    "AutoModelForTokenClassification",
						    "AutoModelForUniversalSegmentation",
						    "AutoModelForVideoClassification",
						    "AutoModelForVision2Seq",
						    "AutoModelForVisualQuestionAnswering",
						    "AutoModelForDocumentQuestionAnswering",
						    "AutoModelWithLMHead",
						    "AutoModelForZeroShotImageClassification",
						    "AutoModelForZeroShotObjectDetection",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase_     =      [
						    "TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING",
						    "TF_MODEL_FOR_CAUSAL_LM_MAPPING",
						    "TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING",
						    "TF_MODEL_FOR_MASK_GENERATION_MAPPING",
						    "TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING",
						    "TF_MODEL_FOR_MASKED_LM_MAPPING",
						    "TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING",
						    "TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING",
						    "TF_MODEL_FOR_PRETRAINING_MAPPING",
						    "TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING",
						    "TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING",
						    "TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING",
						    "TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING",
						    "TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING",
						    "TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING",
						    "TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING",
						    "TF_MODEL_FOR_TEXT_ENCODING_MAPPING",
						    "TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING",
						    "TF_MODEL_FOR_VISION_2_SEQ_MAPPING",
						    "TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING",
						    "TF_MODEL_MAPPING",
						    "TF_MODEL_WITH_LM_HEAD_MAPPING",
						    "TFAutoModel",
						    "TFAutoModelForAudioClassification",
						    "TFAutoModelForCausalLM",
						    "TFAutoModelForImageClassification",
						    "TFAutoModelForMaskedImageModeling",
						    "TFAutoModelForMaskedLM",
						    "TFAutoModelForMaskGeneration",
						    "TFAutoModelForMultipleChoice",
						    "TFAutoModelForNextSentencePrediction",
						    "TFAutoModelForPreTraining",
						    "TFAutoModelForDocumentQuestionAnswering",
						    "TFAutoModelForQuestionAnswering",
						    "TFAutoModelForSemanticSegmentation",
						    "TFAutoModelForSeq2SeqLM",
						    "TFAutoModelForSequenceClassification",
						    "TFAutoModelForSpeechSeq2Seq",
						    "TFAutoModelForTableQuestionAnswering",
						    "TFAutoModelForTextEncoding",
						    "TFAutoModelForTokenClassification",
						    "TFAutoModelForVision2Seq",
						    "TFAutoModelForZeroShotImageClassification",
						    "TFAutoModelWithLMHead",
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase_     =      [
						    "FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING",
						    "FLAX_MODEL_FOR_CAUSAL_LM_MAPPING",
						    "FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING",
						    "FLAX_MODEL_FOR_MASKED_LM_MAPPING",
						    "FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING",
						    "FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING",
						    "FLAX_MODEL_FOR_PRETRAINING_MAPPING",
						    "FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING",
						    "FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING",
						    "FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING",
						    "FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING",
						    "FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING",
						    "FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING",
						    "FLAX_MODEL_MAPPING",
						    "FlaxAutoModel",
						    "FlaxAutoModelForCausalLM",
						    "FlaxAutoModelForImageClassification",
						    "FlaxAutoModelForMaskedLM",
						    "FlaxAutoModelForMultipleChoice",
						    "FlaxAutoModelForNextSentencePrediction",
						    "FlaxAutoModelForPreTraining",
						    "FlaxAutoModelForQuestionAnswering",
						    "FlaxAutoModelForSeq2SeqLM",
						    "FlaxAutoModelForSequenceClassification",
						    "FlaxAutoModelForSpeechSeq2Seq",
						    "FlaxAutoModelForTokenClassification",
						    "FlaxAutoModelForVision2Seq",
						]


if TYPE_CHECKING:
						from .auto_factory import get_values
						from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, MODEL_NAMES_MAPPING, AutoConfig
						from .feature_extraction_auto import FEATURE_EXTRACTOR_MAPPING, AutoFeatureExtractor
						from .image_processing_auto import IMAGE_PROCESSOR_MAPPING, AutoImageProcessor
						from .processing_auto import PROCESSOR_MAPPING, AutoProcessor
						from .tokenization_auto import TOKENIZER_MAPPING, AutoTokenizer

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_auto import (
												    MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
												    MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING,
												    MODEL_FOR_AUDIO_XVECTOR_MAPPING,
												    MODEL_FOR_BACKBONE_MAPPING,
												    MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
												    MODEL_FOR_CAUSAL_LM_MAPPING,
												    MODEL_FOR_CTC_MAPPING,
												    MODEL_FOR_DEPTH_ESTIMATION_MAPPING,
												    MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
												    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
												    MODEL_FOR_IMAGE_SEGMENTATION_MAPPING,
												    MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING,
												    MODEL_FOR_MASK_GENERATION_MAPPING,
												    MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
												    MODEL_FOR_MASKED_LM_MAPPING,
												    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
												    MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
												    MODEL_FOR_OBJECT_DETECTION_MAPPING,
												    MODEL_FOR_PRETRAINING_MAPPING,
												    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
												    MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
												    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
												    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
												    MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
												    MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
												    MODEL_FOR_TEXT_ENCODING_MAPPING,
												    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
												    MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING,
												    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
												    MODEL_FOR_VISION_2_SEQ_MAPPING,
												    MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING,
												    MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
												    MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING,
												    MODEL_MAPPING,
												    MODEL_WITH_LM_HEAD_MAPPING,
												    AutoBackbone,
												    AutoModel,
												    AutoModelForAudioClassification,
												    AutoModelForAudioFrameClassification,
												    AutoModelForAudioXVector,
												    AutoModelForCausalLM,
												    AutoModelForCTC,
												    AutoModelForDepthEstimation,
												    AutoModelForDocumentQuestionAnswering,
												    AutoModelForImageClassification,
												    AutoModelForImageSegmentation,
												    AutoModelForInstanceSegmentation,
												    AutoModelForMaskedImageModeling,
												    AutoModelForMaskedLM,
												    AutoModelForMaskGeneration,
												    AutoModelForMultipleChoice,
												    AutoModelForNextSentencePrediction,
												    AutoModelForObjectDetection,
												    AutoModelForPreTraining,
												    AutoModelForQuestionAnswering,
												    AutoModelForSemanticSegmentation,
												    AutoModelForSeqaSeqLM,
												    AutoModelForSequenceClassification,
												    AutoModelForSpeechSeqaSeq,
												    AutoModelForTableQuestionAnswering,
												    AutoModelForTextEncoding,
												    AutoModelForTokenClassification,
												    AutoModelForUniversalSegmentation,
												    AutoModelForVideoClassification,
												    AutoModelForVisionaSeq,
												    AutoModelForVisualQuestionAnswering,
												    AutoModelForZeroShotImageClassification,
												    AutoModelForZeroShotObjectDetection,
												    AutoModelWithLMHead,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_auto import (
												    TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
												    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
												    TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
												    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
												    TF_MODEL_FOR_MASK_GENERATION_MAPPING,
												    TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
												    TF_MODEL_FOR_MASKED_LM_MAPPING,
												    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
												    TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
												    TF_MODEL_FOR_PRETRAINING_MAPPING,
												    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
												    TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
												    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
												    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
												    TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
												    TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
												    TF_MODEL_FOR_TEXT_ENCODING_MAPPING,
												    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
												    TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
												    TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
												    TF_MODEL_MAPPING,
												    TF_MODEL_WITH_LM_HEAD_MAPPING,
												    TFAutoModel,
												    TFAutoModelForAudioClassification,
												    TFAutoModelForCausalLM,
												    TFAutoModelForDocumentQuestionAnswering,
												    TFAutoModelForImageClassification,
												    TFAutoModelForMaskedImageModeling,
												    TFAutoModelForMaskedLM,
												    TFAutoModelForMaskGeneration,
												    TFAutoModelForMultipleChoice,
												    TFAutoModelForNextSentencePrediction,
												    TFAutoModelForPreTraining,
												    TFAutoModelForQuestionAnswering,
												    TFAutoModelForSemanticSegmentation,
												    TFAutoModelForSeqaSeqLM,
												    TFAutoModelForSequenceClassification,
												    TFAutoModelForSpeechSeqaSeq,
												    TFAutoModelForTableQuestionAnswering,
												    TFAutoModelForTextEncoding,
												    TFAutoModelForTokenClassification,
												    TFAutoModelForVisionaSeq,
												    TFAutoModelForZeroShotImageClassification,
												    TFAutoModelWithLMHead,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_auto import (
												    FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
												    FLAX_MODEL_FOR_CAUSAL_LM_MAPPING,
												    FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
												    FLAX_MODEL_FOR_MASKED_LM_MAPPING,
												    FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
												    FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
												    FLAX_MODEL_FOR_PRETRAINING_MAPPING,
												    FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
												    FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
												    FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
												    FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
												    FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
												    FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING,
												    FLAX_MODEL_MAPPING,
												    FlaxAutoModel,
												    FlaxAutoModelForCausalLM,
												    FlaxAutoModelForImageClassification,
												    FlaxAutoModelForMaskedLM,
												    FlaxAutoModelForMultipleChoice,
												    FlaxAutoModelForNextSentencePrediction,
												    FlaxAutoModelForPreTraining,
												    FlaxAutoModelForQuestionAnswering,
												    FlaxAutoModelForSeqaSeqLM,
												    FlaxAutoModelForSequenceClassification,
												    FlaxAutoModelForSpeechSeqaSeq,
												    FlaxAutoModelForTokenClassification,
												    FlaxAutoModelForVisionaSeq,
												)

else:
						import sys

						lowerCAmelCase_     =      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)








'''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 lowerCamelCase   :

				def __init__(       self,						lowercase_,						lowercase_=13,						lowercase_=32,						lowercase_=3,						lowercase_=4,						lowercase_=[10, 20, 30, 40],						lowercase_=[2, 2, 3, 2],						lowercase_=True,						lowercase_=True,						lowercase_=37,						lowercase_="gelu",						lowercase_=10,						lowercase_=0.02,						lowercase_=3,						lowercase_=None,						)    ->							Dict:
					snake_case							=					parent
					snake_case							=					batch_size
					snake_case							=					image_size
					snake_case							=					num_channels
					snake_case							=					num_stages
					snake_case							=					hidden_sizes
					snake_case							=					depths
					snake_case							=					is_training
					snake_case							=					use_labels
					snake_case							=					intermediate_size
					snake_case							=					hidden_act
					snake_case							=					type_sequence_label_size
					snake_case							=					initializer_range
					snake_case							=					scope

				def 					_lowerCamelCase    (       self )    ->							List[Any]:
					snake_case							=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

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

					snake_case							=					self.get_config()

					return config, pixel_values, labels

				def 					_lowerCamelCase    (       self )    ->							Any:
					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=lowercase_,						initializer_range=self.initializer_range,						)

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_ )    ->							List[Any]:
					snake_case							=					TFConvNextModel(config=lowercase_ )
					snake_case							=					model(lowercase_,						training=lowercase_ )
					# 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 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_ )    ->							Union[str, Any]:
					snake_case							=					self.type_sequence_label_size
					snake_case							=					TFConvNextForImageClassification(lowercase_ )
					snake_case							=					model(lowercase_,						labels=lowercase_,						training=lowercase_ )
					self.parent.assertEqual(result.logits.shape,						(self.batch_size, self.type_sequence_label_size) )






				def 					_lowerCamelCase    (       self )    ->							Optional[int]:
					snake_case							=					self.prepare_config_and_inputs()
					snake_case			,			snake_case			,			snake_case							=					config_and_inputs
					snake_case							=					{'pixel_values': pixel_values}
					return config, inputs_dict







@require_tf
class lowerCamelCase   (    __lowerCAmelCase				,				__lowerCAmelCase				,				unittest.TestCase				):
				snake_case_							     = (TFConvNextModel, TFConvNextForImageClassification) if is_tf_available() else ()
				snake_case_							     = (
				    {'''feature-extraction''': TFConvNextModel, '''image-classification''': TFConvNextForImageClassification}
				    if is_tf_available()
				    else {}
				)

				snake_case_							     = False
				snake_case_							     = False
				snake_case_							     = False
				snake_case_							     = False
				snake_case_							     = False

				def 					_lowerCamelCase    (       self )    ->							str:
					snake_case							=					TFConvNextModelTester(self )
					snake_case							=					ConfigTester(
					    self,						config_class=lowercase_,						has_text_modality=lowercase_,						hidden_size=37,						)

				@unittest.skip(reason='ConvNext does not use inputs_embeds' )
				def 					_lowerCamelCase    (       self )    ->							Tuple:
					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 					_lowerCamelCase    (       self )    ->							Optional[Any]:
					super().test_keras_fit()

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

				def 					_lowerCamelCase    (       self )    ->							List[Any]:
					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()

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

						snake_case							=					['pixel_values']
						self.assertListEqual(arg_names[:1],						lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							str:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*lowercase_ )

				@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 					_lowerCamelCase    (       self )    ->							Optional[int]:
					super().test_dataset_conversion()

				def 					_lowerCamelCase    (       self )    ->							Union[str, Any]:
					def check_hidden_states_output(lowercase_,						lowercase_,						lowercase_ ):
						snake_case							=					model_class(lowercase_ )

						snake_case							=					model(**self._prepare_for_class(lowercase_,						lowercase_ ) )
						snake_case							=					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

						snake_case							=					self.model_tester.num_stages
						self.assertEqual(len(lowercase_ ),						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],						)

					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						snake_case							=					True
						check_hidden_states_output(lowercase_,						lowercase_,						lowercase_ )

						# check that output_hidden_states also work using config
						del inputs_dict["output_hidden_states"]
						snake_case							=					True

						check_hidden_states_output(lowercase_,						lowercase_,						lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							Dict:
					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()

					def check_equivalence(lowercase_,						lowercase_,						lowercase_,						lowercase_={} ):
						snake_case							=					model(lowercase_,						return_dict=lowercase_,						**lowercase_ )
						snake_case							=					model(lowercase_,						return_dict=lowercase_,						**lowercase_ ).to_tuple()

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

							recursive_check(lowercase_,						lowercase_ )

					for model_class in self.all_model_classes:
						snake_case							=					model_class(lowercase_ )

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						check_equivalence(lowercase_,						lowercase_,						lowercase_ )

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_,						return_labels=lowercase_ )
						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_,						return_labels=lowercase_ )
						check_equivalence(lowercase_,						lowercase_,						lowercase_ )

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						check_equivalence(lowercase_,						lowercase_,						lowercase_,						{'output_hidden_states': True} )

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_,						return_labels=lowercase_ )
						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_,						return_labels=lowercase_ )
						check_equivalence(lowercase_,						lowercase_,						lowercase_,						{'output_hidden_states': True} )

				def 					_lowerCamelCase    (       self )    ->							List[str]:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*lowercase_ )






				@slow
				def 					_lowerCamelCase    (       self )    ->							str:
					snake_case							=					TFConvNextModel.from_pretrained('facebook/convnext-tiny-224' )
					self.assertIsNotNone(lowercase_ )

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







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

				@cached_property
				def 					_lowerCamelCase    (       self )    ->							List[str]:
					return ConvNextImageProcessor.from_pretrained('facebook/convnext-tiny-224' ) if is_vision_available() else None






				@slow
				def 					_lowerCamelCase    (       self )    ->							Dict:
					snake_case							=					TFConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224' )

					snake_case							=					self.default_image_processor
					snake_case							=					prepare_img()
					snake_case							=					image_processor(images=lowercase_,						return_tensors='tf' )

					# forward pass
					snake_case							=					model(**lowercase_ )

					# verify the logits
					snake_case							=					tf.TensorShape((1, 1000) )
					self.assertEqual(outputs.logits.shape,						lowercase_ )

					snake_case							=					tf.constant([-0.0_260, -0.4_739, 0.1_911] )

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





