





import collections
import inspect
import unittest

from transformers import NatConfig
from transformers.testing_utils import require_natten, 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, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch
      from torch import nn

      from transformers import NatBackbone, NatForImageClassification, NatModel
      from transformers.models.nat.modeling_nat import NAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
      from PIL import Image

      from transformers import AutoImageProcessor


class       a_  :

    '''simple docstring'''


    def __init__(	self				,	A				,	A=13				,	A=64				,	A=4				,	A=3				,	A=16				,	A=[1, 2, 1]				,	A=[2, 4, 8]				,	A=3				,	A=2.0				,	A=True				,	A=0.0				,	A=0.0				,	A=0.1				,	A="gelu"				,	A=True				,	A=0.02				,	A=1e-5				,	A=True				,	A=None				,	A=True				,	A=10				,	A=["stage1", "stage2"]				,	A=[1, 2]				,	)	->     Optional[int]:
        _SCREAMING_SNAKE_CASE             =    parent
        _SCREAMING_SNAKE_CASE             =    batch_size
        _SCREAMING_SNAKE_CASE             =    image_size
        _SCREAMING_SNAKE_CASE             =    patch_size
        _SCREAMING_SNAKE_CASE             =    num_channels
        _SCREAMING_SNAKE_CASE             =    embed_dim
        _SCREAMING_SNAKE_CASE             =    depths
        _SCREAMING_SNAKE_CASE             =    num_heads
        _SCREAMING_SNAKE_CASE             =    kernel_size
        _SCREAMING_SNAKE_CASE             =    mlp_ratio
        _SCREAMING_SNAKE_CASE             =    qkv_bias
        _SCREAMING_SNAKE_CASE             =    hidden_dropout_prob
        _SCREAMING_SNAKE_CASE             =    attention_probs_dropout_prob
        _SCREAMING_SNAKE_CASE             =    drop_path_rate
        _SCREAMING_SNAKE_CASE             =    hidden_act
        _SCREAMING_SNAKE_CASE             =    patch_norm
        _SCREAMING_SNAKE_CASE             =    layer_norm_eps
        _SCREAMING_SNAKE_CASE             =    initializer_range
        _SCREAMING_SNAKE_CASE             =    is_training
        _SCREAMING_SNAKE_CASE             =    scope
        _SCREAMING_SNAKE_CASE             =    use_labels
        _SCREAMING_SNAKE_CASE             =    num_labels
        _SCREAMING_SNAKE_CASE             =    out_features
        _SCREAMING_SNAKE_CASE             =    out_indices


    def     snake_case_(	self )	->     Union[str, Any]:
        _SCREAMING_SNAKE_CASE             =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

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

        _SCREAMING_SNAKE_CASE             =    self.get_config()

        return config, pixel_values, labels


    def     snake_case_(	self )	->     List[Any]:
        return NatConfig(
            num_labels=self.num_labels				,	image_size=self.image_size				,	patch_size=self.patch_size				,	num_channels=self.num_channels				,	embed_dim=self.embed_dim				,	depths=self.depths				,	num_heads=self.num_heads				,	kernel_size=self.kernel_size				,	mlp_ratio=self.mlp_ratio				,	qkv_bias=self.qkv_bias				,	hidden_dropout_prob=self.hidden_dropout_prob				,	attention_probs_dropout_prob=self.attention_probs_dropout_prob				,	drop_path_rate=self.drop_path_rate				,	hidden_act=self.hidden_act				,	patch_norm=self.patch_norm				,	layer_norm_eps=self.layer_norm_eps				,	initializer_range=self.initializer_range				,	out_features=self.out_features				,	out_indices=self.out_indices				,	)


    def     snake_case_(	self				,	A				,	A				,	A )	->     int:
        _SCREAMING_SNAKE_CASE             =    NatModel(config=A )
        model.to(A )
        model.eval()
        _SCREAMING_SNAKE_CASE             =    model(A )

        _SCREAMING_SNAKE_CASE             =    _SCREAMING_SNAKE_CASE             =    (config.image_size // config.patch_size) // (2 ** (len(config.depths ) - 1))
        _SCREAMING_SNAKE_CASE             =    int(config.embed_dim * 2 ** (len(config.depths ) - 1) )

        self.parent.assertEqual(
            result.last_hidden_state.shape				,	(self.batch_size, expected_height, expected_width, expected_dim) )


    def     snake_case_(	self				,	A				,	A				,	A )	->     Any:
        _SCREAMING_SNAKE_CASE             =    NatForImageClassification(A )
        model.to(A )
        model.eval()
        _SCREAMING_SNAKE_CASE             =    model(A				,	labels=A )
        self.parent.assertEqual(result.logits.shape				,	(self.batch_size, self.num_labels) )

        # test greyscale images
        _SCREAMING_SNAKE_CASE             =    1
        _SCREAMING_SNAKE_CASE             =    NatForImageClassification(A )
        model.to(A )
        model.eval()

        _SCREAMING_SNAKE_CASE             =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
        _SCREAMING_SNAKE_CASE             =    model(A )
        self.parent.assertEqual(result.logits.shape				,	(self.batch_size, self.num_labels) )


    def     snake_case_(	self				,	A				,	A				,	A )	->     int:
        _SCREAMING_SNAKE_CASE             =    NatBackbone(config=A )
        model.to(A )
        model.eval()
        _SCREAMING_SNAKE_CASE             =    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, model.channels[0], 16, 16] )

        # verify channels
        self.parent.assertEqual(len(model.channels )				,	len(config.out_features ) )

        # verify backbone works with out_features=None
        _SCREAMING_SNAKE_CASE             =    None
        _SCREAMING_SNAKE_CASE             =    NatBackbone(config=A )
        model.to(A )
        model.eval()
        _SCREAMING_SNAKE_CASE             =    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, model.channels[-1], 4, 4] )

        # verify channels
        self.parent.assertEqual(len(model.channels )				,	1 )





    def     snake_case_(	self )	->     str:
        _SCREAMING_SNAKE_CASE             =    self.prepare_config_and_inputs()
        _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    config_and_inputs
        _SCREAMING_SNAKE_CASE             =    {"""pixel_values""": pixel_values}
        return config, inputs_dict




