





import inspect
import unittest

from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
						import jax
						import jax.numpy as jnp

						from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel

if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor
class SCREAMING_SNAKE_CASE_  (   unittest.TestCase   ):






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







							"""simple docstring"""


							snake_case_						:     int     =		parent
							snake_case_						:     str     =		batch_size
							snake_case_						:     Optional[Any]     =		image_size
							snake_case_						:     Any     =		num_channels
							snake_case_						:     Tuple     =		embeddings_size
							snake_case_						:     Any     =		hidden_sizes
							snake_case_						:     List[Any]     =		depths
							snake_case_						:     Dict     =		is_training
							snake_case_						:     int     =		use_labels
							snake_case_						:     Any     =		hidden_act
							snake_case_						:     str     =		num_labels
							snake_case_						:     int     =		scope
							snake_case_						:     Union[str, Any]     =		len(_A		)






						def UpperCAmelCase_			( self : Dict		)							->      Optional[Any]:







							"""simple docstring"""


							snake_case_						:     str     =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

							snake_case_						:     Tuple     =		self.get_config()

							return config, pixel_values






						def UpperCAmelCase_			( self : Dict		)							->      List[str]:







							"""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						,				image_size=self.image_size						,				)






						def UpperCAmelCase_			( self : str						,				_A : Optional[int]						,				_A : Tuple		)							->      List[Any]:







							"""simple docstring"""


							snake_case_						:     Optional[int]     =		FlaxRegNetModel(config=_A		)
							snake_case_						:     Any     =		model(_A		)

							# Output shape (b, c, h, w)
							self.parent.assertEqual(
							    result.last_hidden_state.shape						,				(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)						,				)






						def UpperCAmelCase_			( self : int						,				_A : Tuple						,				_A : List[Any]		)							->      str:







							"""simple docstring"""


							snake_case_						:     Union[str, Any]     =		self.num_labels
							snake_case_						:     List[Any]     =		FlaxRegNetForImageClassification(config=_A		)
							snake_case_						:     Optional[int]     =		model(_A		)
							self.parent.assertEqual(result.logits.shape						,				(self.batch_size, self.num_labels)		)






						def UpperCAmelCase_			( self : Any		)							->      Tuple:







							"""simple docstring"""


							snake_case_						:     Optional[int]     =		self.prepare_config_and_inputs()
							snake_case_  ,snake_case_						:     int     =		config_and_inputs
							snake_case_						:     List[str]     =		{'pixel_values': pixel_values}
							return config, inputs_dict
@require_flax
class SCREAMING_SNAKE_CASE_  (   snake_case_    ,			unittest.TestCase   ):
						__magic_name__:     Tuple	 =    (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

						__magic_name__:     List[Any]	 =    False
						__magic_name__:     Any	 =    False
						__magic_name__:     Dict	 =    False






						def UpperCAmelCase_			( self : str		)							->      None:







							"""simple docstring"""


							snake_case_						:     int     =		FlaxRegNetModelTester(self		)
							snake_case_						:     Union[str, Any]     =		ConfigTester(self						,				config_class=_A						,				has_text_modality=_A		)






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







							"""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 UpperCAmelCase_			( self : Any		)							->      Union[str, Any]:







							"""simple docstring"""


							return






						def UpperCAmelCase_			( self : Dict		)							->      Optional[Any]:







							"""simple docstring"""


							snake_case_						:     Tuple     =		self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_A		)






						def UpperCAmelCase_			( self : Any		)							->      List[str]:







							"""simple docstring"""


							snake_case_						:     Optional[int]     =		self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*_A		)






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







							"""simple docstring"""


							pass






						@unittest.skip(reason='RegNet does not support input and output embeddings'		)
						def UpperCAmelCase_			( self : Union[str, Any]		)							->      Dict:







							"""simple docstring"""


							pass






						def UpperCAmelCase_			( self : str		)							->      str:







							"""simple docstring"""


							snake_case_  ,snake_case_						:     Optional[Any]     =		self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								snake_case_						:     Any     =		model_class(_A		)
								snake_case_						:     Optional[Any]     =		inspect.signature(model.__call__		)
								# signature.parameters is an OrderedDict => so arg_names order is deterministic
								snake_case_						:     List[str]     =		[*signature.parameters.keys()]

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






						def UpperCAmelCase_			( self : str		)							->      List[Any]:







							"""simple docstring"""


							def check_hidden_states_output(_A : List[Any]						,				_A : Any						,				_A : int		):
								snake_case_						:     Optional[int]     =		model_class(_A		)

								snake_case_						:     Dict     =		model(**self._prepare_for_class(_A						,				_A		)		)

								snake_case_						:     Union[str, Any]     =		outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

								snake_case_						:     Optional[Any]     =		self.model_tester.num_stages
								self.assertEqual(len(_A		)						,				expected_num_stages + 1		)

							snake_case_  ,snake_case_						:     List[str]     =		self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								snake_case_						:     Tuple     =		True
								check_hidden_states_output(_A						,				_A						,				_A		)

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

								check_hidden_states_output(_A						,				_A						,				_A		)






						def UpperCAmelCase_			( self : List[str]		)							->      Tuple:







							"""simple docstring"""


							snake_case_  ,snake_case_						:     List[str]     =		self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								with self.subTest(model_class.__name__		):
									snake_case_						:     List[str]     =		self._prepare_for_class(_A						,				_A		)
									snake_case_						:     List[str]     =		model_class(_A		)

									@jax.jit
									def model_jitted(_A : Optional[int]						,				**_A : List[str]		):
										return model(pixel_values=_A						,				**_A		)

									with self.subTest('JIT Enabled'		):
										snake_case_						:     Tuple     =		model_jitted(**_A		).to_tuple()

									with self.subTest('JIT Disabled'		):
										with jax.disable_jit():
											snake_case_						:     Union[str, Any]     =		model_jitted(**_A		).to_tuple()

									self.assertEqual(len(_A		)						,				len(_A		)		)
									for jitted_output, output in zip(_A						,				_A		):
										self.assertEqual(jitted_output.shape						,				output.shape		)


