


import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
						import torch

						from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin







class 				snake_case__:







						'''simple docstring'''




						def __init__(				self   ,						__lowercase   ,						__lowercase=None   ,						__lowercase=None   ,						__lowercase=None   ,						__lowercase="resnet50"   ,						__lowercase=3   ,						__lowercase=3_2   ,						__lowercase=3   ,						__lowercase=True   ,						__lowercase=True   ,						)					->    List[Any]:
										lowerCAmelCase_ :      int    				=				parent
										lowerCAmelCase_ :      Union[str, Any]    				=				out_indices if out_indices is not None else [4]
										lowerCAmelCase_ :      Optional[Any]    				=				stage_names
										lowerCAmelCase_ :      int    				=				out_features
										lowerCAmelCase_ :      Union[str, Any]    				=				backbone
										lowerCAmelCase_ :      List[str]    				=				batch_size
										lowerCAmelCase_ :      Any    				=				image_size
										lowerCAmelCase_ :      Any    				=				num_channels
										lowerCAmelCase_ :      List[Any]    				=				use_pretrained_backbone
										lowerCAmelCase_ :      int    				=				is_training




						def 						lowercase_ (				self							)					->    int:
										lowerCAmelCase_ :      List[str]    				=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)
										lowerCAmelCase_ :      List[str]    				=				self.get_config()

										return config, pixel_values




						def 						lowercase_ (				self							)					->    str:
										return TimmBackboneConfig(
										    image_size=self.image_size   ,						num_channels=self.num_channels   ,						out_features=self.out_features   ,						out_indices=self.out_indices   ,						stage_names=self.stage_names   ,						use_pretrained_backbone=self.use_pretrained_backbone   ,						backbone=self.backbone   ,						)




						def 						lowercase_ (				self   ,						__lowercase   ,						__lowercase							)					->    Union[str, Any]:
										lowerCAmelCase_ :      Union[str, Any]    				=				TimmBackbone(config=__lowercase							)
										model.to(__lowercase							)
										model.eval()
										with torch.no_grad():
														lowerCAmelCase_ :      Dict    				=				model(__lowercase							)
										self.parent.assertEqual(
										    result.feature_map[-1].shape   ,						(self.batch_size, model.channels[-1], 1_4, 1_4)   ,						)




						def 						lowercase_ (				self							)					->    List[Any]:
										lowerCAmelCase_ :      Dict    				=				self.prepare_config_and_inputs()
										lowerCAmelCase_				,  lowerCAmelCase_ :      int    				=				config_and_inputs
										lowerCAmelCase_ :      Union[str, Any]    				=				{'''pixel_values''': pixel_values}
										return config, inputs_dict