@require_natten
@require_torch
class       a_  (       snake_case_   ,					snake_case_   ,					unittest.TestCase ):

    '''simple docstring'''
    UpperCamelCase									=				(
        (
            NatModel,
            NatForImageClassification,
            NatBackbone,
        )
        if is_torch_available()
        else ()
    )
    UpperCamelCase									=				(
        {'''feature-extraction''': NatModel, '''image-classification''': NatForImageClassification}
        if is_torch_available()
        else {}
    )
    UpperCamelCase									=				False

    UpperCamelCase									=				False
    UpperCamelCase									=				False
    UpperCamelCase									=				False
    UpperCamelCase									=				False


    def     snake_case_(	self )	->     Union[str, Any]:
        _SCREAMING_SNAKE_CASE             =    NatModelTester(self )
        _SCREAMING_SNAKE_CASE             =    ConfigTester(self				,	config_class=A				,	embed_dim=37 )


    def     snake_case_(	self )	->     Optional[int]:
        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     snake_case_(	self )	->     List[str]:
        return


    def     snake_case_(	self )	->     Any:
        _SCREAMING_SNAKE_CASE             =    self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*A )


    def     snake_case_(	self )	->     Optional[int]:
        _SCREAMING_SNAKE_CASE             =    self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*A )


    def     snake_case_(	self )	->     List[str]:
        _SCREAMING_SNAKE_CASE             =    self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*A )


    @unittest.skip(reason="""Nat does not use inputs_embeds""" )
    def     snake_case_(	self )	->     int:
        pass


    @unittest.skip(reason="""Nat does not use feedforward chunking""" )
    def     snake_case_(	self )	->     Tuple:
        pass


    def     snake_case_(	self )	->     str:
        _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            _SCREAMING_SNAKE_CASE             =    model_class(A )
            self.assertIsInstance(model.get_input_embeddings()				,	(nn.Module) )
            _SCREAMING_SNAKE_CASE             =    model.get_output_embeddings()
            self.assertTrue(x is None or isinstance(A				,	nn.Linear ) )


    def     snake_case_(	self )	->     Optional[int]:
        _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    self.model_tester.prepare_config_and_inputs_for_common()

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

            _SCREAMING_SNAKE_CASE             =    ["""pixel_values"""]
            self.assertListEqual(arg_names[:1]				,	A )


    def     snake_case_(	self )	->     Any:
        self.skipTest("""Nat's attention operation is handled entirely by NATTEN.""" )


    def     snake_case_(	self				,	A				,	A				,	A				,	A )	->     List[Any]:
        _SCREAMING_SNAKE_CASE             =    model_class(A )
        model.to(A )
        model.eval()

        with torch.no_grad():
            _SCREAMING_SNAKE_CASE             =    model(**self._prepare_for_class(A				,	A ) )

        _SCREAMING_SNAKE_CASE             =    outputs.hidden_states

        _SCREAMING_SNAKE_CASE             =    getattr(
            self.model_tester				,	"""expected_num_hidden_layers"""				,	len(self.model_tester.depths ) + 1 )
        self.assertEqual(len(A )				,	A )

        # Nat has a different seq_length
        _SCREAMING_SNAKE_CASE             =    (
            config.patch_size
            if isinstance(config.patch_size				,	collections.abc.Iterable )
            else (config.patch_size, config.patch_size)
        )

        _SCREAMING_SNAKE_CASE             =    image_size[0] // patch_size[0]
        _SCREAMING_SNAKE_CASE             =    image_size[1] // patch_size[1]

        self.assertListEqual(
            list(hidden_states[0].shape[-3:] )				,	[height, width, self.model_tester.embed_dim]				,	)

        if model_class.__name__ != "NatBackbone":
            _SCREAMING_SNAKE_CASE             =    outputs.reshaped_hidden_states
            self.assertEqual(len(A )				,	A )

            _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    reshaped_hidden_states[0].shape
            _SCREAMING_SNAKE_CASE             =    (
                reshaped_hidden_states[0].view(A				,	A				,	A				,	A ).permute(0				,	2				,	3				,	1 )
            )
            self.assertListEqual(
                list(reshaped_hidden_states.shape[-3:] )				,	[height, width, self.model_tester.embed_dim]				,	)


    def     snake_case_(	self )	->     Dict:
        _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    self.model_tester.prepare_config_and_inputs_for_common()

        _SCREAMING_SNAKE_CASE             =    (
            self.model_tester.image_size
            if isinstance(self.model_tester.image_size				,	collections.abc.Iterable )
            else (self.model_tester.image_size, self.model_tester.image_size)
        )

        for model_class in self.all_model_classes:
            _SCREAMING_SNAKE_CASE             =    True
            self.check_hidden_states_output(A				,	A				,	A				,	A )

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

            self.check_hidden_states_output(A				,	A				,	A				,	A )


    @slow
    def     snake_case_(	self )	->     List[Any]:
        for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            _SCREAMING_SNAKE_CASE             =    NatModel.from_pretrained(A )
            self.assertIsNotNone(A )





    def     snake_case_(	self )	->     Optional[Any]:
        _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    self.model_tester.prepare_config_and_inputs_for_common()

        _SCREAMING_SNAKE_CASE             =    _config_zero_init(A )
        for model_class in self.all_model_classes:
            _SCREAMING_SNAKE_CASE             =    model_class(config=A )
            for name, param in model.named_parameters():
                if "embeddings" not in name and param.requires_grad:
                    self.assertIn(
                        ((param.data.mean() * 1e9).round() / 1e9).item()				,	[0.0, 1.0]				,	msg=f'Parameter {name} of model {model_class} seems not properly initialized'				,	)




