

"""simple docstring"""






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 	__UpperCamelCase    :

  def __init__(		self    ,_A    ,_A=13    ,_A=32    ,_A=3    ,_A=4    ,_A=[10, 20, 30, 40]    ,_A=[2, 2, 3, 2]    ,_A=True    ,_A=True    ,_A=37    ,_A="gelu"    ,_A=10    ,_A=0.0_2    ,_A=["stage2", "stage3", "stage4"]    ,_A=[2, 3, 4]    ,_A=None    ,):
      '''simple docstring'''

      _lowerCAmelCase       :   int  =    parent
      _lowerCAmelCase       :   Optional[Any]  =    batch_size
      _lowerCAmelCase       :   Dict  =    image_size
      _lowerCAmelCase       :   Union[str, Any]  =    num_channels
      _lowerCAmelCase       :   Any  =    num_stages
      _lowerCAmelCase       :   List[str]  =    hidden_sizes
      _lowerCAmelCase       :   str  =    depths
      _lowerCAmelCase       :   List[Any]  =    is_training
      _lowerCAmelCase       :   Optional[int]  =    use_labels
      _lowerCAmelCase       :   Tuple  =    intermediate_size
      _lowerCAmelCase       :   Tuple  =    hidden_act
      _lowerCAmelCase       :   Union[str, Any]  =    num_labels
      _lowerCAmelCase       :   Tuple  =    initializer_range
      _lowerCAmelCase       :   List[Any]  =    out_features
      _lowerCAmelCase       :   Union[str, Any]  =    out_indices
      _lowerCAmelCase       :   int  =    scope

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[Any]  =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

      _lowerCAmelCase       :   Optional[Any]  =    None
      if self.use_labels:
          _lowerCAmelCase       :   int  =    ids_tensor([self.batch_size]    ,self.num_labels      )

      _lowerCAmelCase       :   List[Any]  =    self.get_config()
      return config, pixel_values, labels

  def __lowerCamelCase		(		self      ):
      '''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=_A    ,initializer_range=self.initializer_range    ,out_features=self.out_features    ,out_indices=self.out_indices    ,num_labels=self.num_labels    ,)

  def __lowerCamelCase		(		self    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   str  =    ConvNextModel(config=_A      )
      model.to(_A      )
      model.eval()
      _lowerCAmelCase       :   str  =    model(_A      )
      # 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    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   int  =    ConvNextForImageClassification(_A      )
      model.to(_A      )
      model.eval()
      _lowerCAmelCase       :   int  =    model(_A    ,labels=_A      )
      self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.num_labels)      )

  def __lowerCamelCase		(		self    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[Any]  =    ConvNextBackbone(config=_A      )
      model.to(_A      )
      model.eval()
      _lowerCAmelCase       :   List[str]  =    model(_A      )

      # 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
      _lowerCAmelCase       :   Tuple  =    None
      _lowerCAmelCase       :   Optional[Any]  =    ConvNextBackbone(config=_A      )
      model.to(_A      )
      model.eval()
      _lowerCAmelCase       :   List[Any]  =    model(_A      )

      # 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      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Tuple  =    self.prepare_config_and_inputs()
      _lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase       :   Any  =    config_and_inputs
      _lowerCAmelCase       :   str  =    {'pixel_values': pixel_values}
      return config, inputs_dict







@require_torch
class 	__UpperCamelCase    (    a__							,							a__							,							unittest.TestCase						):
  _UpperCAmelCase          =		(
      (
          ConvNextModel,
          ConvNextForImageClassification,
          ConvNextBackbone,
      )
      if is_torch_available()
      else ()
  )
  _UpperCAmelCase          =		(
      {"feature-extraction": ConvNextModel, "image-classification": ConvNextForImageClassification}
      if is_torch_available()
      else {}
  )

  _UpperCAmelCase          =		True
  _UpperCAmelCase          =		False
  _UpperCAmelCase          =		False
  _UpperCAmelCase          =		False
  _UpperCAmelCase          =		False

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   str  =    ConvNextModelTester(self      )
      _lowerCAmelCase       :   Any  =    ConfigTester(self    ,config_class=_A    ,has_text_modality=_A    ,hidden_size=37      )

  def __lowerCamelCase		(		self      ):
      '''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      ):
      '''simple docstring'''

      return

  @unittest.skip(reason='ConvNext does not use inputs_embeds'      )
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      pass

  @unittest.skip(reason='ConvNext does not support input and output embeddings'      )
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      pass

  @unittest.skip(reason='ConvNext does not use feedforward chunking'      )
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      pass

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase,					_lowerCAmelCase       :   int  =    self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
          _lowerCAmelCase       :   Union[str, Any]  =    model_class(_A      )
          _lowerCAmelCase       :   Tuple  =    inspect.signature(model.forward      )
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          _lowerCAmelCase       :   Optional[Any]  =    [*signature.parameters.keys()]

          _lowerCAmelCase       :   List[str]  =    ['pixel_values']
          self.assertListEqual(arg_names[:1]    ,_A      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[int]  =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_A      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Tuple  =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*_A      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      def check_hidden_states_output(_A    ,_A    ,_A      ):
          _lowerCAmelCase       :   List[str]  =    model_class(_A      )
          model.to(_A      )
          model.eval()

          with torch.no_grad():
              _lowerCAmelCase       :   Union[str, Any]  =    model(**self._prepare_for_class(_A    ,_A      )      )

          _lowerCAmelCase       :   Dict  =    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

          _lowerCAmelCase       :   Optional[Any]  =    self.model_tester.num_stages
          self.assertEqual(len(_A      )    ,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]    ,)

      _lowerCAmelCase,					_lowerCAmelCase       :   Any  =    self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
          _lowerCAmelCase       :   Any  =    True
          check_hidden_states_output(_A    ,_A    ,_A      )

          # check that output_hidden_states also work using config
          del inputs_dict["output_hidden_states"]
          _lowerCAmelCase       :   int  =    True

          check_hidden_states_output(_A    ,_A    ,_A      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[str]  =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*_A      )







  @slow
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          _lowerCAmelCase       :   List[Any]  =    ConvNextModel.from_pretrained(_A      )
          self.assertIsNotNone(_A      )





