



'''simple docstring'''



import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    NystromformerForMaskedLM,
							    NystromformerForMultipleChoice,
							    NystromformerForQuestionAnswering,
							    NystromformerForSequenceClassification,
							    NystromformerForTokenClassification,
							    NystromformerModel,
							)
							from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST
class 	lowerCamelCase_							:







						def __init__(  self   :      Union[str, Any]				,    lowerCAmelCase__   :      Optional[Any]				,    lowerCAmelCase__   :      Any=13				,    lowerCAmelCase__   :      str=7				,    lowerCAmelCase__   :      Optional[Any]=True				,    lowerCAmelCase__   :      Tuple=True				,    lowerCAmelCase__   :      Dict=True				,    lowerCAmelCase__   :      int=True				,    lowerCAmelCase__   :      Optional[int]=99				,    lowerCAmelCase__   :      int=32				,    lowerCAmelCase__   :      List[str]=5				,    lowerCAmelCase__   :      int=4				,    lowerCAmelCase__   :      Tuple=37				,    lowerCAmelCase__   :      Dict="gelu"				,    lowerCAmelCase__   :      Tuple=0.1				,    lowerCAmelCase__   :      List[Any]=0.1				,    lowerCAmelCase__   :      str=5_12				,    lowerCAmelCase__   :      Optional[int]=16				,    lowerCAmelCase__   :      Any=2				,    lowerCAmelCase__   :      Any=0.02				,    lowerCAmelCase__   :      Dict=3				,    lowerCAmelCase__   :      Optional[Any]=4				,    lowerCAmelCase__   :      Dict=None				,    ):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Any     					=			parent
													SCREAMING_SNAKE_CASE					:      int     					=			batch_size
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			seq_length
													SCREAMING_SNAKE_CASE					:      List[str]     					=			is_training
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			use_input_mask
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			use_token_type_ids
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			use_labels
													SCREAMING_SNAKE_CASE					:      int     					=			vocab_size
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			hidden_size
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			num_hidden_layers
													SCREAMING_SNAKE_CASE					:      Any     					=			num_attention_heads
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			intermediate_size
													SCREAMING_SNAKE_CASE					:      List[str]     					=			hidden_act
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			hidden_dropout_prob
													SCREAMING_SNAKE_CASE					:      Any     					=			attention_probs_dropout_prob
													SCREAMING_SNAKE_CASE					:      str     					=			max_position_embeddings
													SCREAMING_SNAKE_CASE					:      Any     					=			type_vocab_size
													SCREAMING_SNAKE_CASE					:      Any     					=			type_sequence_label_size
													SCREAMING_SNAKE_CASE					:      Dict     					=			initializer_range
													SCREAMING_SNAKE_CASE					:      Any     					=			num_labels
													SCREAMING_SNAKE_CASE					:      Dict     					=			num_choices
													SCREAMING_SNAKE_CASE					:      str     					=			scope







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Tuple     					=			ids_tensor([self.batch_size, self.seq_length]				,    self.vocab_size				)

													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			None
													if self.use_input_mask:
																				SCREAMING_SNAKE_CASE					:      Optional[int]     					=			random_attention_mask([self.batch_size, self.seq_length]				)

													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			None
													if self.use_token_type_ids:
																				SCREAMING_SNAKE_CASE					:      Dict     					=			ids_tensor([self.batch_size, self.seq_length]				,    self.type_vocab_size				)

													SCREAMING_SNAKE_CASE					:      Dict     					=			None
													SCREAMING_SNAKE_CASE					:      int     					=			None
													SCREAMING_SNAKE_CASE					:      int     					=			None
													if self.use_labels:
																				SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			ids_tensor([self.batch_size]				,    self.type_sequence_label_size				)
																				SCREAMING_SNAKE_CASE					:      str     					=			ids_tensor([self.batch_size, self.seq_length]				,    self.num_labels				)
																				SCREAMING_SNAKE_CASE					:      Any     					=			ids_tensor([self.batch_size]				,    self.num_choices				)

													SCREAMING_SNAKE_CASE					:      Any     					=			self.get_config()

													return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels







						def 					__lowercase    (  self   :      List[str]				):

													"""simple docstring"""
													return NystromformerConfig(
													    vocab_size=self.vocab_size				,    hidden_size=self.hidden_size				,    num_hidden_layers=self.num_hidden_layers				,    num_attention_heads=self.num_attention_heads				,    intermediate_size=self.intermediate_size				,    hidden_act=self.hidden_act				,    hidden_dropout_prob=self.hidden_dropout_prob				,    attention_probs_dropout_prob=self.attention_probs_dropout_prob				,    max_position_embeddings=self.max_position_embeddings				,    type_vocab_size=self.type_vocab_size				,    is_decoder=a_				,    initializer_range=self.initializer_range				,    )







						def 					__lowercase    (  self   :      Tuple				,    lowerCAmelCase__   :      List[Any]				,    lowerCAmelCase__   :      Any				,    lowerCAmelCase__   :      Dict				,    lowerCAmelCase__   :      Dict				,    lowerCAmelCase__   :      Any				,    lowerCAmelCase__   :      Dict				,    lowerCAmelCase__   :      Tuple				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Tuple     					=			NystromformerModel(config=a_				)
													model.to(a_				)
													model.eval()
													SCREAMING_SNAKE_CASE					:      List[str]     					=			model(a_				,    attention_mask=a_				,    token_type_ids=a_				)
													SCREAMING_SNAKE_CASE					:      str     					=			model(a_				,    token_type_ids=a_				)
													SCREAMING_SNAKE_CASE					:      int     					=			model(a_				)
													self.parent.assertEqual(result.last_hidden_state.shape				,    (self.batch_size, self.seq_length, self.hidden_size)				)







						def 					__lowercase    (  self   :      Any				,    lowerCAmelCase__   :      int				,    lowerCAmelCase__   :      str				,    lowerCAmelCase__   :      Any				,    lowerCAmelCase__   :      List[Any]				,    lowerCAmelCase__   :      Union[str, Any]				,    lowerCAmelCase__   :      Union[str, Any]				,    lowerCAmelCase__   :      str				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      int     					=			NystromformerForMaskedLM(config=a_				)
													model.to(a_				)
													model.eval()
													SCREAMING_SNAKE_CASE					:      str     					=			model(a_				,    attention_mask=a_				,    token_type_ids=a_				,    labels=a_				)
													self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.seq_length, self.vocab_size)				)







						def 					__lowercase    (  self   :      Optional[Any]				,    lowerCAmelCase__   :      List[Any]				,    lowerCAmelCase__   :      Any				,    lowerCAmelCase__   :      int				,    lowerCAmelCase__   :      Union[str, Any]				,    lowerCAmelCase__   :      List[str]				,    lowerCAmelCase__   :      Any				,    lowerCAmelCase__   :      Tuple				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Tuple     					=			NystromformerForQuestionAnswering(config=a_				)
													model.to(a_				)
													model.eval()
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			model(
													    a_				,    attention_mask=a_				,    token_type_ids=a_				,    start_positions=a_				,    end_positions=a_				,    )
													self.parent.assertEqual(result.start_logits.shape				,    (self.batch_size, self.seq_length)				)
													self.parent.assertEqual(result.end_logits.shape				,    (self.batch_size, self.seq_length)				)







						def 					__lowercase    (  self   :      Union[str, Any]				,    lowerCAmelCase__   :      Any				,    lowerCAmelCase__   :      Optional[int]				,    lowerCAmelCase__   :      Tuple				,    lowerCAmelCase__   :      List[Any]				,    lowerCAmelCase__   :      Dict				,    lowerCAmelCase__   :      Optional[int]				,    lowerCAmelCase__   :      Any				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      int     					=			self.num_labels
													SCREAMING_SNAKE_CASE					:      str     					=			NystromformerForSequenceClassification(a_				)
													model.to(a_				)
													model.eval()
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			model(a_				,    attention_mask=a_				,    token_type_ids=a_				,    labels=a_				)
													self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.num_labels)				)







						def 					__lowercase    (  self   :      Optional[Any]				,    lowerCAmelCase__   :      str				,    lowerCAmelCase__   :      Dict				,    lowerCAmelCase__   :      Dict				,    lowerCAmelCase__   :      List[Any]				,    lowerCAmelCase__   :      List[Any]				,    lowerCAmelCase__   :      str				,    lowerCAmelCase__   :      Union[str, Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      int     					=			self.num_labels
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			NystromformerForTokenClassification(config=a_				)
													model.to(a_				)
													model.eval()
													SCREAMING_SNAKE_CASE					:      Tuple     					=			model(a_				,    attention_mask=a_				,    token_type_ids=a_				,    labels=a_				)
													self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.seq_length, self.num_labels)				)







						def 					__lowercase    (  self   :      Optional[Any]				,    lowerCAmelCase__   :      Tuple				,    lowerCAmelCase__   :      str				,    lowerCAmelCase__   :      Optional[int]				,    lowerCAmelCase__   :      Any				,    lowerCAmelCase__   :      Optional[Any]				,    lowerCAmelCase__   :      int				,    lowerCAmelCase__   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Any     					=			self.num_choices
													SCREAMING_SNAKE_CASE					:      Dict     					=			NystromformerForMultipleChoice(config=a_				)
													model.to(a_				)
													model.eval()
													SCREAMING_SNAKE_CASE					:      int     					=			input_ids.unsqueeze(1				).expand(-1				,    self.num_choices				,    -1				).contiguous()
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			token_type_ids.unsqueeze(1				).expand(-1				,    self.num_choices				,    -1				).contiguous()
													SCREAMING_SNAKE_CASE					:      int     					=			input_mask.unsqueeze(1				).expand(-1				,    self.num_choices				,    -1				).contiguous()
													SCREAMING_SNAKE_CASE					:      int     					=			model(
													    a_				,    attention_mask=a_				,    token_type_ids=a_				,    labels=a_				,    )
													self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.num_choices)				)







						def 					__lowercase    (  self   :      str				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.prepare_config_and_inputs()
													(
													    SCREAMING_SNAKE_CASE      
													)					:      List[Any]     					=			config_and_inputs
													SCREAMING_SNAKE_CASE					:      str     					=			{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
													return config, inputs_dict


@require_torch
class 	lowerCamelCase_							(					__a    ,				__a    ,				unittest.TestCase			):
						_lowerCAmelCase     :   Optional[Any]	     =				(
						    (
						        NystromformerModel,
						        NystromformerForMaskedLM,
						        NystromformerForMultipleChoice,
						        NystromformerForQuestionAnswering,
						        NystromformerForSequenceClassification,
						        NystromformerForTokenClassification,
						    )
						    if is_torch_available()
						    else ()
						)
						_lowerCAmelCase     :   List[Any]	     =				(
						    {
						        'feature-extraction': NystromformerModel,
						        'fill-mask': NystromformerForMaskedLM,
						        'question-answering': NystromformerForQuestionAnswering,
						        'text-classification': NystromformerForSequenceClassification,
						        'token-classification': NystromformerForTokenClassification,
						        'zero-shot': NystromformerForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)
						_lowerCAmelCase     :   Dict	     =				False
						_lowerCAmelCase     :   Optional[int]	     =				False







						def 					__lowercase    (  self   :      str				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      int     					=			NystromformerModelTester(self				)
													SCREAMING_SNAKE_CASE					:      str     					=			ConfigTester(self				,    config_class=a_				,    hidden_size=37				)







						def 					__lowercase    (  self   :      List[str]				):

													"""simple docstring"""
													self.config_tester.run_common_tests()







						def 					__lowercase    (  self   :      int				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[str]     					=			self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*a_				)







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      int     					=			self.model_tester.prepare_config_and_inputs()
													for type in ["absolute", "relative_key", "relative_key_query"]:
																				SCREAMING_SNAKE_CASE					:      Any     					=			type
																				self.model_tester.create_and_check_model(*a_				)







						def 					__lowercase    (  self   :      Optional[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_masked_lm(*a_				)







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      str     					=			self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_multiple_choice(*a_				)







						def 					__lowercase    (  self   :      Optional[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      int     					=			self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_question_answering(*a_				)







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      str     					=			self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_sequence_classification(*a_				)







						def 					__lowercase    (  self   :      str				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_token_classification(*a_				)







						@slow
						def 					__lowercase    (  self   :      int				):

													"""simple docstring"""



													for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				SCREAMING_SNAKE_CASE					:      str     					=			NystromformerModel.from_pretrained(a_				)
																				self.assertIsNotNone(a_				)


@require_torch
class 	lowerCamelCase_							(					unittest.TestCase			):







						@slow
						def 					__lowercase    (  self   :      List[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Tuple     					=			NystromformerModel.from_pretrained('''uw-madison/nystromformer-512'''				)
													SCREAMING_SNAKE_CASE					:      List[str]     					=			torch.tensor([[0, 1, 2, 3, 4, 5]]				)

													with torch.no_grad():
																				SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			model(a_				)[0]

													SCREAMING_SNAKE_CASE					:      int     					=			torch.Size((1, 6, 7_68)				)
													self.assertEqual(output.shape				,    a_				)

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			torch.tensor(
													    [[[-0.4532, -0.0936, 0.5137], [-0.2676, 0.0628, 0.6186], [-0.3629, -0.1726, 0.4716]]]				)

													self.assertTrue(torch.allclose(output[:, :3, :3]				,    a_				,    atol=1e-4				)				)







						@slow
						def 					__lowercase    (  self   :      Any				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			"""the [MASK] of Belgium is Brussels"""

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			AutoTokenizer.from_pretrained('''uw-madison/nystromformer-512'''				)
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			NystromformerForMaskedLM.from_pretrained('''uw-madison/nystromformer-512'''				)

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			tokenizer(a_				,    return_tensors='''pt'''				)

													with torch.no_grad():
																				SCREAMING_SNAKE_CASE					:      List[Any]     					=			model(encoding.input_ids				).logits

													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			token_logits[:, 2, :].argmax(-1				)[0]

													self.assertEqual(tokenizer.decode(a_				)				,    '''capital'''				)









'''simple docstring'''



from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
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 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor
class 	lowerCamelCase_							:







						def __init__(  self   :      Optional[Any]				,    lowerCAmelCase__   :      Tuple				,    lowerCAmelCase__   :      int=3				,    lowerCAmelCase__   :      Tuple=32				,    lowerCAmelCase__   :      Union[str, Any]=3				,    lowerCAmelCase__   :      Dict=10				,    lowerCAmelCase__   :      List[Any]=[10, 20, 30, 40]				,    lowerCAmelCase__   :      List[Any]=[1, 1, 2, 1]				,    lowerCAmelCase__   :      Optional[int]=True				,    lowerCAmelCase__   :      Any=True				,    lowerCAmelCase__   :      List[str]="relu"				,    lowerCAmelCase__   :      int=3				,    lowerCAmelCase__   :      Tuple=None				,    ):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Tuple     					=			parent
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			batch_size
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			image_size
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			num_channels
													SCREAMING_SNAKE_CASE					:      str     					=			embeddings_size
													SCREAMING_SNAKE_CASE					:      str     					=			hidden_sizes
													SCREAMING_SNAKE_CASE					:      Tuple     					=			depths
													SCREAMING_SNAKE_CASE					:      Dict     					=			is_training
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			use_labels
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			hidden_act
													SCREAMING_SNAKE_CASE					:      str     					=			num_labels
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			scope
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			len(lowerCAmelCase__				)







						def 					__lowercase    (  self   :      str				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

													SCREAMING_SNAKE_CASE					:      List[Any]     					=			None
													if self.use_labels:
																				SCREAMING_SNAKE_CASE					:      List[Any]     					=			ids_tensor([self.batch_size]				,    self.num_labels				)

													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			self.get_config()
													return config, pixel_values, labels







						def 					__lowercase    (  self   :      Any				):

													"""simple docstring"""
													return RegNetConfig(
													    num_channels=self.num_channels				,    embeddings_size=self.embeddings_size				,    hidden_sizes=self.hidden_sizes				,    depths=self.depths				,    hidden_act=self.hidden_act				,    num_labels=self.num_labels				,    )







						def 					__lowercase    (  self   :      Dict				,    lowerCAmelCase__   :      Tuple				,    lowerCAmelCase__   :      Union[str, Any]				,    lowerCAmelCase__   :      Optional[int]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      int     					=			TFRegNetModel(config=lowerCAmelCase__				)
													SCREAMING_SNAKE_CASE					:      int     					=			model(lowerCAmelCase__				,    training=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 					__lowercase    (  self   :      int				,    lowerCAmelCase__   :      str				,    lowerCAmelCase__   :      int				,    lowerCAmelCase__   :      List[str]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.num_labels
													SCREAMING_SNAKE_CASE					:      Any     					=			TFRegNetForImageClassification(lowerCAmelCase__				)
													SCREAMING_SNAKE_CASE					:      Dict     					=			model(lowerCAmelCase__				,    labels=lowerCAmelCase__				,    training=lowerCAmelCase__				)
													self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.num_labels)				)







						def 					__lowercase    (  self   :      List[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      int     					=			self.prepare_config_and_inputs()
													SCREAMING_SNAKE_CASE					,SCREAMING_SNAKE_CASE					,SCREAMING_SNAKE_CASE					:      List[str]     					=			config_and_inputs
													SCREAMING_SNAKE_CASE					:      Tuple     					=			{'''pixel_values''': pixel_values}
													return config, inputs_dict


@require_tf
class 	lowerCamelCase_							(					snake_case_    ,				snake_case_    ,				unittest.TestCase			):
						_lowerCAmelCase     :   str	     =				(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
						_lowerCAmelCase     :   str	     =				(
						    {'feature-extraction': TFRegNetModel, 'image-classification': TFRegNetForImageClassification}
						    if is_tf_available()
						    else {}
						)

						_lowerCAmelCase     :   Tuple	     =				False
						_lowerCAmelCase     :   List[Any]	     =				False
						_lowerCAmelCase     :   List[str]	     =				False
						_lowerCAmelCase     :   str	     =				False
						_lowerCAmelCase     :   str	     =				False







						def 					__lowercase    (  self   :      Union[str, Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Tuple     					=			TFRegNetModelTester(self				)
													SCREAMING_SNAKE_CASE					:      Dict     					=			ConfigTester(self				,    config_class=lowerCAmelCase__				,    has_text_modality=lowerCAmelCase__				)







						def 					__lowercase    (  self   :      List[str]				):

													"""simple docstring"""
													return







						@unittest.skip(reason='''RegNet does not use inputs_embeds'''				)
						def 					__lowercase    (  self   :      Optional[int]				):

													"""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 					__lowercase    (  self   :      int				):

													"""simple docstring"""
													super().test_keras_fit()







						@unittest.skip(reason='''RegNet does not support input and output embeddings'''				)
						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													pass







						def 					__lowercase    (  self   :      int				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					,SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.model_tester.prepare_config_and_inputs_for_common()

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

																				SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			['''pixel_values''']
																				self.assertListEqual(arg_names[:1]				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Any				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													def check_hidden_states_output(lowerCAmelCase__   :      Any				,    lowerCAmelCase__   :      int				,    lowerCAmelCase__   :      Tuple				):
																				SCREAMING_SNAKE_CASE					:      List[Any]     					=			model_class(lowerCAmelCase__				)
																				SCREAMING_SNAKE_CASE					:      Dict     					=			model(**self._prepare_for_class(lowerCAmelCase__				,    lowerCAmelCase__				)				,    training=lowerCAmelCase__				)

																				SCREAMING_SNAKE_CASE					:      int     					=			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																				SCREAMING_SNAKE_CASE					:      int     					=			self.model_tester.num_stages
																				self.assertEqual(len(lowerCAmelCase__				)				,    expected_num_stages + 1				)

																				# RegNet'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 // 2, self.model_tester.image_size // 2]				,    )

													SCREAMING_SNAKE_CASE					,SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.model_tester.prepare_config_and_inputs_for_common()
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			['''basic''', '''bottleneck''']
													for model_class in self.all_model_classes:
																				for layer_type in layers_type:
																											SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			layer_type
																											SCREAMING_SNAKE_CASE					:      Tuple     					=			True
																											check_hidden_states_output(lowerCAmelCase__				,    lowerCAmelCase__				,    lowerCAmelCase__				)

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

																											check_hidden_states_output(lowerCAmelCase__				,    lowerCAmelCase__				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Union[str, Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					,SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.model_tester.prepare_config_and_inputs_for_common()

													def check_equivalence(lowerCAmelCase__   :      Tuple				,    lowerCAmelCase__   :      int				,    lowerCAmelCase__   :      Dict				,    lowerCAmelCase__   :      str={}				):
																				SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			model(lowerCAmelCase__				,    return_dict=lowerCAmelCase__				,    **lowerCAmelCase__				)
																				SCREAMING_SNAKE_CASE					:      Any     					=			model(lowerCAmelCase__				,    return_dict=lowerCAmelCase__				,    **lowerCAmelCase__				).to_tuple()

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

																											recursive_check(lowerCAmelCase__				,    lowerCAmelCase__				)

													for model_class in self.all_model_classes:
																				SCREAMING_SNAKE_CASE					:      List[Any]     					=			model_class(lowerCAmelCase__				)

																				SCREAMING_SNAKE_CASE					:      int     					=			self._prepare_for_class(lowerCAmelCase__				,    lowerCAmelCase__				)
																				SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self._prepare_for_class(lowerCAmelCase__				,    lowerCAmelCase__				)
																				check_equivalence(lowerCAmelCase__				,    lowerCAmelCase__				,    lowerCAmelCase__				)

																				SCREAMING_SNAKE_CASE					:      Optional[int]     					=			self._prepare_for_class(lowerCAmelCase__				,    lowerCAmelCase__				,    return_labels=lowerCAmelCase__				)
																				SCREAMING_SNAKE_CASE					:      str     					=			self._prepare_for_class(lowerCAmelCase__				,    lowerCAmelCase__				,    return_labels=lowerCAmelCase__				)
																				check_equivalence(lowerCAmelCase__				,    lowerCAmelCase__				,    lowerCAmelCase__				)

																				SCREAMING_SNAKE_CASE					:      Tuple     					=			self._prepare_for_class(lowerCAmelCase__				,    lowerCAmelCase__				)
																				SCREAMING_SNAKE_CASE					:      Dict     					=			self._prepare_for_class(lowerCAmelCase__				,    lowerCAmelCase__				)
																				check_equivalence(lowerCAmelCase__				,    lowerCAmelCase__				,    lowerCAmelCase__				,    {'''output_hidden_states''': True}				)

																				SCREAMING_SNAKE_CASE					:      Any     					=			self._prepare_for_class(lowerCAmelCase__				,    lowerCAmelCase__				,    return_labels=lowerCAmelCase__				)
																				SCREAMING_SNAKE_CASE					:      List[Any]     					=			self._prepare_for_class(lowerCAmelCase__				,    lowerCAmelCase__				,    return_labels=lowerCAmelCase__				)
																				check_equivalence(lowerCAmelCase__				,    lowerCAmelCase__				,    lowerCAmelCase__				,    {'''output_hidden_states''': True}				)







						def 					__lowercase    (  self   :      List[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Dict     					=			self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__				)







						@slow
						def 					__lowercase    (  self   :      Any				):

													"""simple docstring"""
													for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			TFRegNetModel.from_pretrained(lowerCAmelCase__				)
																				self.assertIsNotNone(lowerCAmelCase__				)


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






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







						@cached_property
						def 					__lowercase    (  self   :      List[str]				):

													"""simple docstring"""
													return (
													    AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]				)
													    if is_vision_available()
													    else None
													)







						@slow
						def 					__lowercase    (  self   :      str				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      str     					=			TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]				)

													SCREAMING_SNAKE_CASE					:      Dict     					=			self.default_image_processor
													SCREAMING_SNAKE_CASE					:      int     					=			prepare_img()
													SCREAMING_SNAKE_CASE					:      List[str]     					=			image_processor(images=lowerCAmelCase__				,    return_tensors='''tf'''				)

													# forward pass
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			model(**lowerCAmelCase__				,    training=lowerCAmelCase__				)

													# verify the logits
													SCREAMING_SNAKE_CASE					:      List[str]     					=			tf.TensorShape((1, 10_00)				)
													self.assertEqual(outputs.logits.shape				,    lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      List[str]     					=			tf.constant([-0.4180, -1.5051, -3.4836]				)

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




