






import math

import torch
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from .attention_processor import Attention
from .embeddings import get_timestep_embedding
from .modeling_utils import ModelMixin
class 		SCREAMING_SNAKE_CASE__	(  UpperCAmelCase					,      UpperCAmelCase     ):

  '''simple docstring'''







  @register_to_config
  def __init__(      self		:			Dict       ,				lowerCamelCase		:			int = 128       ,				lowerCamelCase		:			int = 256       ,				lowerCamelCase		:			float = 2000.0       ,				lowerCamelCase		:			int = 768       ,				lowerCamelCase		:			int = 12       ,				lowerCamelCase		:			int = 12       ,				lowerCamelCase		:			int = 64       ,				lowerCamelCase		:			int = 2048       ,				lowerCamelCase		:			float = 0.1       ,				)						->	Tuple:


         """simple docstring"""
         super().__init__()

         _UpperCAmelCase							=    nn.Sequential(
             nn.Linear(lowerCamelCase       ,				d_model * 4       ,				bias=lowerCamelCase							)       ,				nn.SiLU()       ,				nn.Linear(d_model * 4       ,				d_model * 4       ,				bias=lowerCamelCase							)       ,				nn.SiLU()       ,				)

         _UpperCAmelCase							=    nn.Embedding(lowerCamelCase       ,				lowerCamelCase							)
         _UpperCAmelCase							=    False

         _UpperCAmelCase							=    nn.Linear(lowerCamelCase       ,				lowerCamelCase       ,				bias=lowerCamelCase							)

         _UpperCAmelCase							=    nn.Dropout(p=lowerCamelCase							)

         _UpperCAmelCase							=    nn.ModuleList()
         for lyr_num in range(lowerCamelCase							):
                # FiLM conditional T5 decoder
                _UpperCAmelCase							=    DecoderLayer(d_model=lowerCamelCase       ,				d_kv=lowerCamelCase       ,				num_heads=lowerCamelCase       ,				d_ff=lowerCamelCase       ,				dropout_rate=lowerCamelCase							)
                self.decoders.append(lowerCamelCase							)

         _UpperCAmelCase							=    TaLayerNorm(lowerCamelCase							)

         _UpperCAmelCase							=    nn.Dropout(p=lowerCamelCase							)
         _UpperCAmelCase							=    nn.Linear(lowerCamelCase       ,				lowerCamelCase       ,				bias=lowerCamelCase							)


  def  lowerCamelCase       (      self		:			int       ,				lowerCamelCase		:			Optional[Any]       ,				lowerCamelCase		:			int							)						->	List[str]:


         """simple docstring"""
         _UpperCAmelCase							=    torch.mul(query_input.unsqueeze(-1							)       ,				key_input.unsqueeze(-2							)							)
         return mask.unsqueeze(-3							)





  def  lowerCamelCase       (      self		:			List[Any]       ,				lowerCamelCase		:			List[Any]       ,				lowerCamelCase		:			Dict       ,				lowerCamelCase		:			int							)						->	Any:


         """simple docstring"""
         _UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase							=    decoder_input_tokens.shape
         assert decoder_noise_time.shape == (batch,)

         # decoder_noise_time is in [0, 1), so rescale to expected timing range.
         _UpperCAmelCase							=    get_timestep_embedding(
             decoder_noise_time * self.config.max_decoder_noise_time       ,				embedding_dim=self.config.d_model       ,				max_period=self.config.max_decoder_noise_time       ,				).to(dtype=self.dtype							)

         _UpperCAmelCase							=    self.conditioning_emb(lowerCamelCase							).unsqueeze(1							)

         assert conditioning_emb.shape == (batch, 1, self.config.d_model * 4)

         _UpperCAmelCase							=    decoder_input_tokens.shape[1]

         # If we want to use relative positions for audio context, we can just offset
         # this sequence by the length of encodings_and_masks.
         _UpperCAmelCase							=    torch.broadcast_to(
             torch.arange(lowerCamelCase       ,				device=decoder_input_tokens.device							)       ,				(batch, seq_length)       ,				)

         _UpperCAmelCase							=    self.position_encoding(lowerCamelCase							)

         _UpperCAmelCase							=    self.continuous_inputs_projection(lowerCamelCase							)
         inputs += position_encodings
         _UpperCAmelCase							=    self.dropout(lowerCamelCase							)

         # decoder: No padding present.
         _UpperCAmelCase							=    torch.ones(
             decoder_input_tokens.shape[:2]       ,				device=decoder_input_tokens.device       ,				dtype=inputs.dtype							)

         # Translate encoding masks to encoder-decoder masks.
         _UpperCAmelCase							=    [(x, self.encoder_decoder_mask(lowerCamelCase       ,				lowerCamelCase							)) for x, y in encodings_and_masks]

         # cross attend style: concat encodings
         _UpperCAmelCase							=    torch.cat([x[0] for x in encodings_and_encdec_masks]       ,				dim=1							)
         _UpperCAmelCase							=    torch.cat([x[1] for x in encodings_and_encdec_masks]       ,				dim=-1							)

         for lyr in self.decoders:
                _UpperCAmelCase							=    lyr(
                    lowerCamelCase       ,				conditioning_emb=lowerCamelCase       ,				encoder_hidden_states=lowerCamelCase       ,				encoder_attention_mask=lowerCamelCase       ,				)[0]

         _UpperCAmelCase							=    self.decoder_norm(lowerCamelCase							)
         _UpperCAmelCase							=    self.post_dropout(lowerCamelCase							)

         _UpperCAmelCase							=    self.spec_out(lowerCamelCase							)
         return spec_out



