


'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__lowercase:						Optional[Any]  		=   {
    'configuration_flava': [
        'FLAVA_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'FlavaConfig',
        'FlavaImageCodebookConfig',
        'FlavaImageConfig',
        'FlavaMultimodalConfig',
        'FlavaTextConfig',
    ],
}

try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowercase:						int  		=   ['FlavaFeatureExtractor']
       __lowercase:						str  		=   ['FlavaImageProcessor']
       __lowercase:						Optional[Any]  		=   ['FlavaProcessor']

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowercase:						Optional[int]  		=   [
           'FLAVA_PRETRAINED_MODEL_ARCHIVE_LIST',
           'FlavaForPreTraining',
           'FlavaImageCodebook',
           'FlavaImageModel',
           'FlavaModel',
           'FlavaMultimodalModel',
           'FlavaPreTrainedModel',
           'FlavaTextModel',
       ]

if TYPE_CHECKING:
       from .configuration_flava import (
           FLAVA_PRETRAINED_CONFIG_ARCHIVE_MAP,
           FlavaConfig,
           FlavaImageCodebookConfig,
           FlavaImageConfig,
           FlavaMultimodalConfig,
           FlavaTextConfig,
       )

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_flava import FlavaFeatureExtractor
              from .image_processing_flava import FlavaImageProcessor
              from .processing_flava import FlavaProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_flava import (
                  FLAVA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  FlavaForPreTraining,
                  FlavaImageCodebook,
                  FlavaImageModel,
                  FlavaModel,
                  FlavaMultimodalModel,
                  FlavaPreTrainedModel,
                  FlavaTextModel,
              )

else:
       import sys

       __lowercase:						Tuple  		=   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType







@require_torch
class      __lowercase  :





							"""simple docstring"""







							_UpperCAmelCase     =		()
							_UpperCAmelCase     =		True






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= self.config_class

										# test default config
										SCREAMING_SNAKE_CASE_						:			Tuple       						= config_class()
										self.assertIsNotNone(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Dict       						= ['stem'] + [F'''stage{idx}''' for idx in range(1       ,		len(config.depths    ) + 1    )]
										self.assertEqual(config.stage_names       ,		lowerCAmelCase__    )
										self.assertTrue(set(config.out_features    ).issubset(set(config.stage_names    )    )    )

										# Test out_features and out_indices are correctly set
										# out_features and out_indices both None
										SCREAMING_SNAKE_CASE_						:			List[Any]       						= config_class(out_features=lowerCAmelCase__       ,		out_indices=lowerCAmelCase__    )
										self.assertEqual(config.out_features       ,		[config.stage_names[-1]]    )
										self.assertEqual(config.out_indices       ,		[len(config.stage_names    ) - 1]    )

										# out_features and out_indices both set
										SCREAMING_SNAKE_CASE_						:			str       						= config_class(out_features=['stem', 'stage1']       ,		out_indices=[0, 1]    )
										self.assertEqual(config.out_features       ,		['stem', 'stage1']    )
										self.assertEqual(config.out_indices       ,		[0, 1]    )

										# Only out_features set
										SCREAMING_SNAKE_CASE_						:			List[str]       						= config_class(out_features=['stage1', 'stage3']    )
										self.assertEqual(config.out_features       ,		['stage1', 'stage3']    )
										self.assertEqual(config.out_indices       ,		[1, 3]    )

										# Only out_indices set
										SCREAMING_SNAKE_CASE_						:			List[Any]       						= config_class(out_indices=[0, 2]    )
										self.assertEqual(config.out_features       ,		[config.stage_names[0], config.stage_names[2]]    )
										self.assertEqual(config.out_indices       ,		[0, 2]    )

										# Error raised when out_indices do not correspond to out_features
										with self.assertRaises(lowerCAmelCase__    ):
													SCREAMING_SNAKE_CASE_						:			str       						= config_class(out_features=['stage1', 'stage2']       ,		out_indices=[0, 2]    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




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

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= model_class(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			int       						= inspect.signature(model.forward    )
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													SCREAMING_SNAKE_CASE_						:			Any       						= [*signature.parameters.keys()]
													SCREAMING_SNAKE_CASE_						:			Optional[int]       						= ['pixel_values']
													self.assertListEqual(arg_names[:1]       ,		lowerCAmelCase__    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			str       						= self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			Any       						= model_class(lowerCAmelCase__    )
													self.assertEqual(len(model.channels    )       ,		len(config.out_features    )    )
													SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= model.num_features
													SCREAMING_SNAKE_CASE_						:			Dict       						= [config.stage_names.index(lowerCAmelCase__    ) for feat in config.out_features]
													SCREAMING_SNAKE_CASE_						:			List[str]       						= [num_features[idx] for idx in out_indices]
													self.assertListEqual(model.channels       ,		lowerCAmelCase__    )

													SCREAMING_SNAKE_CASE_						:			Tuple       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			Dict       						= None
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model_class(lowerCAmelCase__    )
													self.assertEqual(len(model.channels    )       ,		1    )
													self.assertListEqual(model.channels       ,		[num_features[-1]]    )

													SCREAMING_SNAKE_CASE_						:			Dict       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			Tuple       						= None
													SCREAMING_SNAKE_CASE_						:			int       						= model_class(lowerCAmelCase__    )
													self.assertEqual(len(model.channels    )       ,		1    )
													self.assertListEqual(model.channels       ,		[num_features[-1]]    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




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

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model(**lowerCAmelCase__    )

													self.assertEqual(len(result.feature_maps    )       ,		len(config.out_features    )    )
													self.assertEqual(len(model.channels    )       ,		len(config.out_features    )    )
													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
													SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= None
													SCREAMING_SNAKE_CASE_						:			int       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()
													SCREAMING_SNAKE_CASE_						:			List[Any]       						= model(**lowerCAmelCase__    )

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

													SCREAMING_SNAKE_CASE_						:			Tuple       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			int       						= None
													SCREAMING_SNAKE_CASE_						:			Dict       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()
													SCREAMING_SNAKE_CASE_						:			List[str]       						= model(**lowerCAmelCase__    )

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

													# Check backbone can be initialized with fresh weights
													SCREAMING_SNAKE_CASE_						:			Tuple       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			Dict       						= False
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()
													SCREAMING_SNAKE_CASE_						:			str       						= model(**lowerCAmelCase__    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




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

										for backbone_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			List[str]       						= backbone_class(lowerCAmelCase__    )

													self.assertTrue(hasattr(lowerCAmelCase__       ,		'backbone_type'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'stage_names'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'num_features'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'out_indices'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'out_features'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'out_feature_channels'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'channels'    )    )

													self.assertIsInstance(backbone.backbone_type       ,		lowerCAmelCase__    )
													# Verify num_features has been initialized in the backbone init
													self.assertIsNotNone(backbone.num_features    )
													self.assertTrue(len(backbone.channels    ) == len(backbone.out_indices    )    )
													self.assertTrue(len(backbone.stage_names    ) == len(backbone.num_features    )    )
													self.assertTrue(len(backbone.channels    ) <= len(backbone.num_features    )    )
													self.assertTrue(len(backbone.out_feature_channels    ) == len(backbone.stage_names    )    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			List[str]       						= self.model_tester.prepare_config_and_inputs_for_common()
										SCREAMING_SNAKE_CASE_						:			Tuple       						= inputs_dict['pixel_values'].shape[0]

										for backbone_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			Optional[int]       						= backbone_class(lowerCAmelCase__    )
													backbone.to(lowerCAmelCase__    )
													backbone.eval()

													SCREAMING_SNAKE_CASE_						:			Dict       						= backbone(**lowerCAmelCase__    )

													# Test default outputs and verify feature maps
													self.assertIsInstance(outputs.feature_maps       ,		lowerCAmelCase__    )
													self.assertTrue(len(outputs.feature_maps    ) == len(backbone.channels    )    )
													for feature_map, n_channels in zip(outputs.feature_maps       ,		backbone.channels    ):
																self.assertTrue(feature_map.shape[:2]       ,		(batch_size, n_channels)    )
													self.assertIsNone(outputs.hidden_states    )
													self.assertIsNone(outputs.attentions    )

													# Test output_hidden_states=True
													SCREAMING_SNAKE_CASE_						:			List[Any]       						= backbone(**lowerCAmelCase__       ,		output_hidden_states=lowerCAmelCase__    )
													self.assertIsNotNone(outputs.hidden_states    )
													self.assertTrue(len(outputs.hidden_states    )       ,		len(backbone.stage_names    )    )
													for hidden_state, n_channels in zip(outputs.hidden_states       ,		backbone.channels    ):
																self.assertTrue(hidden_state.shape[:2]       ,		(batch_size, n_channels)    )

													# Test output_attentions=True
													if self.has_attentions:
																SCREAMING_SNAKE_CASE_						:			Tuple       						= backbone(**lowerCAmelCase__       ,		output_attentions=lowerCAmelCase__    )
																self.assertIsNotNone(outputs.attentions    )