@require_natten
@require_vision
@require_torch
class       a_  (       unittest.TestCase ):

    '''simple docstring'''


    @cached_property
    def     snake_case_(	self )	->     Dict:
        return AutoImageProcessor.from_pretrained("""shi-labs/nat-mini-in1k-224""" ) if is_vision_available() else None





    @slow
    def     snake_case_(	self )	->     List[Any]:
        _SCREAMING_SNAKE_CASE             =    NatForImageClassification.from_pretrained("""shi-labs/nat-mini-in1k-224""" ).to(A )
        _SCREAMING_SNAKE_CASE             =    self.default_image_processor

        _SCREAMING_SNAKE_CASE             =    Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
        _SCREAMING_SNAKE_CASE             =    image_processor(images=A				,	return_tensors="""pt""" ).to(A )

        # forward pass
        with torch.no_grad():
            _SCREAMING_SNAKE_CASE             =    model(**A )

        # verify the logits
        _SCREAMING_SNAKE_CASE             =    torch.Size((1, 1000) )
        self.assertEqual(outputs.logits.shape				,	A )
        _SCREAMING_SNAKE_CASE             =    torch.tensor([0.3805, -0.8676, -0.3912] ).to(A )
        self.assertTrue(torch.allclose(outputs.logits[0, :3]				,	A				,	atol=1e-4 ) )




