



'''simple docstring'''
import inspect
import os
from argparse import ArgumentParser, Namespace
from importlib import import_module

import huggingface_hub
import numpy as np
from packaging import version

from .. import (
    FEATURE_EXTRACTOR_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoImageProcessor,
    AutoProcessor,
    AutoTokenizer,
    is_datasets_available,
    is_tf_available,
    is_torch_available,
)
from ..utils import TF2_WEIGHTS_INDEX_NAME, TF2_WEIGHTS_NAME, logging
from . import BaseTransformersCLICommand


if is_tf_available():
					import tensorflow as tf

					tf.config.experimental.enable_tensor_float_aa_execution(False)

if is_torch_available():
					import torch

if is_datasets_available():
					from datasets import load_dataset


_UpperCamelCase									=      5e-5  # larger error tolerance than in our internal tests, to avoid flaky user-facing errors


def 	lowercase_						( lowerCAmelCase__						:	Namespace			):

			"""simple docstring"""





			return PTtoTFCommand(
			    args.model_name      ,				args.local_dir      ,				args.max_error      ,				args.new_weights      ,				args.no_pr      ,				args.push      ,				args.extra_commit_description      ,				args.override_model_class      ,				)






class _A	(     __SCREAMING_SNAKE_CASE     ):





		@staticmethod
		def 				__A							(  __UpperCAmelCase					)							->  Tuple:

					'''simple docstring'''
					__UpperCAmelCase :   Optional[int]    					=  parser.add_parser(
					    """pt-to-tf"""			,							help=(
					        """CLI tool to run convert a transformers model from a PyTorch checkpoint to a TensorFlow checkpoint."""
					        """ Can also be used to validate existing weights without opening PRs, with --no-pr."""
					    )			,							)
					train_parser.add_argument(
					    """--model-name"""			,							type=__UpperCAmelCase			,							required=__UpperCAmelCase			,							help="""The model name, including owner/organization, as seen on the hub."""			,							)
					train_parser.add_argument(
					    """--local-dir"""			,							type=__UpperCAmelCase			,							default=""""""			,							help="""Optional local directory of the model repository. Defaults to /tmp/{model_name}"""			,							)
					train_parser.add_argument(
					    """--max-error"""			,							type=__UpperCAmelCase			,							default=__UpperCAmelCase			,							help=(
					        f'Maximum error tolerance. Defaults to {MAX_ERROR}. This flag should be avoided, use at your own risk.'
					    )			,							)
					train_parser.add_argument(
					    """--new-weights"""			,							action="""store_true"""			,							help="""Optional flag to create new TensorFlow weights, even if they already exist."""			,							)
					train_parser.add_argument(
					    """--no-pr"""			,							action="""store_true"""			,							help="""Optional flag to NOT open a PR with converted weights."""					)
					train_parser.add_argument(
					    """--push"""			,							action="""store_true"""			,							help="""Optional flag to push the weights directly to `main` (requires permissions)"""			,							)
					train_parser.add_argument(
					    """--extra-commit-description"""			,							type=__UpperCAmelCase			,							default=""""""			,							help="""Optional additional commit description to use when opening a PR (e.g. to tag the owner)."""			,							)
					train_parser.add_argument(
					    """--override-model-class"""			,							type=__UpperCAmelCase			,							default=__UpperCAmelCase			,							help="""If you think you know better than the auto-detector, you can specify the model class here. """
					    """Can be either an AutoModel class or a specific model class like BertForSequenceClassification."""			,							)
					train_parser.set_defaults(func=__UpperCAmelCase					)





		@staticmethod
		def 				__A							(  __UpperCAmelCase			,							__UpperCAmelCase					)							->  Dict:

					'''simple docstring'''
					__UpperCAmelCase :   int    					=  set(pt_outputs.keys()					)
					__UpperCAmelCase :   str    					=  set(tf_outputs.keys()					)
					if pt_out_attrs != tf_out_attrs:
								raise ValueError(
								    f'The model outputs have different attributes, aborting. (Pytorch: {pt_out_attrs}, TensorFlow:'
								    f' {tf_out_attrs})'					)

					# 2. For each output attribute, computes the difference
					def _find_pt_tf_differences(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase=""					):
								# If the current attribute is a tensor, it is a leaf and we make the comparison. Otherwise, we will dig in
								# recursivelly, keeping the name of the attribute.
								if isinstance(__UpperCAmelCase			,							torch.Tensor					):
											__UpperCAmelCase :   int    					=  np.max(np.abs(pt_out.numpy() - tf_out.numpy()					)					)
											__UpperCAmelCase :   List[str]    					=  tensor_difference
								else:
											__UpperCAmelCase :   Tuple    					=  attr_name
											for i, pt_item in enumerate(__UpperCAmelCase					):
														# If it is a named attribute, we keep the name. Otherwise, just its index.
														if isinstance(__UpperCAmelCase			,							__UpperCAmelCase					):
																	__UpperCAmelCase :   Any    					=  root_name + pt_item
																	__UpperCAmelCase :   Union[str, Any]    					=  tf_out[pt_item]
																	__UpperCAmelCase :   List[Any]    					=  pt_out[pt_item]
														else:
																	__UpperCAmelCase :   str    					=  root_name + f'[{i}]'
																	__UpperCAmelCase :   List[str]    					=  tf_out[i]
														__UpperCAmelCase :   int    					=  _find_pt_tf_differences(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase					)

								return differences

					return _find_pt_tf_differences(__UpperCAmelCase			,							__UpperCAmelCase			,							{}					)





		def __init__(  self			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							*__UpperCAmelCase			,							)							->  Optional[Any]:

					'''simple docstring'''
					__UpperCAmelCase :   Optional[int]    					=  logging.get_logger("""transformers-cli/pt_to_tf"""					)
					__UpperCAmelCase :   Optional[int]    					=  model_name
					__UpperCAmelCase :   Optional[Any]    					=  local_dir if local_dir else os.path.join("""/tmp"""			,							__UpperCAmelCase					)
					__UpperCAmelCase :   List[str]    					=  max_error
					__UpperCAmelCase :   List[str]    					=  new_weights
					__UpperCAmelCase :   Tuple    					=  no_pr
					__UpperCAmelCase :   Optional[Any]    					=  push
					__UpperCAmelCase :   int    					=  extra_commit_description
					__UpperCAmelCase :   Tuple    					=  override_model_class





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

					'''simple docstring'''

					def _get_audio_input():
								__UpperCAmelCase :   str    					=  load_dataset("""hf-internal-testing/librispeech_asr_dummy"""			,							"""clean"""			,							split="""validation"""					)
								__UpperCAmelCase :   str    					=  ds.sort("""id"""					).select(range(2					)					)[:2]["""audio"""]
								__UpperCAmelCase :   int    					=  [x["""array"""] for x in speech_samples]
								return raw_samples

					__UpperCAmelCase :   Tuple    					=  type(pt_model.config					)
					if model_config_class in PROCESSOR_MAPPING:
								__UpperCAmelCase :   Optional[Any]    					=  AutoProcessor.from_pretrained(self._local_dir					)
								if model_config_class in TOKENIZER_MAPPING and processor.tokenizer.pad_token is None:
											__UpperCAmelCase :   Optional[Any]    					=  processor.tokenizer.eos_token
					elif model_config_class in IMAGE_PROCESSOR_MAPPING:
								__UpperCAmelCase :   Tuple    					=  AutoImageProcessor.from_pretrained(self._local_dir					)
					elif model_config_class in FEATURE_EXTRACTOR_MAPPING:
								__UpperCAmelCase :   int    					=  AutoFeatureExtractor.from_pretrained(self._local_dir					)
					elif model_config_class in TOKENIZER_MAPPING:
								__UpperCAmelCase :   Optional[int]    					=  AutoTokenizer.from_pretrained(self._local_dir					)
								if processor.pad_token is None:
											__UpperCAmelCase :   Optional[Any]    					=  processor.eos_token
					else:
								raise ValueError(f'Unknown data processing type (model config type: {model_config_class})'					)

					__UpperCAmelCase :   Tuple    					=  set(inspect.signature(pt_model.forward					).parameters.keys()					)
					__UpperCAmelCase :   Dict    					=  {}
					if "input_ids" in model_forward_signature:
								processor_inputs.update(
								    {
								        """text""": ["""Hi there!""", """I am a batch with more than one row and different input lengths."""],
								        """padding""": True,
								        """truncation""": True,
								    }					)
					if "pixel_values" in model_forward_signature:
								__UpperCAmelCase :   Optional[Any]    					=  load_dataset("""cifar10"""			,							"""plain_text"""			,							split="""test"""					)[:2]["""img"""]
								processor_inputs.update({"""images""": sample_images}					)
					if "input_features" in model_forward_signature:
								__UpperCAmelCase :   Optional[Any]    					=  inspect.signature(processor.feature_extractor					).parameters
								# Pad to the largest input length by default but take feature extractor default
								# padding value if it exists e.g. "max_length" and is not False or None
								if "padding" in feature_extractor_signature:
											__UpperCAmelCase :   Dict    					=  feature_extractor_signature["""padding"""].default
											if default_strategy is not False and default_strategy is not None:
														__UpperCAmelCase :   Optional[int]    					=  default_strategy
											else:
														__UpperCAmelCase :   Optional[int]    					=  True
								else:
											__UpperCAmelCase :   Optional[int]    					=  True
								processor_inputs.update({"""audio""": _get_audio_input(), """padding""": padding_strategy}					)
					if "input_values" in model_forward_signature:  # Wav2Vec2 audio input
								processor_inputs.update({"""audio""": _get_audio_input(), """padding""": True}					)
					__UpperCAmelCase :   Dict    					=  processor(**__UpperCAmelCase			,							return_tensors="""pt"""					)
					__UpperCAmelCase :   Optional[Any]    					=  processor(**__UpperCAmelCase			,							return_tensors="""tf"""					)

					# Extra input requirements, in addition to the input modality
					if (
					    config.is_encoder_decoder
					    or (hasattr(__UpperCAmelCase			,							"""encoder"""					) and hasattr(__UpperCAmelCase			,							"""decoder"""					))
					    or "decoder_input_ids" in tf_dummy_inputs
					):
								__UpperCAmelCase :   Union[str, Any]    					=  np.asarray([[1], [1]]			,							dtype=__UpperCAmelCase					) * (pt_model.config.decoder_start_token_id or 0)
								pt_input.update({"""decoder_input_ids""": torch.tensor(__UpperCAmelCase					)}					)
								tf_input.update({"""decoder_input_ids""": tf.convert_to_tensor(__UpperCAmelCase					)}					)

					return pt_input, tf_input





		def 				__A							(  self					)							->  int:

					'''simple docstring'''
					# hub version 0.9.0 introduced the possibility of programmatically opening PRs with normal write tokens.
					if version.parse(huggingface_hub.__version__					) < version.parse("""0.9.0"""					):
								raise ImportError(
								    """The huggingface_hub version must be >= 0.9.0 to use this command. Please update your huggingface_hub"""
								    """ installation."""					)
					else:
								from huggingface_hub import Repository, create_commit
								from huggingface_hub._commit_api import CommitOperationAdd

					# Fetch remote data
					__UpperCAmelCase :   Any    					=  Repository(local_dir=self._local_dir			,							clone_from=self._model_name					)

					# Load config and get the appropriate architecture -- the latter is needed to convert the head's weights
					__UpperCAmelCase :   str    					=  AutoConfig.from_pretrained(self._local_dir					)
					__UpperCAmelCase :   Dict    					=  config.architectures
					if self._override_model_class is not None:
								if self._override_model_class.startswith("""TF"""					):
											__UpperCAmelCase :   Union[str, Any]    					=  [self._override_model_class[2:]]
								else:
											__UpperCAmelCase :   Tuple    					=  [self._override_model_class]
								try:
											__UpperCAmelCase :   Any    					=  getattr(import_module("""transformers"""					)			,							architectures[0]					)
								except AttributeError:
											raise ValueError(f'Model class {self._override_model_class} not found in transformers.'					)
								try:
											__UpperCAmelCase :   int    					=  getattr(import_module("""transformers"""					)			,							"""TF""" + architectures[0]					)
								except AttributeError:
											raise ValueError(f'TF model class TF{self._override_model_class} not found in transformers.'					)
					elif architectures is None:  # No architecture defined -- use auto classes
								__UpperCAmelCase :   int    					=  getattr(import_module("""transformers"""					)			,							"""AutoModel"""					)
								__UpperCAmelCase :   List[str]    					=  getattr(import_module("""transformers"""					)			,							"""TFAutoModel"""					)
								self._logger.warning("""No detected architecture, using AutoModel/TFAutoModel"""					)
					else:  # Architecture defined -- use it
								if len(__UpperCAmelCase					) > 1:
											raise ValueError(f'More than one architecture was found, aborting. (architectures = {architectures})'					)
								self._logger.warning(f'Detected architecture: {architectures[0]}'					)
								__UpperCAmelCase :   str    					=  getattr(import_module("""transformers"""					)			,							architectures[0]					)
								try:
											__UpperCAmelCase :   Optional[Any]    					=  getattr(import_module("""transformers"""					)			,							"""TF""" + architectures[0]					)
								except AttributeError:
											raise AttributeError(f'The TensorFlow equivalent of {architectures[0]} doesn\'t exist in transformers.'					)

        # Check the TF dummy inputs to see what keys we need in the forward pass
					__UpperCAmelCase :   List[Any]    					=  tf_class.from_config(__UpperCAmelCase					)
					__UpperCAmelCase :   int    					=  tf_from_pt_model.dummy_inputs

					del tf_from_pt_model  # Try to keep only one model in memory at a time

					# Load the model and get some basic inputs
					__UpperCAmelCase :   str    					=  pt_class.from_pretrained(self._local_dir					)
					pt_model.eval()

					__UpperCAmelCase					,	__UpperCAmelCase :   Optional[Any]    					=  self.get_inputs(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase					)

					with torch.no_grad():
								__UpperCAmelCase :   Dict    					=  pt_model(**__UpperCAmelCase			,							output_hidden_states=__UpperCAmelCase					)
					del pt_model  # will no longer be used, and may have a large memory footprint

					__UpperCAmelCase :   List[str]    					=  tf_class.from_pretrained(self._local_dir			,							from_pt=__UpperCAmelCase					)
					__UpperCAmelCase :   Tuple    					=  tf_from_pt_model(**__UpperCAmelCase			,							output_hidden_states=__UpperCAmelCase			,							training=__UpperCAmelCase					)

					# Confirms that cross loading PT weights into TF worked.
					__UpperCAmelCase :   Tuple    					=  self.find_pt_tf_differences(__UpperCAmelCase			,							__UpperCAmelCase					)
					__UpperCAmelCase :   Tuple    					=  {k: v for k, v in crossload_differences.items() if """hidden""" not in k}
					__UpperCAmelCase :   Union[str, Any]    					=  {k: v for k, v in crossload_differences.items() if """hidden""" in k}
					if len(__UpperCAmelCase					) == 0 and architectures is not None:
								raise ValueError(
								    f'Something went wrong -- the config file has architectures ({architectures}), but no model head'
								    """ output was found. All outputs start with 'hidden'"""					)
					__UpperCAmelCase :   Tuple    					=  max(output_differences.values()					) if output_differences else 0.0
					__UpperCAmelCase :   str    					=  max(hidden_differences.values()					)
					if max_crossload_output_diff > self._max_error or max_crossload_hidden_diff > self._max_error:
								raise ValueError(
								    """The cross-loaded TensorFlow model has different outputs, something went wrong!\n"""
								    + f'\nList of maximum output differences above the threshold ({self._max_error}):\n'
								    + """\n""".join([f'{k}: {v:.3e}' for k, v in output_differences.items() if v > self._max_error]					)
								    + f'\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'
								    + """\n""".join([f'{k}: {v:.3e}' for k, v in hidden_differences.items() if v > self._max_error]					)					)

					# Save the weights in a TF format (if needed) and confirms that the results are still good
					__UpperCAmelCase :   List[str]    					=  os.path.join(self._local_dir			,							__UpperCAmelCase					)
					__UpperCAmelCase :   Optional[Any]    					=  os.path.join(self._local_dir			,							__UpperCAmelCase					)
					if (not os.path.exists(__UpperCAmelCase					) and not os.path.exists(__UpperCAmelCase					)) or self._new_weights:
								tf_from_pt_model.save_pretrained(self._local_dir					)
					del tf_from_pt_model  # will no longer be used, and may have a large memory footprint

					__UpperCAmelCase :   Union[str, Any]    					=  tf_class.from_pretrained(self._local_dir					)
					__UpperCAmelCase :   List[Any]    					=  tf_model(**__UpperCAmelCase			,							output_hidden_states=__UpperCAmelCase					)

					__UpperCAmelCase :   Tuple    					=  self.find_pt_tf_differences(__UpperCAmelCase			,							__UpperCAmelCase					)
					__UpperCAmelCase :   Any    					=  {k: v for k, v in conversion_differences.items() if """hidden""" not in k}
					__UpperCAmelCase :   Any    					=  {k: v for k, v in conversion_differences.items() if """hidden""" in k}
					if len(__UpperCAmelCase					) == 0 and architectures is not None:
								raise ValueError(
								    f'Something went wrong -- the config file has architectures ({architectures}), but no model head'
								    """ output was found. All outputs start with 'hidden'"""					)
					__UpperCAmelCase :   List[Any]    					=  max(output_differences.values()					) if output_differences else 0.0
					__UpperCAmelCase :   Optional[Any]    					=  max(hidden_differences.values()					)
					if max_conversion_output_diff > self._max_error or max_conversion_hidden_diff > self._max_error:
								raise ValueError(
								    """The converted TensorFlow model has different outputs, something went wrong!\n"""
								    + f'\nList of maximum output differences above the threshold ({self._max_error}):\n'
								    + """\n""".join([f'{k}: {v:.3e}' for k, v in output_differences.items() if v > self._max_error]					)
								    + f'\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'
								    + """\n""".join([f'{k}: {v:.3e}' for k, v in hidden_differences.items() if v > self._max_error]					)					)

					__UpperCAmelCase :   int    					=  """Update TF weights""" if self._new_weights else """Add TF weights"""
					if self._push:
								repo.git_add(auto_lfs_track=__UpperCAmelCase					)
								repo.git_commit(__UpperCAmelCase					)
								repo.git_push(blocking=__UpperCAmelCase					)  # this prints a progress bar with the upload
								self._logger.warning(f'TF weights pushed into {self._model_name}'					)
					elif not self._no_pr:
								self._logger.warning("""Uploading the weights into a new PR..."""					)
								__UpperCAmelCase :   Tuple    					=  (
								    """Model converted by the [`transformers`' `pt_to_tf`"""
								    """ CLI](https://github.com/huggingface/transformers/blob/main/src/transformers/commands/pt_to_tf.py). """
								    """All converted model outputs and hidden layers were validated against its PyTorch counterpart.\n\n"""
								    f'Maximum crossload output difference={max_crossload_output_diff:.3e}; '
								    f'Maximum crossload hidden layer difference={max_crossload_hidden_diff:.3e};\n'
								    f'Maximum conversion output difference={max_conversion_output_diff:.3e}; '
								    f'Maximum conversion hidden layer difference={max_conversion_hidden_diff:.3e};\n'
								)
								if self._max_error > MAX_ERROR:
											commit_descrition += (
											    f'\n\nCAUTION: The maximum admissible error was manually increased to {self._max_error}!'
											)
								if self._extra_commit_description:
											commit_descrition += "\n\n" + self._extra_commit_description

								# sharded model -> adds all related files (index and .h5 shards)
								if os.path.exists(__UpperCAmelCase					):
											__UpperCAmelCase :   Dict    					=  [
											    CommitOperationAdd(path_in_repo=__UpperCAmelCase			,							path_or_fileobj=__UpperCAmelCase					)
											]
											for shard_path in tf.io.gfile.glob(self._local_dir + """/tf_model-*.h5"""					):
														operations += [
														    CommitOperationAdd(path_in_repo=os.path.basename(__UpperCAmelCase					)			,							path_or_fileobj=__UpperCAmelCase					)
														]
								else:
											__UpperCAmelCase :   Optional[Any]    					=  [CommitOperationAdd(path_in_repo=__UpperCAmelCase			,							path_or_fileobj=__UpperCAmelCase					)]

								__UpperCAmelCase :   Optional[int]    					=  create_commit(
								    repo_id=self._model_name			,							operations=__UpperCAmelCase			,							commit_message=__UpperCAmelCase			,							commit_description=__UpperCAmelCase			,							repo_type="""model"""			,							create_pr=__UpperCAmelCase			,							).pr_url
								self._logger.warning(f'PR open in {hub_pr_url}'					)









'''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					)