class 		SCREAMING_SNAKE_CASE__	(  nn.Module     ):

  '''simple docstring'''







  def __init__(      self		:			Any       ,				lowerCamelCase		:			Tuple       ,				lowerCamelCase		:			Dict       ,				lowerCamelCase		:			str       ,				lowerCamelCase		:			Union[str, Any]       ,				lowerCamelCase		:			Union[str, Any]       ,				lowerCamelCase		:			Union[str, Any]=1E-6							)						->	List[str]:


         """simple docstring"""
         super().__init__()
         _UpperCAmelCase							=    nn.ModuleList()

         # cond self attention: layer 0
         self.layer.append(
             TaLayerSelfAttentionCond(d_model=lowerCamelCase       ,				d_kv=lowerCamelCase       ,				num_heads=lowerCamelCase       ,				dropout_rate=lowerCamelCase							)							)

         # cross attention: layer 1
         self.layer.append(
             TaLayerCrossAttention(
                 d_model=lowerCamelCase       ,				d_kv=lowerCamelCase       ,				num_heads=lowerCamelCase       ,				dropout_rate=lowerCamelCase       ,				layer_norm_epsilon=lowerCamelCase       ,				)							)

         # Film Cond MLP + dropout: last layer
         self.layer.append(
             TaLayerFFCond(d_model=lowerCamelCase       ,				d_ff=lowerCamelCase       ,				dropout_rate=lowerCamelCase       ,				layer_norm_epsilon=lowerCamelCase							)							)





  def  lowerCamelCase       (      self		:			int       ,				lowerCamelCase		:			Any       ,				lowerCamelCase		:			Any=None       ,				lowerCamelCase		:			Optional[Any]=None       ,				lowerCamelCase		:			Any=None       ,				lowerCamelCase		:			List[str]=None       ,				lowerCamelCase		:			Any=None       ,				)						->	Dict:


         """simple docstring"""
         _UpperCAmelCase							=    self.layer[0](
             lowerCamelCase       ,				conditioning_emb=lowerCamelCase       ,				attention_mask=lowerCamelCase       ,				)

         if encoder_hidden_states is not None:
                _UpperCAmelCase							=    torch.where(encoder_attention_mask > 0       ,				0       ,				-1E10							).to(
                    encoder_hidden_states.dtype							)

                _UpperCAmelCase							=    self.layer[1](
                    lowerCamelCase       ,				key_value_states=lowerCamelCase       ,				attention_mask=lowerCamelCase       ,				)

         # Apply Film Conditional Feed Forward layer
         _UpperCAmelCase							=    self.layer[-1](lowerCamelCase       ,				lowerCamelCase							)

         return (hidden_states,)



