
"""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  snake_case     :

							def __init__(self       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_=3       ,       SCREAMING_SNAKE_CASE_=32       ,       SCREAMING_SNAKE_CASE_=3       ,       SCREAMING_SNAKE_CASE_=10       ,       SCREAMING_SNAKE_CASE_=[10, 20, 30, 40]       ,       SCREAMING_SNAKE_CASE_=[1, 1, 2, 1]       ,       SCREAMING_SNAKE_CASE_=True       ,       SCREAMING_SNAKE_CASE_=True       ,       SCREAMING_SNAKE_CASE_="relu"       ,       SCREAMING_SNAKE_CASE_=3       ,       SCREAMING_SNAKE_CASE_=None       ,       ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = parent
									SCREAMING_SNAKE_CASE_						 = batch_size
									SCREAMING_SNAKE_CASE_						 = image_size
									SCREAMING_SNAKE_CASE_						 = num_channels
									SCREAMING_SNAKE_CASE_						 = embeddings_size
									SCREAMING_SNAKE_CASE_						 = hidden_sizes
									SCREAMING_SNAKE_CASE_						 = depths
									SCREAMING_SNAKE_CASE_						 = is_training
									SCREAMING_SNAKE_CASE_						 = use_labels
									SCREAMING_SNAKE_CASE_						 = hidden_act
									SCREAMING_SNAKE_CASE_						 = num_labels
									SCREAMING_SNAKE_CASE_						 = scope
									SCREAMING_SNAKE_CASE_						 = len(SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self    ):

									"""simple docstring"""







									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 _lowercase					(self    ):

									"""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       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = TFRegNetModel(config=SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = model(SCREAMING_SNAKE_CASE_       ,       training=SCREAMING_SNAKE_CASE_    )
									# 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       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.num_labels
									SCREAMING_SNAKE_CASE_						 = TFRegNetForImageClassification(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = model(SCREAMING_SNAKE_CASE_       ,       labels=SCREAMING_SNAKE_CASE_       ,       training=SCREAMING_SNAKE_CASE_    )
									self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.num_labels)    )







							def _lowercase					(self    ):

									"""simple docstring"""







									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_tf
