






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 			__a  (    unittest.TestCase       ):







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


      '''simple docstring'''






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







 def 					__lowercase					(		self					:   str						):


      '''simple docstring'''






      UpperCamelCase__			:   Optional[Any]       				=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

      UpperCamelCase__			:   List[str]       				=  self.get_config()

      return config, pixel_values







 def 					__lowercase					(		self					:   List[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							,   image_size=self.image_size							,   )







 def 					__lowercase					(		self					:   int							,   SCREAMING_SNAKE_CASE					:   str							,   SCREAMING_SNAKE_CASE					:   List[str]						):


      '''simple docstring'''






      UpperCamelCase__			:   Dict       				=  FlaxRegNetModel(config=_lowerCAmelCase						)
      UpperCamelCase__			:   List[str]       				=  model(_lowerCAmelCase						)

      # 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 					__lowercase					(		self					:   Optional[Any]							,   SCREAMING_SNAKE_CASE					:   Optional[int]							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]						):


      '''simple docstring'''






      UpperCamelCase__			:   List[Any]       				=  self.num_labels
      UpperCamelCase__			:   Optional[int]       				=  FlaxRegNetForImageClassification(config=_lowerCAmelCase						)
      UpperCamelCase__			:   Any       				=  model(_lowerCAmelCase						)
      self.parent.assertEqual(result.logits.shape							,   (self.batch_size, self.num_labels)						)







 def 					__lowercase					(		self					:   List[str]						):


      '''simple docstring'''






      UpperCamelCase__			:   Any       				=  self.prepare_config_and_inputs()
      UpperCamelCase__				,     UpperCamelCase__			:   Union[str, Any]       				=  config_and_inputs
      UpperCamelCase__			:   Optional[int]       				=  {"pixel_values": pixel_values}
      return config, inputs_dict







@require_flax
class 			__a  (    _SCREAMING_SNAKE_CASE       ,   unittest.TestCase       ):
 _lowerCAmelCase       :       str        = (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

 _lowerCAmelCase       :       Any        = False
 _lowerCAmelCase       :       Optional[int]        = False
 _lowerCAmelCase       :       Dict        = False







 def 					__lowercase					(		self					:   Optional[Any]						):


      '''simple docstring'''






      UpperCamelCase__			:   List[str]       				=  FlaxRegNetModelTester(self						)
      UpperCamelCase__			:   Dict       				=  ConfigTester(self							,   config_class=_lowerCAmelCase							,   has_text_modality=_lowerCAmelCase						)







 def 					__lowercase					(		self					:   str						):


      '''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 					__lowercase					(		self					:   Any						):


      '''simple docstring'''






      return







 def 					__lowercase					(		self					:   Any						):


      '''simple docstring'''






      UpperCamelCase__			:   List[str]       				=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_lowerCAmelCase						)







 def 					__lowercase					(		self					:   str						):


      '''simple docstring'''






      UpperCamelCase__			:   Dict       				=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase						)







 @unittest.skip(reason="RegNet does not use inputs_embeds"						)
 def 					__lowercase					(		self					:   List[str]						):


      '''simple docstring'''






      pass







 @unittest.skip(reason="RegNet does not support input and output embeddings"						)
 def 					__lowercase					(		self					:   Optional[int]						):


      '''simple docstring'''






      pass







 def 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      UpperCamelCase__				,     UpperCamelCase__			:   Dict       				=  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           UpperCamelCase__			:   Dict       				=  model_class(_lowerCAmelCase						)
           UpperCamelCase__			:   Tuple       				=  inspect.signature(model.__call__						)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           UpperCamelCase__			:   Tuple       				=  [*signature.parameters.keys()]

           UpperCamelCase__			:   Optional[int]       				=  ["pixel_values"]
           self.assertListEqual(arg_names[:1]							,   _lowerCAmelCase						)







 def 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      def check_hidden_states_output(SCREAMING_SNAKE_CASE					:   Union[str, Any]							,   SCREAMING_SNAKE_CASE					:   Any							,   SCREAMING_SNAKE_CASE					:   int						):
           UpperCamelCase__			:   Dict       				=  model_class(_lowerCAmelCase						)

           UpperCamelCase__			:   List[Any]       				=  model(**self._prepare_for_class(_lowerCAmelCase							,   _lowerCAmelCase						)						)

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

           UpperCamelCase__			:   List[Any]       				=  self.model_tester.num_stages
           self.assertEqual(len(_lowerCAmelCase						)							,   expected_num_stages + 1						)

      UpperCamelCase__				,     UpperCamelCase__			:   Tuple       				=  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           UpperCamelCase__			:   Optional[Any]       				=  True
           check_hidden_states_output(_lowerCAmelCase							,   _lowerCAmelCase							,   _lowerCAmelCase						)

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

           check_hidden_states_output(_lowerCAmelCase							,   _lowerCAmelCase							,   _lowerCAmelCase						)







 def 					__lowercase					(		self					:   Dict						):


      '''simple docstring'''






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

      for model_class in self.all_model_classes:
           with self.subTest(model_class.__name__						):
                UpperCamelCase__			:   Tuple       				=  self._prepare_for_class(_lowerCAmelCase							,   _lowerCAmelCase						)
                UpperCamelCase__			:   Optional[Any]       				=  model_class(_lowerCAmelCase						)

                @jax.jit
                def model_jitted(SCREAMING_SNAKE_CASE					:   Optional[Any]							,   **SCREAMING_SNAKE_CASE					:   Tuple						):
                     return model(pixel_values=_lowerCAmelCase							,   **_lowerCAmelCase						)

                with self.subTest("JIT Enabled"						):
                     UpperCamelCase__			:   List[str]       				=  model_jitted(**_lowerCAmelCase						).to_tuple()

                with self.subTest("JIT Disabled"						):
                     with jax.disable_jit():
                          UpperCamelCase__			:   Tuple       				=  model_jitted(**_lowerCAmelCase						).to_tuple()

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







def 		SCREAMING_SNAKE_CASE							(					) ->	str:
     UpperCamelCase__			:   Optional[int]       				=  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
     return image





@require_flax
class 			__a  (    unittest.TestCase       ):







 @cached_property
 def 					__lowercase					(		self					:   int						):


      '''simple docstring'''






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







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


      '''simple docstring'''






      UpperCamelCase__			:   Tuple       				=  FlaxRegNetForImageClassification.from_pretrained("facebook/regnet-y-040"						)

      UpperCamelCase__			:   List[str]       				=  self.default_image_processor
      UpperCamelCase__			:   List[Any]       				=  prepare_img()
      UpperCamelCase__			:   Dict       				=  image_processor(images=_lowerCAmelCase							,   return_tensors="np"						)

      UpperCamelCase__			:   Any       				=  model(**_lowerCAmelCase						)

      # verify the logits
      UpperCamelCase__			:   str       				=  (1, 10_00)
      self.assertEqual(outputs.logits.shape							,   _lowerCAmelCase						)

      UpperCamelCase__			:   str       				=  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]							,   _lowerCAmelCase							,   atol=1e-4						)						)





# Copyright 2021 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from packaging import version

from .. import __version__
from .constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD
from .doc import (
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    copy_func,
    replace_return_docstrings,
)
from .generic import (
    ContextManagers,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    TensorType,
    add_model_info_to_auto_map,
    cached_property,
    can_return_loss,
    expand_dims,
    find_labels,
    flatten_dict,
    infer_framework,
    is_jax_tensor,
    is_numpy_array,
    is_tensor,
    is_tf_symbolic_tensor,
    is_tf_tensor,
    is_torch_device,
    is_torch_dtype,
    is_torch_tensor,
    reshape,
    squeeze,
    strtobool,
    tensor_size,
    to_numpy,
    to_py_obj,
    transpose,
    working_or_temp_dir,
)
from .hub import (
    CLOUDFRONT_DISTRIB_PREFIX,
    DISABLE_TELEMETRY,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    EntryNotFoundError,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    cached_file,
    default_cache_path,
    define_sagemaker_information,
    download_url,
    extract_commit_hash,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    has_file,
    http_user_agent,
    is_offline_mode,
    is_remote_url,
    move_cache,
    send_example_telemetry,
    try_to_load_from_cache,
)
from .import_utils import (
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    TORCH_FX_REQUIRED_VERSION,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    DummyObject,
    OptionalDependencyNotAvailable,
    _LazyModule,
    ccl_version,
    direct_transformers_import,
    get_torch_version,
    is_accelerate_available,
    is_apex_available,
    is_bitsandbytes_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_cython_available,
    is_datasets_available,
    is_decord_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_jieba_available,
    is_jumanpp_available,
    is_kenlm_available,
    is_keras_nlp_available,
    is_librosa_available,
    is_natten_available,
    is_ninja_available,
    is_onnx_available,
    is_openai_available,
    is_optimum_available,
    is_pandas_available,
    is_peft_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytest_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sacremoses_available,
    is_safetensors_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_sudachi_available,
    is_tensorflow_probability_available,
    is_tensorflow_text_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_bfaa_cpu_available,
    is_torch_bfaa_gpu_available,
    is_torch_compile_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_neuroncore_available,
    is_torch_tensorrt_fx_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_torchdistx_available,
    is_torchdynamo_available,
    is_torchvision_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    requires_backends,
    torch_only_method,
)


lowerCamelCase__ :   str					=							'pytorch_model.bin'
lowerCamelCase__ :   int					=							'pytorch_model.bin.index.json'
lowerCamelCase__ :   List[Any]					=							'adapter_config.json'
lowerCamelCase__ :   Optional[int]					=							'adapter_model.bin'
lowerCamelCase__ :   Dict					=							'adapter_model.safetensors'
lowerCamelCase__ :   List[str]					=							'tf_model.h5'
lowerCamelCase__ :   Tuple					=							'tf_model.h5.index.json'
lowerCamelCase__ :   Optional[int]					=							'model.ckpt'
lowerCamelCase__ :   Any					=							'flax_model.msgpack'
lowerCamelCase__ :   List[Any]					=							'flax_model.msgpack.index.json'
lowerCamelCase__ :   int					=							'model.safetensors'
lowerCamelCase__ :   str					=							'model.safetensors.index.json'
lowerCamelCase__ :   Union[str, Any]					=							'config.json'
lowerCamelCase__ :   List[Any]					=							'preprocessor_config.json'
lowerCamelCase__ :   Optional[int]					=							FEATURE_EXTRACTOR_NAME
lowerCamelCase__ :   Any					=							'generation_config.json'
lowerCamelCase__ :   Any					=							'modelcard.json'

lowerCamelCase__ :   List[str]					=							'▁'
lowerCamelCase__ :   Union[str, Any]					=							SENTENCEPIECE_UNDERLINE  # Kept for backward compatibility

lowerCamelCase__ :   Optional[int]					=							[
    [[0, 1, 0, 1], [1, 0, 0, 1]]
] * 2  # Needs to have 0s and 1s only since XLM uses it for langs too.
lowerCamelCase__ :   str					=							[[7, 6, 0, 0, 1], [1, 2, 3, 0, 0], [0, 0, 0, 4, 5]]
lowerCamelCase__ :   Dict					=							[[1, 1, 1, 1, 1], [1, 1, 1, 0, 0], [0, 0, 0, 1, 1]]

def 					UpperCAmelCase_							(      __UpperCAmelCase						:	Optional[int]							)					-> int:
      if version.parse(__UpperCAmelCase							) < version.parse(__UpperCAmelCase							):
            if "dev" in min_version:
                  SCREAMING_SNAKE_CASE_							=			(
                      'This example requires a source install from HuggingFace Transformers (see '
                      '`https://huggingface.co/docs/transformers/installation#install-from-source`),'
                  )
            else:
                  SCREAMING_SNAKE_CASE_							=			f"This example requires a minimum version of {min_version},"
            error_message += f" but the version found is {__version__}.\n"
            raise ImportError(
                error_message
                + 'Check out https://github.com/huggingface/transformers/tree/main/examples#important-note for the examples corresponding to other '
                'versions of HuggingFace Transformers.'							)