@require_torch
@require_timm
class 				snake_case__(							UpperCAmelCase__,						UpperCAmelCase__,						UpperCAmelCase__,						unittest.TestCase							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__      :  Optional[Any]					=							(TimmBackbone,) if is_torch_available() else ()
						SCREAMING_SNAKE_CASE__      :  Optional[Any]					=							{"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
						SCREAMING_SNAKE_CASE__      :  Dict					=							False
						SCREAMING_SNAKE_CASE__      :  Tuple					=							False
						SCREAMING_SNAKE_CASE__      :  Optional[Any]					=							False
						SCREAMING_SNAKE_CASE__      :  str					=							False




						def 						lowercase_ (				self							)					->    List[Any]:
										lowerCAmelCase_ :      Optional[Any]    				=				TimmBackboneModelTester(self							)
										lowerCAmelCase_ :      Dict    				=				ConfigTester(self   ,						config_class=__lowercase   ,						has_text_modality=__lowercase							)




						def 						lowercase_ (				self							)					->    Tuple:
										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							)					->    Optional[int]:
										lowerCAmelCase_ :      Dict    				=				'''resnet18'''
										lowerCAmelCase_ :      Dict    				=				'''microsoft/resnet-18'''

										lowerCAmelCase_ :      Union[str, Any]    				=				AutoBackbone.from_pretrained(__lowercase   ,						use_timm_backbone=__lowercase							)
										lowerCAmelCase_ :      Any    				=				AutoBackbone.from_pretrained(__lowercase							)

										self.assertEqual(len(timm_model.out_features							)   ,						len(transformers_model.out_features							)							)
										self.assertEqual(len(timm_model.stage_names							)   ,						len(transformers_model.stage_names							)							)
										self.assertEqual(timm_model.channels   ,						transformers_model.channels							)
										# Out indices are set to the last layer by default. For timm models, we don't know
										# the number of layers in advance, so we set it to (-1,), whereas for transformers
										# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
										self.assertEqual(timm_model.out_indices   ,						(-1,)							)
										self.assertEqual(transformers_model.out_indices   ,						[len(timm_model.stage_names							) - 1]							)

										lowerCAmelCase_ :      Optional[int]    				=				AutoBackbone.from_pretrained(__lowercase   ,						use_timm_backbone=__lowercase   ,						out_indices=[1, 2, 3]							)
										lowerCAmelCase_ :      List[Any]    				=				AutoBackbone.from_pretrained(__lowercase   ,						out_indices=[1, 2, 3]							)

										self.assertEqual(timm_model.out_indices   ,						transformers_model.out_indices							)
										self.assertEqual(len(timm_model.out_features							)   ,						len(transformers_model.out_features							)							)
										self.assertEqual(timm_model.channels   ,						transformers_model.channels							)




						@unittest.skip('''TimmBackbone doesn\'t support feed forward chunking'''							)
						def 						lowercase_ (				self							)					->    Optional[int]:
										pass




						@unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''							)
						def 						lowercase_ (				self							)					->    Tuple:
										pass




						@unittest.skip('''TimmBackbone initialization is managed on the timm side'''							)
						def 						lowercase_ (				self							)					->    Union[str, Any]:
										pass




						@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''							)
						def 						lowercase_ (				self							)					->    Union[str, Any]:
										pass




						@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''							)
						def 						lowercase_ (				self							)					->    Any:
										pass




						@unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''							)
						def 						lowercase_ (				self							)					->    List[Any]:
										pass




						@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''							)
						def 						lowercase_ (				self							)					->    Optional[int]:
										pass




						@unittest.skip('''model weights aren\'t tied in TimmBackbone.'''							)
						def 						lowercase_ (				self							)					->    str:
										pass




						@unittest.skip('''model weights aren\'t tied in TimmBackbone.'''							)
						def 						lowercase_ (				self							)					->    List[str]:
										pass




						@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''							)
						def 						lowercase_ (				self							)					->    Tuple:
										pass




						@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''							)
						def 						lowercase_ (				self							)					->    List[Any]:
										pass




						@unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''							)
						def 						lowercase_ (				self							)					->    List[str]:
										pass




						@unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''							)
						def 						lowercase_ (				self							)					->    int:
										pass




						@unittest.skip('''Safetensors is not supported by timm.'''							)
						def 						lowercase_ (				self							)					->    Union[str, Any]:
										pass




						@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''							)
						def 						lowercase_ (				self							)					->    int:
										pass




						def 						lowercase_ (				self							)					->    Any:
										lowerCAmelCase_				,  lowerCAmelCase_ :      int    				=				self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
														lowerCAmelCase_ :      Dict    				=				model_class(__lowercase							)
														lowerCAmelCase_ :      Dict    				=				inspect.signature(model.forward							)
														# signature.parameters is an OrderedDict => so arg_names order is deterministic
														lowerCAmelCase_ :      List[Any]    				=				[*signature.parameters.keys()]

														lowerCAmelCase_ :      Optional[int]    				=				['''pixel_values''']
														self.assertListEqual(arg_names[:1]   ,						__lowercase							)




						def 						lowercase_ (				self							)					->    Union[str, Any]:
										lowerCAmelCase_				,  lowerCAmelCase_ :      Optional[Any]    				=				self.model_tester.prepare_config_and_inputs_for_common()
										lowerCAmelCase_ :      int    				=				True
										lowerCAmelCase_ :      Dict    				=				self.has_attentions

										# no need to test all models as different heads yield the same functionality
										lowerCAmelCase_ :      Tuple    				=				self.all_model_classes[0]
										lowerCAmelCase_ :      Dict    				=				model_class(__lowercase							)
										model.to(__lowercase							)

										lowerCAmelCase_ :      Optional[int]    				=				self._prepare_for_class(__lowercase   ,						__lowercase							)
										lowerCAmelCase_ :      Dict    				=				model(**__lowercase							)
										lowerCAmelCase_ :      str    				=				outputs[0][-1]

										# Encoder-/Decoder-only models
										lowerCAmelCase_ :      List[str]    				=				outputs.hidden_states[0]
										hidden_states.retain_grad()

										if self.has_attentions:
														lowerCAmelCase_ :      Dict    				=				outputs.attentions[0]
														attentions.retain_grad()

										output.flatten()[0].backward(retain_graph=__lowercase							)

										self.assertIsNotNone(hidden_states.grad							)

										if self.has_attentions:
														self.assertIsNotNone(attentions.grad							)




						def 						lowercase_ (				self							)					->    List[Any]:
										lowerCAmelCase_				,  lowerCAmelCase_ :      Dict    				=				self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
														lowerCAmelCase_ :      int    				=				model_class(__lowercase							)
														model.to(__lowercase							)
														model.eval()
														lowerCAmelCase_ :      Tuple    				=				model(**__lowercase							)

														self.assertEqual(len(result.feature_maps							)   ,						len(config.out_indices							)							)
														self.assertEqual(len(model.channels							)   ,						len(config.out_indices							)							)

														# Check output of last stage is taken if out_features=None, out_indices=None
														lowerCAmelCase_ :      int    				=				copy.deepcopy(__lowercase							)
														lowerCAmelCase_ :      Any    				=				None
														lowerCAmelCase_ :      Union[str, Any]    				=				model_class(__lowercase							)
														model.to(__lowercase							)
														model.eval()
														lowerCAmelCase_ :      Dict    				=				model(**__lowercase							)

														self.assertEqual(len(result.feature_maps							)   ,						1							)
														self.assertEqual(len(model.channels							)   ,						1							)

														# Check backbone can be initialized with fresh weights
														lowerCAmelCase_ :      int    				=				copy.deepcopy(__lowercase							)
														lowerCAmelCase_ :      Dict    				=				False
														lowerCAmelCase_ :      Optional[Any]    				=				model_class(__lowercase							)
														model.to(__lowercase							)
														model.eval()
														lowerCAmelCase_ :      Union[str, Any]    				=				model(**__lowercase							)



from __future__ import annotations



def 			lowerCAmelCase (		lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ ,   )-> tuple:
				if (electron_conc, hole_conc, intrinsic_conc).count(0 ) != 1:
								raise ValueError('''You cannot supply more or less than 2 values''' )
				elif electron_conc < 0:
								raise ValueError('''Electron concentration cannot be negative in a semiconductor''' )
				elif hole_conc < 0:
								raise ValueError('''Hole concentration cannot be negative in a semiconductor''' )
				elif intrinsic_conc < 0:
								raise ValueError(
								    '''Intrinsic concentration cannot be negative in a semiconductor''' )
				elif electron_conc == 0:
								return (
								    "electron_conc",
								    intrinsic_conc**2 / hole_conc,
								)
				elif hole_conc == 0:
								return (
								    "hole_conc",
								    intrinsic_conc**2 / electron_conc,
								)
				elif intrinsic_conc == 0:
								return (
								    "intrinsic_conc",
								    (electron_conc * hole_conc) ** 0.5,
								)
				else:
								return (-1, -1)


if __name__ == "__main__":
						import doctest

						doctest.testmod()