class 		SCREAMING_SNAKE_CASE__	(  nn.Module     ):

  '''simple docstring'''







  def __init__(      self		:			int       ,				lowerCamelCase		:			Tuple       ,				lowerCamelCase		:			Dict       ,				lowerCamelCase		:			List[Any]       ,				lowerCamelCase		:			Optional[int]							)						->	List[str]:


         """simple docstring"""
         super().__init__()
         _UpperCAmelCase							=    TaLayerNorm(lowerCamelCase							)
         _UpperCAmelCase							=    TaFiLMLayer(in_features=d_model * 4       ,				out_features=lowerCamelCase							)
         _UpperCAmelCase							=    Attention(query_dim=lowerCamelCase       ,				heads=lowerCamelCase       ,				dim_head=lowerCamelCase       ,				out_bias=lowerCamelCase       ,				scale_qk=lowerCamelCase							)
         _UpperCAmelCase							=    nn.Dropout(lowerCamelCase							)





  def  lowerCamelCase       (      self		:			str       ,				lowerCamelCase		:			Optional[Any]       ,				lowerCamelCase		:			Tuple=None       ,				lowerCamelCase		:			Dict=None       ,				)						->	Optional[int]:


         """simple docstring"""
         # pre_self_attention_layer_norm
         _UpperCAmelCase							=    self.layer_norm(lowerCamelCase							)

         if conditioning_emb is not None:
                _UpperCAmelCase							=    self.FiLMLayer(lowerCamelCase       ,				lowerCamelCase							)

         # Self-attention block
         _UpperCAmelCase							=    self.attention(lowerCamelCase							)

         _UpperCAmelCase							=    hidden_states + self.dropout(lowerCamelCase							)

         return hidden_states



class 		SCREAMING_SNAKE_CASE__	(  nn.Module     ):

  '''simple docstring'''







  def __init__(      self		:			int       ,				lowerCamelCase		:			Union[str, Any]       ,				lowerCamelCase		:			Dict       ,				lowerCamelCase		:			Optional[int]       ,				lowerCamelCase		:			Tuple       ,				lowerCamelCase		:			Optional[Any]							)						->	List[str]:


         """simple docstring"""
         super().__init__()
         _UpperCAmelCase							=    Attention(query_dim=lowerCamelCase       ,				heads=lowerCamelCase       ,				dim_head=lowerCamelCase       ,				out_bias=lowerCamelCase       ,				scale_qk=lowerCamelCase							)
         _UpperCAmelCase							=    TaLayerNorm(lowerCamelCase       ,				eps=lowerCamelCase							)
         _UpperCAmelCase							=    nn.Dropout(lowerCamelCase							)





  def  lowerCamelCase       (      self		:			Optional[int]       ,				lowerCamelCase		:			Union[str, Any]       ,				lowerCamelCase		:			str=None       ,				lowerCamelCase		:			str=None       ,				)						->	str:


         """simple docstring"""
         _UpperCAmelCase							=    self.layer_norm(lowerCamelCase							)
         _UpperCAmelCase							=    self.attention(
             lowerCamelCase       ,				encoder_hidden_states=lowerCamelCase       ,				attention_mask=attention_mask.squeeze(1							)       ,				)
         _UpperCAmelCase							=    hidden_states + self.dropout(lowerCamelCase							)
         return layer_output