def 		lowerCamelCase__		(					):

    '''simple docstring'''



    _lowerCAmelCase       :   List[Any]  =    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
    return image







@require_torch
@require_vision
class 	__UpperCamelCase    (    unittest.TestCase						):

  @cached_property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

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







  @slow
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   str  =    ConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224'      ).to(_A      )

      _lowerCAmelCase       :   Union[str, Any]  =    self.default_image_processor
      _lowerCAmelCase       :   Optional[int]  =    prepare_img()
      _lowerCAmelCase       :   Union[str, Any]  =    image_processor(images=_A    ,return_tensors='pt'      ).to(_A      )

      # forward pass
      with torch.no_grad():
          _lowerCAmelCase       :   str  =    model(**_A      )

      # verify the logits
      _lowerCAmelCase       :   List[Any]  =    torch.Size((1, 1000)      )
      self.assertEqual(outputs.logits.shape    ,_A      )

      _lowerCAmelCase       :   List[Any]  =    torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1]      ).to(_A      )

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







@require_torch
class 	__UpperCamelCase    (    unittest.TestCase							,							a__						):
  _UpperCAmelCase          =		(ConvNextBackbone,) if is_torch_available() else ()
  _UpperCAmelCase          =		ConvNextConfig

  _UpperCAmelCase          =		False

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[int]  =    ConvNextModelTester(self      )








"""simple docstring"""






from __future__ import annotations

def 		lowerCamelCase__		(					_lowerCamelCase   ):

    '''simple docstring'''



    create_state_space_tree(_lowerCamelCase ,   [] ,   0 ,   [0 for i in range(len(_lowerCamelCase   )   )]   )

def 		lowerCamelCase__		(					_lowerCamelCase ,   _lowerCamelCase ,   _lowerCamelCase ,   _lowerCamelCase ,   ):

    '''simple docstring'''



    if index == len(_lowerCamelCase   ):
        print(_lowerCamelCase   )
        return

    for i in range(len(_lowerCamelCase   )   ):
        if not index_used[i]:
            current_sequence.append(sequence[i]   )
            _lowerCAmelCase       :   List[str]  =    True
            create_state_space_tree(_lowerCamelCase ,   _lowerCamelCase ,   index + 1 ,   _lowerCamelCase   )
            current_sequence.pop()
            _lowerCAmelCase       :   int  =    False
_lowerCAmelCase						=		[3, 1, 2, 4]
generate_all_permutations(sequence)

_lowerCAmelCase						=		["A", "B", "C"]

generate_all_permutations(sequence_a)





