

'''simple docstring'''





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[Any]		,					UpperCAmelCase__     :		int		,					UpperCAmelCase__     :		int=3		,					UpperCAmelCase__     :		Optional[int]=32		,					UpperCAmelCase__     :		List[str]=3		,					UpperCAmelCase__     :		Tuple=10		,					UpperCAmelCase__     :		List[str]=[10, 20, 30, 40]		,					UpperCAmelCase__     :		Any=[1, 1, 2, 1]		,					UpperCAmelCase__     :		Optional[Any]=True		,					UpperCAmelCase__     :		Optional[int]=True		,					UpperCAmelCase__     :		List[Any]="relu"		,					UpperCAmelCase__     :		Optional[Any]=3		,					UpperCAmelCase__     :		Tuple=None		,					):
										'''simple docstring'''
										lowercase :							List[Any]    		=parent
										lowercase :							str    		=batch_size
										lowercase :							Optional[int]    		=image_size
										lowercase :							List[Any]    		=num_channels
										lowercase :							Tuple    		=embeddings_size
										lowercase :							int    		=hidden_sizes
										lowercase :							List[str]    		=depths
										lowercase :							Any    		=is_training
										lowercase :							List[Any]    		=use_labels
										lowercase :							Tuple    		=hidden_act
										lowercase :							Dict    		=num_labels
										lowercase :							List[str]    		=scope
										lowercase :							Dict    		=len(UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		int   ):
										'''simple docstring'''
										lowercase :							Any    		=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

										lowercase :							int    		=self.get_config()

										return config, pixel_values







				def  lowerCamelCase_	(       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  lowerCamelCase_	(       self     :		Union[str, Any]		,					UpperCAmelCase__     :		Union[str, Any]		,					UpperCAmelCase__     :		Optional[Any]   ):
										'''simple docstring'''
										lowercase :							Tuple    		=FlaxRegNetModel(config=UpperCAmelCase__   )
										lowercase :							int    		=model(UpperCAmelCase__   )

										# 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  lowerCamelCase_	(       self     :		str		,					UpperCAmelCase__     :		List[Any]		,					UpperCAmelCase__     :		Optional[Any]   ):
										'''simple docstring'''
										lowercase :							Dict    		=self.num_labels
										lowercase :							Optional[Any]    		=FlaxRegNetForImageClassification(config=UpperCAmelCase__   )
										lowercase :							List[str]    		=model(UpperCAmelCase__   )
										self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_labels)   )







				def  lowerCamelCase_	(       self     :		str   ):
										'''simple docstring'''
										lowercase :							Optional[Any]    		=self.prepare_config_and_inputs()
										lowercase		,	lowercase :							Any    		=config_and_inputs
										lowercase :							Tuple    		={'''pixel_values''': pixel_values}
										return config, inputs_dict