class 		SCREAMING_SNAKE_CASE__	(  nn.Module     ):

  '''simple docstring'''







  def __init__(      self		:			Optional[Any]       ,				lowerCamelCase		:			str       ,				lowerCamelCase		:			Optional[int]       ,				lowerCamelCase		:			Optional[int]       ,				lowerCamelCase		:			Union[str, Any]							)						->	Tuple:


         """simple docstring"""
         super().__init__()
         _UpperCAmelCase							=    TaDenseGatedActDense(d_model=lowerCamelCase       ,				d_ff=lowerCamelCase       ,				dropout_rate=lowerCamelCase							)
         _UpperCAmelCase							=    TaFiLMLayer(in_features=d_model * 4       ,				out_features=lowerCamelCase							)
         _UpperCAmelCase							=    TaLayerNorm(lowerCamelCase       ,				eps=lowerCamelCase							)
         _UpperCAmelCase							=    nn.Dropout(lowerCamelCase							)





  def  lowerCamelCase       (      self		:			Union[str, Any]       ,				lowerCamelCase		:			Optional[int]       ,				lowerCamelCase		:			Optional[Any]=None							)						->	Dict:


         """simple docstring"""
         _UpperCAmelCase							=    self.layer_norm(lowerCamelCase							)
         if conditioning_emb is not None:
                _UpperCAmelCase							=    self.film(lowerCamelCase       ,				lowerCamelCase							)

         _UpperCAmelCase							=    self.DenseReluDense(lowerCamelCase							)
         _UpperCAmelCase							=    hidden_states + self.dropout(lowerCamelCase							)
         return hidden_states



class 		SCREAMING_SNAKE_CASE__	(  nn.Module     ):

  '''simple docstring'''







  def __init__(      self		:			int       ,				lowerCamelCase		:			Optional[int]       ,				lowerCamelCase		:			Any       ,				lowerCamelCase		:			Optional[int]							)						->	List[Any]:


         """simple docstring"""
         super().__init__()
         _UpperCAmelCase							=    nn.Linear(lowerCamelCase       ,				lowerCamelCase       ,				bias=lowerCamelCase							)
         _UpperCAmelCase							=    nn.Linear(lowerCamelCase       ,				lowerCamelCase       ,				bias=lowerCamelCase							)
         _UpperCAmelCase							=    nn.Linear(lowerCamelCase       ,				lowerCamelCase       ,				bias=lowerCamelCase							)
         _UpperCAmelCase							=    nn.Dropout(lowerCamelCase							)
         _UpperCAmelCase							=    NewGELUActivation()





  def  lowerCamelCase       (      self		:			Optional[Any]       ,				lowerCamelCase		:			str							)						->	List[Any]:


         """simple docstring"""
         _UpperCAmelCase							=    self.act(self.wi_a(lowerCamelCase							)							)
         _UpperCAmelCase							=    self.wi_a(lowerCamelCase							)
         _UpperCAmelCase							=    hidden_gelu * hidden_linear
         _UpperCAmelCase							=    self.dropout(lowerCamelCase							)

         _UpperCAmelCase							=    self.wo(lowerCamelCase							)
         return hidden_states



class 		SCREAMING_SNAKE_CASE__	(  nn.Module     ):

  '''simple docstring'''







  def __init__(      self		:			List[Any]       ,				lowerCamelCase		:			Union[str, Any]       ,				lowerCamelCase		:			Optional[int]=1E-6							)						->	Union[str, Any]:


         """simple docstring"""
         super().__init__()
         _UpperCAmelCase							=    nn.Parameter(torch.ones(lowerCamelCase							)							)
         _UpperCAmelCase							=    eps





  def  lowerCamelCase       (      self		:			Union[str, Any]       ,				lowerCamelCase		:			Dict							)						->	Optional[Any]:


         """simple docstring"""
         # T5 uses a layer_norm which only scales and doesn't shift, which is also known as Root Mean
         # Square Layer Normalization https://arxiv.org/abs/1910.07467 thus variance is calculated
         # w/o mean and there is no bias. Additionally we want to make sure that the accumulation for
         # half-precision inputs is done in fp32

         _UpperCAmelCase							=    hidden_states.to(torch.floataa							).pow(2							).mean(-1       ,				keepdim=lowerCamelCase							)
         _UpperCAmelCase							=    hidden_states * torch.rsqrt(variance + self.variance_epsilon							)

         # convert into half-precision if necessary
         if self.weight.dtype in [torch.floataa, torch.bfloataa]:
                _UpperCAmelCase							=    hidden_states.to(self.weight.dtype							)

         return self.weight * hidden_states



class 		SCREAMING_SNAKE_CASE__	(  nn.Module     ):

  '''simple docstring'''







  def  lowerCamelCase       (      self		:			Any       ,				lowerCamelCase		:			torch.Tensor							)						->	torch.Tensor:


         """simple docstring"""
         return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi							) * (input + 0.04_4715 * torch.pow(lowerCamelCase       ,				3.0							))							))