class  snake_case     (							__lowercase       ,			__lowercase       ,			unittest.TestCase   ):
							UpperCAmelCase__						     =      (TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
							UpperCAmelCase__						     =      (
							    {'''feature-extraction''': TFRegNetModel, '''image-classification''': TFRegNetForImageClassification}
							    if is_tf_available()
							    else {}
							)

							UpperCAmelCase__						     =      False
							UpperCAmelCase__						     =      False
							UpperCAmelCase__						     =      False
							UpperCAmelCase__						     =      False
							UpperCAmelCase__						     =      False

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = TFRegNetModelTester(self    )
									SCREAMING_SNAKE_CASE_						 = ConfigTester(self       ,       config_class=SCREAMING_SNAKE_CASE_       ,       has_text_modality=SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self    ):

									"""simple docstring"""







									return

							@unittest.skip(reason='''RegNet does not use inputs_embeds'''    )
							def _lowercase					(self    ):

									"""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    ):

									"""simple docstring"""







									super().test_keras_fit()

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

									"""simple docstring"""







									pass

							def _lowercase					(self    ):

									"""simple docstring"""







									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(SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = inspect.signature(model.call    )
											# 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]       ,       SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self    ):

									"""simple docstring"""







									def check_hidden_states_output(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):
											SCREAMING_SNAKE_CASE_						 = model_class(SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )       ,       training=SCREAMING_SNAKE_CASE_    )

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

											SCREAMING_SNAKE_CASE_						 = self.model_tester.num_stages
											self.assertEqual(len(SCREAMING_SNAKE_CASE_    )       ,       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_						 = self.model_tester.prepare_config_and_inputs_for_common()
									SCREAMING_SNAKE_CASE_						 = ['''basic''', '''bottleneck''']
									for model_class in self.all_model_classes:
											for layer_type in layers_type:
													SCREAMING_SNAKE_CASE_						 = layer_type
													SCREAMING_SNAKE_CASE_						 = True
													check_hidden_states_output(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

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

													check_hidden_states_output(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_						 = self.model_tester.prepare_config_and_inputs_for_common()

									def check_equivalence(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_={}    ):
											SCREAMING_SNAKE_CASE_						 = model(SCREAMING_SNAKE_CASE_       ,       return_dict=SCREAMING_SNAKE_CASE_       ,       **SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = model(SCREAMING_SNAKE_CASE_       ,       return_dict=SCREAMING_SNAKE_CASE_       ,       **SCREAMING_SNAKE_CASE_    ).to_tuple()

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

													recursive_check(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									for model_class in self.all_model_classes:
											SCREAMING_SNAKE_CASE_						 = model_class(SCREAMING_SNAKE_CASE_    )

											SCREAMING_SNAKE_CASE_						 = self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )
											check_equivalence(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

											SCREAMING_SNAKE_CASE_						 = self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       return_labels=SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       return_labels=SCREAMING_SNAKE_CASE_    )
											check_equivalence(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

											SCREAMING_SNAKE_CASE_						 = self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )
											check_equivalence(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       {'''output_hidden_states''': True}    )

											SCREAMING_SNAKE_CASE_						 = self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       return_labels=SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       return_labels=SCREAMING_SNAKE_CASE_    )
											check_equivalence(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       {'''output_hidden_states''': True}    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_    )







							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											SCREAMING_SNAKE_CASE_						 = TFRegNetModel.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )







def        _lowerCamelCase ( ):
		SCREAMING_SNAKE_CASE_						 = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''    )
		return image





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

							@cached_property
							def _lowercase					(self    ):

									"""simple docstring"""







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







							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )

									SCREAMING_SNAKE_CASE_						 = self.default_image_processor
									SCREAMING_SNAKE_CASE_						 = prepare_img()
									SCREAMING_SNAKE_CASE_						 = image_processor(images=SCREAMING_SNAKE_CASE_       ,       return_tensors='''tf'''    )

									# forward pass
									SCREAMING_SNAKE_CASE_						 = model(**SCREAMING_SNAKE_CASE_       ,       training=SCREAMING_SNAKE_CASE_    )

									# verify the logits
									SCREAMING_SNAKE_CASE_						 = tf.TensorShape((1, 10_00)    )
									self.assertEqual(outputs.logits.shape       ,       SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = tf.constant([-0.41_80, -1.50_51, -3.48_36]    )

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

"""simple docstring"""




import json
import os
import unittest

from transformers.models.ctrl.tokenization_ctrl import VOCAB_FILES_NAMES, CTRLTokenizer

from ...test_tokenization_common import TokenizerTesterMixin





class  snake_case     (							__lowercase       ,			unittest.TestCase   ):
							UpperCAmelCase__						     =      CTRLTokenizer
							UpperCAmelCase__						     =      False
							UpperCAmelCase__						     =      False

							def _lowercase					(self    ):

									"""simple docstring"""







									super().setUp()

									# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
									SCREAMING_SNAKE_CASE_						 = ['''adapt''', '''re@@''', '''a@@''', '''apt''', '''c@@''', '''t''', '''<unk>''']
									SCREAMING_SNAKE_CASE_						 = dict(zip(SCREAMING_SNAKE_CASE_       ,       range(len(SCREAMING_SNAKE_CASE_    )    )    )    )
									SCREAMING_SNAKE_CASE_						 = ['''#version: 0.2''', '''a p''', '''ap t</w>''', '''r e''', '''a d''', '''ad apt</w>''', '''''']
									SCREAMING_SNAKE_CASE_						 = {'''unk_token''': '''<unk>'''}

									SCREAMING_SNAKE_CASE_						 = os.path.join(self.tmpdirname       ,       VOCAB_FILES_NAMES['''vocab_file''']    )
									SCREAMING_SNAKE_CASE_						 = os.path.join(self.tmpdirname       ,       VOCAB_FILES_NAMES['''merges_file''']    )
									with open(self.vocab_file       ,       '''w'''       ,       encoding='''utf-8'''    ) as fp:
											fp.write(json.dumps(SCREAMING_SNAKE_CASE_    ) + '''\n'''    )
									with open(self.merges_file       ,       '''w'''       ,       encoding='''utf-8'''    ) as fp:
											fp.write('''\n'''.join(SCREAMING_SNAKE_CASE_    )    )

							def _lowercase					(self       ,       **SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									kwargs.update(self.special_tokens_map    )
									return CTRLTokenizer.from_pretrained(self.tmpdirname       ,       **SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = '''adapt react readapt apt'''
									SCREAMING_SNAKE_CASE_						 = '''adapt react readapt apt'''
									return input_text, output_text







							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = CTRLTokenizer(self.vocab_file       ,       self.merges_file       ,       **self.special_tokens_map    )
									SCREAMING_SNAKE_CASE_						 = '''adapt react readapt apt'''
									SCREAMING_SNAKE_CASE_						 = '''adapt re@@ a@@ c@@ t re@@ adapt apt'''.split()
									SCREAMING_SNAKE_CASE_						 = tokenizer.tokenize(SCREAMING_SNAKE_CASE_    )
									self.assertListEqual(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = tokens + [tokenizer.unk_token]

									SCREAMING_SNAKE_CASE_						 = [0, 1, 2, 4, 5, 1, 0, 3, 6]
									self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_    )       ,       SCREAMING_SNAKE_CASE_    )