@require_flax
class 		__SCREAMING_SNAKE_CASE							(			lowercase__						,							unittest.TestCase      ):
				lowerCamelCase_		       =    (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

				lowerCamelCase_		       =    False
				lowerCamelCase_		       =    False
				lowerCamelCase_		       =    False







				def  lowerCamelCase_	(       self     :		List[str]   ):
										'''simple docstring'''
										lowercase :							int    		=FlaxRegNetModelTester(self   )
										lowercase :							Tuple    		=ConfigTester(self		,					config_class=UpperCAmelCase__		,					has_text_modality=UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		Tuple   ):
										'''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  lowerCamelCase_	(       self     :		Optional[int]   ):
										'''simple docstring'''
										return







				def  lowerCamelCase_	(       self     :		List[str]   ):
										'''simple docstring'''
										lowercase :							List[str]    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		Optional[int]   ):
										'''simple docstring'''
										lowercase :							Tuple    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase__   )







				@unittest.skip(reason='''RegNet does not use inputs_embeds'''   )
				def  lowerCamelCase_	(       self     :		str   ):
										'''simple docstring'''
										pass







				@unittest.skip(reason='''RegNet does not support input and output embeddings'''   )
				def  lowerCamelCase_	(       self     :		str   ):
										'''simple docstring'''
										pass







				def  lowerCamelCase_	(       self     :		List[str]   ):
										'''simple docstring'''
										lowercase		,	lowercase :							Optional[Any]    		=self.model_tester.prepare_config_and_inputs_for_common()

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

																lowercase :							List[str]    		=['''pixel_values''']
																self.assertListEqual(arg_names[:1]		,					UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		Optional[Any]   ):
										'''simple docstring'''
										def check_hidden_states_output(UpperCAmelCase__     :		str		,					UpperCAmelCase__     :		Any		,					UpperCAmelCase__     :		Optional[int]   ):
																lowercase :							Union[str, Any]    		=model_class(UpperCAmelCase__   )

																lowercase :							Tuple    		=model(**self._prepare_for_class(UpperCAmelCase__		,					UpperCAmelCase__   )   )

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

																lowercase :							int    		=self.model_tester.num_stages
																self.assertEqual(len(UpperCAmelCase__   )		,					expected_num_stages + 1   )

										lowercase		,	lowercase :							Optional[int]    		=self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																lowercase :							List[str]    		=True
																check_hidden_states_output(UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__   )

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

																check_hidden_states_output(UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		List[Any]   ):
										'''simple docstring'''
										lowercase		,	lowercase :							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__   ):
																						lowercase :							List[Any]    		=self._prepare_for_class(UpperCAmelCase__		,					UpperCAmelCase__   )
																						lowercase :							Optional[Any]    		=model_class(UpperCAmelCase__   )

																						@jax.jit
																						def model_jitted(UpperCAmelCase__     :		Any		,					**UpperCAmelCase__     :		List[Any]   ):
																												return model(pixel_values=UpperCAmelCase__		,					**UpperCAmelCase__   )

																						with self.subTest('''JIT Enabled'''   ):
																												lowercase :							Union[str, Any]    		=model_jitted(**UpperCAmelCase__   ).to_tuple()

																						with self.subTest('''JIT Disabled'''   ):
																												with jax.disable_jit():
																																		lowercase :							int    		=model_jitted(**UpperCAmelCase__   ).to_tuple()

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






def 				_lowerCAmelCase			(   )				->  int:
						lowercase :							Dict    		=Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
						return image







@require_flax
class 		__SCREAMING_SNAKE_CASE							(			unittest.TestCase      ):







				@cached_property
				def  lowerCamelCase_	(       self     :		List[Any]   ):
										'''simple docstring'''
										return AutoImageProcessor.from_pretrained('''facebook/regnet-y-040'''   ) if is_vision_available() else None







				@slow
				def  lowerCamelCase_	(       self     :		Dict   ):
										'''simple docstring'''
										lowercase :							int    		=FlaxRegNetForImageClassification.from_pretrained('''facebook/regnet-y-040'''   )

										lowercase :							Tuple    		=self.default_image_processor
										lowercase :							Union[str, Any]    		=prepare_img()
										lowercase :							Any    		=image_processor(images=UpperCAmelCase__		,					return_tensors='''np'''   )

										lowercase :							Union[str, Any]    		=model(**UpperCAmelCase__   )

										# verify the logits
										lowercase :							str    		=(1, 1000)
										self.assertEqual(outputs.logits.shape		,					UpperCAmelCase__   )

										lowercase :							Dict    		=jnp.array([-0.41_80, -1.50_51, -3.48_36]   )

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






# coding=utf-8
# Copyright 2023 The HuggingFace Inc. team.
#
# 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.

# this script dumps information about the environment

import os
import platform
import sys


UpperCAmelCase_           =				'''3'''

print('''Python version:''', sys.version)

print('''OS platform:''', platform.platform())
print('''OS architecture:''', platform.machine())

try:
  import torch

  print('''Torch version:''', torch.__version__)
  print('''Cuda available:''', torch.cuda.is_available())
  print('''Cuda version:''', torch.version.cuda)
  print('''CuDNN version:''', torch.backends.cudnn.version())
  print('''Number of GPUs available:''', torch.cuda.device_count())
except ImportError:
  print('''Torch version:''', None)

try:
  import transformers

  print('''transformers version:''', transformers.__version__)
except ImportError:
  print('''transformers version:''', None)