class 		SCREAMING_SNAKE_CASE__	(  nn.Module     ):

  '''simple docstring'''







  def __init__(      self		:			List[Any]       ,				lowerCamelCase		:			Any       ,				lowerCamelCase		:			str							)						->	Optional[int]:


         """simple docstring"""
         super().__init__()
         _UpperCAmelCase							=    nn.Linear(lowerCamelCase       ,				out_features * 2       ,				bias=lowerCamelCase							)





  def  lowerCamelCase       (      self		:			Optional[int]       ,				lowerCamelCase		:			str       ,				lowerCamelCase		:			List[Any]							)						->	List[str]:


         """simple docstring"""
         _UpperCAmelCase							=    self.scale_bias(lowerCamelCase							)
         _UpperCAmelCase	,			_UpperCAmelCase							=    torch.chunk(lowerCamelCase       ,				2       ,				-1							)
         _UpperCAmelCase							=    x * (1 + scale) + shift
         return x







import inspect
import unittest

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

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


if is_torch_available():
  import torch

  from transformers import ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
  from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor
class 		SCREAMING_SNAKE_CASE__	:

  '''simple docstring'''







  def __init__(      self		:			Dict       ,				lowerCamelCase		:			List[str]       ,				lowerCamelCase		:			Optional[Any]=13       ,				lowerCamelCase		:			Dict=32       ,				lowerCamelCase		:			Optional[int]=3       ,				lowerCamelCase		:			List[Any]=4       ,				lowerCamelCase		:			Tuple=[10, 20, 30, 40]       ,				lowerCamelCase		:			str=[2, 2, 3, 2]       ,				lowerCamelCase		:			Optional[int]=True       ,				lowerCamelCase		:			List[Any]=True       ,				lowerCamelCase		:			Union[str, Any]=37       ,				lowerCamelCase		:			Any="gelu"       ,				lowerCamelCase		:			Tuple=10       ,				lowerCamelCase		:			Optional[Any]=0.02       ,				lowerCamelCase		:			Union[str, Any]=["stage2", "stage3", "stage4"]       ,				lowerCamelCase		:			Any=[2, 3, 4]       ,				lowerCamelCase		:			Tuple=None       ,				)						->	int:


         """simple docstring"""
         _UpperCAmelCase							=    parent
         _UpperCAmelCase							=    batch_size
         _UpperCAmelCase							=    image_size
         _UpperCAmelCase							=    num_channels
         _UpperCAmelCase							=    num_stages
         _UpperCAmelCase							=    hidden_sizes
         _UpperCAmelCase							=    depths
         _UpperCAmelCase							=    is_training
         _UpperCAmelCase							=    use_labels
         _UpperCAmelCase							=    intermediate_size
         _UpperCAmelCase							=    hidden_act
         _UpperCAmelCase							=    num_labels
         _UpperCAmelCase							=    initializer_range
         _UpperCAmelCase							=    out_features
         _UpperCAmelCase							=    out_indices
         _UpperCAmelCase							=    scope


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


         """simple docstring"""
         _UpperCAmelCase							=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

         _UpperCAmelCase							=    None
         if self.use_labels:
                _UpperCAmelCase							=    ids_tensor([self.batch_size]       ,				self.num_labels							)

         _UpperCAmelCase							=    self.get_config()
         return config, pixel_values, labels


  def  lowerCamelCase       (      self		:			Optional[Any]							)						->	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=lowerCamelCase       ,				initializer_range=self.initializer_range       ,				out_features=self.out_features       ,				out_indices=self.out_indices       ,				num_labels=self.num_labels       ,				)


  def  lowerCamelCase       (      self		:			Union[str, Any]       ,				lowerCamelCase		:			List[str]       ,				lowerCamelCase		:			Optional[int]       ,				lowerCamelCase		:			Any							)						->	str:


         """simple docstring"""
         _UpperCAmelCase							=    ConvNextModel(config=lowerCamelCase							)
         model.to(lowerCamelCase							)
         model.eval()
         _UpperCAmelCase							=    model(lowerCamelCase							)
         # 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		:			Dict       ,				lowerCamelCase		:			Tuple       ,				lowerCamelCase		:			Tuple       ,				lowerCamelCase		:			List[Any]							)						->	int:


         """simple docstring"""
         _UpperCAmelCase							=    ConvNextForImageClassification(lowerCamelCase							)
         model.to(lowerCamelCase							)
         model.eval()
         _UpperCAmelCase							=    model(lowerCamelCase       ,				labels=lowerCamelCase							)
         self.parent.assertEqual(result.logits.shape       ,				(self.batch_size, self.num_labels)							)


  def  lowerCamelCase       (      self		:			Dict       ,				lowerCamelCase		:			List[Any]       ,				lowerCamelCase		:			Tuple       ,				lowerCamelCase		:			Dict							)						->	Dict:


         """simple docstring"""
         _UpperCAmelCase							=    ConvNextBackbone(config=lowerCamelCase							)
         model.to(lowerCamelCase							)
         model.eval()
         _UpperCAmelCase							=    model(lowerCamelCase							)

         # verify hidden states
         self.parent.assertEqual(len(result.feature_maps							)       ,				len(config.out_features							)							)
         self.parent.assertListEqual(list(result.feature_maps[0].shape							)       ,				[self.batch_size, self.hidden_sizes[1], 4, 4]							)

         # verify channels
         self.parent.assertEqual(len(model.channels							)       ,				len(config.out_features							)							)
         self.parent.assertListEqual(model.channels       ,				config.hidden_sizes[1:]							)

         # verify backbone works with out_features=None
         _UpperCAmelCase							=    None
         _UpperCAmelCase							=    ConvNextBackbone(config=lowerCamelCase							)
         model.to(lowerCamelCase							)
         model.eval()
         _UpperCAmelCase							=    model(lowerCamelCase							)

         # verify feature maps
         self.parent.assertEqual(len(result.feature_maps							)       ,				1							)
         self.parent.assertListEqual(list(result.feature_maps[0].shape							)       ,				[self.batch_size, self.hidden_sizes[-1], 1, 1]							)

         # verify channels
         self.parent.assertEqual(len(model.channels							)       ,				1							)
         self.parent.assertListEqual(model.channels       ,				[config.hidden_sizes[-1]]							)





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


         """simple docstring"""
         _UpperCAmelCase							=    self.prepare_config_and_inputs()
         _UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase							=    config_and_inputs
         _UpperCAmelCase							=    {"""pixel_values""": pixel_values}
         return config, inputs_dict