def 							SCREAMING_SNAKE_CASE__  (      ):
	snake_case_						:     Tuple     =		Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
	return image


@require_flax
class SCREAMING_SNAKE_CASE_  (   unittest.TestCase   ):






						@cached_property
						def UpperCAmelCase_			( self : List[str]		)							->      List[str]:







							"""simple docstring"""


							return AutoImageProcessor.from_pretrained('facebook/regnet-y-040'		) if is_vision_available() else None






						@slow
						def UpperCAmelCase_			( self : Tuple		)							->      List[Any]:







							"""simple docstring"""


							snake_case_						:     Tuple     =		FlaxRegNetForImageClassification.from_pretrained('facebook/regnet-y-040'		)

							snake_case_						:     Any     =		self.default_image_processor
							snake_case_						:     List[str]     =		prepare_img()
							snake_case_						:     Any     =		image_processor(images=_A						,				return_tensors='np'		)

							snake_case_						:     Dict     =		model(**_A		)

							# verify the logits
							snake_case_						:     Union[str, Any]     =		(1, 1000)
							self.assertEqual(outputs.logits.shape						,				_A		)

							snake_case_						:     Tuple     =		jnp.array([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]		)

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








import re
import string

import numpy as np

import datasets


_SCREAMING_SNAKE_CASE 		=						"""
Returns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.
"""

_SCREAMING_SNAKE_CASE 		=						"""
Args:
    predictions: List of predicted texts.
    references: List of reference texts.
    regexes_to_ignore: List, defaults to None. Regex expressions of characters to
        ignore when calculating the exact matches. Note: these regexes are removed
        from the input data before the changes based on the options below (e.g. ignore_case,
        ignore_punctuation, ignore_numbers) are applied.
    ignore_case: Boolean, defaults to False. If true, turns everything
        to lowercase so that capitalization differences are ignored.
    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
Returns:
    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.
Examples:
    >>> exact_match = datasets.load_metric(\"exact_match\")
    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]
    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results[\"exact_match\"], 1))
    25.0

    >>> exact_match = datasets.load_metric(\"exact_match\")
    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]
    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=[\"the \", \"yell\"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results[\"exact_match\"], 1))
    50.0


    >>> exact_match = datasets.load_metric(\"exact_match\")
    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]
    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=[\"the \", \"yell\", \"YELL\"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results[\"exact_match\"], 1))
    75.0

    >>> exact_match = datasets.load_metric(\"exact_match\")
    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]
    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=[\"the \", \"yell\", \"YELL\"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)
    >>> print(round(results[\"exact_match\"], 1))
    100.0

    >>> exact_match = datasets.load_metric(\"exact_match\")
    >>> refs = [\"The cat sat on the mat.\", \"Theaters are great.\", \"It's like comparing oranges and apples.\"]
    >>> preds = [\"The cat sat on the mat?\", \"Theaters are great.\", \"It's like comparing apples and oranges.\"]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results[\"exact_match\"], 1))
    33.3

"""

_SCREAMING_SNAKE_CASE 		=						"""
"""
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION    ,			_KWARGS_DESCRIPTION   )
class SCREAMING_SNAKE_CASE_  (   datasets.Metric   ):






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







							"""simple docstring"""


							return datasets.MetricInfo(
							    description=_DESCRIPTION						,				citation=_CITATION						,				inputs_description=_KWARGS_DESCRIPTION						,				features=datasets.Features(
							        {
							            'predictions': datasets.Value('string'						,				id='sequence'		),
							            'references': datasets.Value('string'						,				id='sequence'		),
							        }		)						,				reference_urls=[]						,				)






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







							"""simple docstring"""


							if regexes_to_ignore is not None:
								for s in regexes_to_ignore:
									snake_case_						:     List[str]     =		np.array([re.sub(_A						,				''						,				_A		) for x in predictions]		)
									snake_case_						:     int     =		np.array([re.sub(_A						,				''						,				_A		) for x in references]		)
							else:
								snake_case_						:     Optional[Any]     =		np.asarray(_A		)
								snake_case_						:     Optional[Any]     =		np.asarray(_A		)

							if ignore_case:
								snake_case_						:     int     =		np.char.lower(_A		)
								snake_case_						:     List[str]     =		np.char.lower(_A		)

							if ignore_punctuation:
								snake_case_						:     str     =		string.punctuation.maketrans(''						,				''						,				string.punctuation		)
								snake_case_						:     str     =		np.char.translate(_A						,				table=_A		)
								snake_case_						:     Any     =		np.char.translate(_A						,				table=_A		)

							if ignore_numbers:
								snake_case_						:     int     =		string.digits.maketrans(''						,				''						,				string.digits		)
								snake_case_						:     Tuple     =		np.char.translate(_A						,				table=_A		)
								snake_case_						:     Optional[Any]     =		np.char.translate(_A						,				table=_A		)

							snake_case_						:     Optional[Any]     =		predictions == references

							return {"exact_match": np.mean(_A		) * 100}