@require_torch
@require_natten
class       a_  (       unittest.TestCase   ,					snake_case_ ):

    '''simple docstring'''
    UpperCamelCase									=				(NatBackbone,) if is_torch_available() else ()
    UpperCamelCase									=				NatConfig


    def     snake_case_(	self )	->     Any:
        _SCREAMING_SNAKE_CASE             =    NatModelTester(self )










'''simple docstring'''

import json
import os
import tempfile
import unittest

from transformers.modelcard import ModelCard


class       a_  (       unittest.TestCase ):

    '''simple docstring'''


    def     snake_case_(	self )	->     int:
        _SCREAMING_SNAKE_CASE             =    {
            """model_details""": {
                """Organization""": """testing""",
                """Model date""": """today""",
                """Model version""": """v2.1, Developed by Test Corp in 2019.""",
                """Architecture""": """Convolutional Neural Network.""",
            },
            """metrics""": """BLEU and ROUGE-1""",
            """evaluation_data""": {
                """Datasets""": {"""BLEU""": """My-great-dataset-v1""", """ROUGE-1""": """My-short-dataset-v2.1"""},
                """Preprocessing""": """See details on https://arxiv.org/pdf/1810.03993.pdf""",
            },
            """training_data""": {
                """Dataset""": """English Wikipedia dump dated 2018-12-01""",
                """Preprocessing""": (
                    """Using SentencePiece vocabulary of size 52k tokens. See details on"""
                    """ https://arxiv.org/pdf/1810.03993.pdf"""
                ),
            },
            """quantitative_analyses""": {"""BLEU""": 55.1, """ROUGE-1""": 76},
        }


    def     snake_case_(	self )	->     Tuple:
        _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )
        self.assertTrue(hasattr(A				,	"""model_details""" ) )
        self.assertTrue(hasattr(A				,	"""intended_use""" ) )
        self.assertTrue(hasattr(A				,	"""factors""" ) )
        self.assertTrue(hasattr(A				,	"""metrics""" ) )
        self.assertTrue(hasattr(A				,	"""evaluation_data""" ) )
        self.assertTrue(hasattr(A				,	"""training_data""" ) )
        self.assertTrue(hasattr(A				,	"""quantitative_analyses""" ) )
        self.assertTrue(hasattr(A				,	"""ethical_considerations""" ) )
        self.assertTrue(hasattr(A				,	"""caveats_and_recommendations""" ) )


    def     snake_case_(	self )	->     List[str]:
        _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )
        _SCREAMING_SNAKE_CASE             =    json.loads(modelcard.to_json_string() )
        for key, value in self.inputs_dict.items():
            self.assertEqual(obj[key]				,	A )


    def     snake_case_(	self )	->     Any:
        _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )

        with tempfile.TemporaryDirectory() as tmpdirname:
            _SCREAMING_SNAKE_CASE             =    os.path.join(A				,	"""modelcard.json""" )
            model_card_first.to_json_file(A )
            _SCREAMING_SNAKE_CASE             =    ModelCard.from_json_file(A )

        self.assertEqual(model_card_second.to_dict()				,	model_card_first.to_dict() )





    def     snake_case_(	self )	->     List[Any]:
        _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )

        with tempfile.TemporaryDirectory() as tmpdirname:
            model_card_first.save_pretrained(A )
            _SCREAMING_SNAKE_CASE             =    ModelCard.from_pretrained(A )

        self.assertEqual(model_card_second.to_dict()				,	model_card_first.to_dict() )