@require_torch
class 		SCREAMING_SNAKE_CASE__	(  UpperCAmelCase					,      UpperCAmelCase					,      unittest.TestCase     ):

  '''simple docstring'''







  _lowerCamelCase    =  (
      (
          ConvNextModel,
          ConvNextForImageClassification,
          ConvNextBackbone,
      )
      if is_torch_available()
      else ()
  )
  _lowerCamelCase    =  (
      {'''feature-extraction''': ConvNextModel, '''image-classification''': ConvNextForImageClassification}
      if is_torch_available()
      else {}
  )

  _lowerCamelCase    =  True
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False


  def  lowerCamelCase       (      self		:			Dict							)						->	int:


         """simple docstring"""
         _UpperCAmelCase							=    ConvNextModelTester(self							)
         _UpperCAmelCase							=    ConfigTester(self       ,				config_class=lowerCamelCase       ,				has_text_modality=lowerCamelCase       ,				hidden_size=37							)


  def  lowerCamelCase       (      self		:			int							)						->	int:


         """simple docstring"""
         self.create_and_test_config_common_properties()
         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()


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


         """simple docstring"""
         return


  @unittest.skip(reason="""ConvNext does not use inputs_embeds"""							)
  def  lowerCamelCase       (      self		:			List[Any]							)						->	Any:


         """simple docstring"""
         pass


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


         """simple docstring"""
         pass


  @unittest.skip(reason="""ConvNext does not use feedforward chunking"""							)
  def  lowerCamelCase       (      self		:			Optional[int]							)						->	int:


         """simple docstring"""
         pass


  def  lowerCamelCase       (      self		:			List[Any]							)						->	Optional[int]:


         """simple docstring"""
         _UpperCAmelCase	,			_UpperCAmelCase							=    self.model_tester.prepare_config_and_inputs_for_common()

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

                _UpperCAmelCase							=    ["""pixel_values"""]
                self.assertListEqual(arg_names[:1]       ,				lowerCamelCase							)


  def  lowerCamelCase       (      self		:			Tuple							)						->	Any:


         """simple docstring"""
         _UpperCAmelCase							=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCamelCase							)


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


         """simple docstring"""
         _UpperCAmelCase							=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*lowerCamelCase							)


  def  lowerCamelCase       (      self		:			int							)						->	Any:


         """simple docstring"""
         def check_hidden_states_output(lowerCamelCase		:			List[Any]       ,				lowerCamelCase		:			Tuple       ,				lowerCamelCase		:			Optional[int]							):
                _UpperCAmelCase							=    model_class(lowerCamelCase							)
                model.to(lowerCamelCase							)
                model.eval()

                with torch.no_grad():
                       _UpperCAmelCase							=    model(**self._prepare_for_class(lowerCamelCase       ,				lowerCamelCase							)							)

                _UpperCAmelCase							=    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                _UpperCAmelCase							=    self.model_tester.num_stages
                self.assertEqual(len(lowerCamelCase							)       ,				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							=    self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
                _UpperCAmelCase							=    True
                check_hidden_states_output(lowerCamelCase       ,				lowerCamelCase       ,				lowerCamelCase							)

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

                check_hidden_states_output(lowerCamelCase       ,				lowerCamelCase       ,				lowerCamelCase							)


  def  lowerCamelCase       (      self		:			Any							)						->	Optional[int]:


         """simple docstring"""
         _UpperCAmelCase							=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*lowerCamelCase							)





  @slow
  def  lowerCamelCase       (      self		:			Optional[int]							)						->	List[Any]:


         """simple docstring"""
         for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                _UpperCAmelCase							=    ConvNextModel.from_pretrained(lowerCamelCase							)
                self.assertIsNotNone(lowerCamelCase							)




def       _SCREAMING_SNAKE_CASE (							)				->						Tuple:
       _UpperCAmelCase							=    Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
       return image
@require_torch
@require_vision
class 		SCREAMING_SNAKE_CASE__	(  unittest.TestCase     ):

  '''simple docstring'''







  @cached_property
  def  lowerCamelCase       (      self		:			Dict							)						->	int:


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





  @slow
  def  lowerCamelCase       (      self		:			List[Any]							)						->	int:


         """simple docstring"""
         _UpperCAmelCase							=    ConvNextForImageClassification.from_pretrained("""facebook/convnext-tiny-224"""							).to(lowerCamelCase							)

         _UpperCAmelCase							=    self.default_image_processor
         _UpperCAmelCase							=    prepare_img()
         _UpperCAmelCase							=    image_processor(images=lowerCamelCase       ,				return_tensors="""pt"""							).to(lowerCamelCase							)

         # forward pass
         with torch.no_grad():
                _UpperCAmelCase							=    model(**lowerCamelCase							)

         # verify the logits
         _UpperCAmelCase							=    torch.Size((1, 1000)							)
         self.assertEqual(outputs.logits.shape       ,				lowerCamelCase							)

         _UpperCAmelCase							=    torch.tensor([-0.0260, -0.4739, 0.1911]							).to(lowerCamelCase							)

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



@require_torch
class 		SCREAMING_SNAKE_CASE__	(  unittest.TestCase					,      UpperCAmelCase     ):

  '''simple docstring'''







  _lowerCamelCase    =  (ConvNextBackbone,) if is_torch_available() else ()
  _lowerCamelCase    =  ConvNextConfig

  _lowerCamelCase    =  False


  def  lowerCamelCase       (      self		:			List[Any]							)						->	Optional[int]:


         """simple docstring"""
         _UpperCAmelCase							=    ConvNextModelTester(self							)