






"""simple docstring"""







import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
				from transformers import SpeechaTextFeatureExtractor

_lowerCAmelCase            =	random.Random()


def      UpperCamelCase       ( _A  ,				_A=1.0  ,				_A=None  ,				_A=None )     ->       Any:
				if rng is None:
								lowercase    :      Optional[int]       = global_rng

				lowercase    :      int       = []
				for batch_idx in range(shape[0] ):
								values.append([] )
								for _ in range(shape[1] ):
												values[-1].append(rng.random() * scale )

				return values


@require_torch
@require_torchaudio
class      UpperCamelCase		(unittest.TestCase     ):






						def __init__(		self  :Tuple			, __magic_name__  :Any			, __magic_name__  :Any=7			, __magic_name__  :List[str]=400			, __magic_name__  :Tuple=2_000			, __magic_name__  :Tuple=24			, __magic_name__  :Any=24			, __magic_name__  :Optional[Any]=0.0			, __magic_name__  :Any=16_000			, __magic_name__  :List[str]=True			, __magic_name__  :Dict=True			, )      ->str:
										lowercase    :      List[Any]       = parent
										lowercase    :      Optional[int]       = batch_size
										lowercase    :      Optional[int]       = min_seq_length
										lowercase    :      Tuple       = max_seq_length
										lowercase    :      Optional[Any]       = (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
										lowercase    :      Any       = feature_size
										lowercase    :      Optional[Any]       = num_mel_bins
										lowercase    :      List[Any]       = padding_value
										lowercase    :      Optional[int]       = sampling_rate
										lowercase    :      str       = return_attention_mask
										lowercase    :      Optional[Any]       = do_normalize






						def      __snake_case      (		self  :List[Any]				)      ->int:
										return {
										    "feature_size": self.feature_size,
										    "num_mel_bins": self.num_mel_bins,
										    "padding_value": self.padding_value,
										    "sampling_rate": self.sampling_rate,
										    "return_attention_mask": self.return_attention_mask,
										    "do_normalize": self.do_normalize,
										}






						def      __snake_case      (		self  :Any			, __magic_name__  :int=False			, __magic_name__  :str=False				)      ->int:
										def _flatten(__magic_name__  :Dict				):
														return list(itertools.chain(*__magic_name__				)				)

										if equal_length:
														lowercase    :      Any       = [floats_list((self.max_seq_length, self.feature_size)				) for _ in range(self.batch_size				)]
										else:
														# make sure that inputs increase in size
														lowercase    :      Tuple       = [
														    floats_list((x, self.feature_size)				)
														    for x in range(self.min_seq_length			, self.max_seq_length			, self.seq_length_diff				)
														]
										if numpify:
														lowercase    :      List[str]       = [np.asarray(__magic_name__				) for x in speech_inputs]
										return speech_inputs


@require_torch
@require_torchaudio
class      UpperCamelCase		(__snake_case						,						unittest.TestCase     ):
						_SCREAMING_SNAKE_CASE  : Any												=		SpeechaTextFeatureExtractor if is_speech_available() else None






						def      __snake_case      (		self  :List[Any]				)      ->Tuple:
										lowercase    :      Union[str, Any]       = SpeechaTextFeatureExtractionTester(self				)






						def      __snake_case      (		self  :Dict			, __magic_name__  :str				)      ->int:
										self.assertTrue(np.all(np.mean(__magic_name__			, axis=0				) < 1E-3				)				)
										self.assertTrue(np.all(np.abs(np.var(__magic_name__			, axis=0				) - 1				) < 1E-3				)				)






						def      __snake_case      (		self  :str				)      ->int:
										# Tests that all call wrap to encode_plus and batch_encode_plus
										lowercase    :      List[str]       = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
										# create three inputs of length 800, 1000, and 1200
										lowercase    :      Union[str, Any]       = [floats_list((1, x)				)[0] for x in range(800			, 1_400			, 200				)]
										lowercase    :      Optional[int]       = [np.asarray(__magic_name__				) for speech_input in speech_inputs]

										# Test feature size
										lowercase    :      int       = feature_extractor(__magic_name__			, padding=__magic_name__			, return_tensors="""np"""				).input_features
										self.assertTrue(input_features.ndim == 3				)
										self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size				)

										# Test not batched input
										lowercase    :      Dict       = feature_extractor(speech_inputs[0]			, return_tensors="""np"""				).input_features
										lowercase    :      List[Any]       = feature_extractor(np_speech_inputs[0]			, return_tensors="""np"""				).input_features
										self.assertTrue(np.allclose(__magic_name__			, __magic_name__			, atol=1E-3				)				)

										# Test batched
										lowercase    :      Dict       = feature_extractor(__magic_name__			, return_tensors="""np"""				).input_features
										lowercase    :      Optional[int]       = feature_extractor(__magic_name__			, return_tensors="""np"""				).input_features
										for enc_seq_a, enc_seq_a in zip(__magic_name__			, __magic_name__				):
														self.assertTrue(np.allclose(__magic_name__			, __magic_name__			, atol=1E-3				)				)

										# Test 2-D numpy arrays are batched.
										lowercase    :      List[Any]       = [floats_list((1, x)				)[0] for x in (800, 800, 800)]
										lowercase    :      Any       = np.asarray(__magic_name__				)
										lowercase    :      int       = feature_extractor(__magic_name__			, return_tensors="""np"""				).input_features
										lowercase    :      int       = feature_extractor(__magic_name__			, return_tensors="""np"""				).input_features
										for enc_seq_a, enc_seq_a in zip(__magic_name__			, __magic_name__				):
														self.assertTrue(np.allclose(__magic_name__			, __magic_name__			, atol=1E-3				)				)






						def      __snake_case      (		self  :Any				)      ->Optional[Any]:
										lowercase    :      Optional[int]       = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
										lowercase    :      Optional[int]       = [floats_list((1, x)				)[0] for x in range(800			, 1_400			, 200				)]

										lowercase    :      Optional[int]       = ["""longest""", """max_length""", """do_not_pad"""]
										lowercase    :      Union[str, Any]       = [None, 16, None]
										for max_length, padding in zip(__magic_name__			, __magic_name__				):
														lowercase    :      Any       = feature_extractor(
														    __magic_name__			, padding=__magic_name__			, max_length=__magic_name__			, return_attention_mask=__magic_name__				)
														lowercase    :      Dict       = inputs.input_features
														lowercase    :      Tuple       = inputs.attention_mask
														lowercase    :      Any       = [np.sum(__magic_name__				) for x in attention_mask]

														self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]				)
														self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]				)
														self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]				)






						def      __snake_case      (		self  :Any				)      ->Dict:
										lowercase    :      Tuple       = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
										lowercase    :      Tuple       = [floats_list((1, x)				)[0] for x in range(800			, 1_400			, 200				)]

										lowercase    :      Optional[int]       = ["""longest""", """max_length""", """do_not_pad"""]
										lowercase    :      Optional[Any]       = [None, 16, None]
										for max_length, padding in zip(__magic_name__			, __magic_name__				):
														lowercase    :      List[Any]       = feature_extractor(
														    __magic_name__			, max_length=__magic_name__			, padding=__magic_name__			, return_tensors="""np"""			, return_attention_mask=__magic_name__				)
														lowercase    :      str       = inputs.input_features
														lowercase    :      str       = inputs.attention_mask
														lowercase    :      Optional[int]       = [np.sum(__magic_name__				) for x in attention_mask]

														self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]				)
														self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1E-6				)
														self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]				)
														self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1E-6				)
														self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]				)






						def      __snake_case      (		self  :List[str]				)      ->Tuple:
										lowercase    :      Tuple       = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
										lowercase    :      int       = [floats_list((1, x)				)[0] for x in range(800			, 1_400			, 200				)]
										lowercase    :      str       = feature_extractor(
										    __magic_name__			, padding="""max_length"""			, max_length=4			, truncation=__magic_name__			, return_tensors="""np"""			, return_attention_mask=__magic_name__			, )
										lowercase    :      str       = inputs.input_features
										lowercase    :      List[Any]       = inputs.attention_mask
										lowercase    :      str       = np.sum(attention_mask == 1			, axis=1				)

										self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]				)
										self._check_zero_mean_unit_variance(input_features[1]				)
										self._check_zero_mean_unit_variance(input_features[2]				)






						def      __snake_case      (		self  :Optional[int]				)      ->Tuple:
										lowercase    :      Any       = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
										lowercase    :      Tuple       = [floats_list((1, x)				)[0] for x in range(800			, 1_400			, 200				)]
										lowercase    :      Optional[int]       = feature_extractor(
										    __magic_name__			, padding="""longest"""			, max_length=4			, truncation=__magic_name__			, return_tensors="""np"""			, return_attention_mask=__magic_name__			, )
										lowercase    :      List[Any]       = inputs.input_features
										lowercase    :      Dict       = inputs.attention_mask
										lowercase    :      int       = np.sum(attention_mask == 1			, axis=1				)

										self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]				)
										self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]				)
										self._check_zero_mean_unit_variance(input_features[2]				)

										# make sure that if max_length < longest -> then pad to max_length
										self.assertEqual(input_features.shape			, (3, 4, 24)				)

										lowercase    :      Optional[int]       = [floats_list((1, x)				)[0] for x in range(800			, 1_400			, 200				)]
										lowercase    :      str       = feature_extractor(
										    __magic_name__			, padding="""longest"""			, max_length=16			, truncation=__magic_name__			, return_tensors="""np"""			, return_attention_mask=__magic_name__			, )
										lowercase    :      Dict       = inputs.input_features
										lowercase    :      Any       = inputs.attention_mask
										lowercase    :      Optional[Any]       = np.sum(attention_mask == 1			, axis=1				)

										self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]				)
										self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]				)
										self._check_zero_mean_unit_variance(input_features[2]				)

										# make sure that if max_length < longest -> then pad to max_length
										self.assertEqual(input_features.shape			, (3, 6, 24)				)






						def      __snake_case      (		self  :Union[str, Any]				)      ->Tuple:
										import torch

										lowercase    :      str       = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
										lowercase    :      int       = np.random.rand(100			, 32				).astype(np.floataa				)
										lowercase    :      Optional[int]       = np_speech_inputs.tolist()

										for inputs in [py_speech_inputs, np_speech_inputs]:
														lowercase    :      Tuple       = feature_extractor.pad([{"""input_features""": inputs}]			, return_tensors="""np"""				)
														self.assertTrue(np_processed.input_features.dtype == np.floataa				)
														lowercase    :      Union[str, Any]       = feature_extractor.pad([{"""input_features""": inputs}]			, return_tensors="""pt"""				)
														self.assertTrue(pt_processed.input_features.dtype == torch.floataa				)






						def      __snake_case      (		self  :str			, __magic_name__  :List[Any]				)      ->Optional[Any]:
										from datasets import load_dataset

										lowercase    :      Optional[int]       = load_dataset("""hf-internal-testing/librispeech_asr_dummy"""			, """clean"""			, split="""validation"""				)
										# automatic decoding with librispeech
										lowercase    :      List[Any]       = ds.sort("""id"""				).select(range(__magic_name__				)				)[:num_samples]["""audio"""]

										return [x["array"] for x in speech_samples]






						def      __snake_case      (		self  :Optional[Any]				)      ->Optional[Any]:
										# fmt: off
										lowercase    :      List[Any]       = np.array([
										    -1.5745, -1.7713, -1.7020, -1.6069, -1.2250, -1.1105, -0.9072, -0.8241,
										    -1.2310, -0.8098, -0.3320, -0.4101, -0.7985, -0.4996, -0.8213, -0.9128,
										    -1.0420, -1.1286, -1.0440, -0.7999, -0.8405, -1.2275, -1.5443, -1.4625,
										]				)
										# fmt: on

										lowercase    :      Optional[Any]       = self._load_datasamples(1				)
										lowercase    :      Dict       = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
										lowercase    :      Optional[int]       = feature_extractor(__magic_name__			, return_tensors="""pt"""				).input_features
										self.assertEquals(input_features.shape			, (1, 584, 24)				)
										self.assertTrue(np.allclose(input_features[0, 0, :30]			, __magic_name__			, atol=1E-4				)				)








"""simple docstring"""







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      UpperCamelCase		:






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






						def      __snake_case      (		self  :List[Any]				)      ->Optional[Any]:
										lowercase    :      Dict       = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)
										lowercase    :      Optional[int]       = self.get_config()

										return config, pixel_values






						def      __snake_case      (		self  :Tuple				)      ->int:
										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      __snake_case      (		self  :Any			, __magic_name__  :List[str]			, __magic_name__  :Optional[int]				)      ->Tuple:
										lowercase    :      List[str]       = TimmBackbone(config=__magic_name__				)
										model.to(__magic_name__				)
										model.eval()
										with torch.no_grad():
														lowercase    :      str       = model(__magic_name__				)
										self.parent.assertEqual(
										    result.feature_map[-1].shape			, (self.batch_size, model.channels[-1], 14, 14)			, )






						def      __snake_case      (		self  :str				)      ->Dict:
										lowercase    :      Tuple       = self.prepare_config_and_inputs()
										lowercase      ,      lowercase    :      List[Any]       = config_and_inputs
										lowercase    :      Union[str, Any]       = {"""pixel_values""": pixel_values}
										return config, inputs_dict


@require_torch
@require_timm
class      UpperCamelCase		(__snake_case						,						__snake_case						,						__snake_case						,						unittest.TestCase     ):
						_SCREAMING_SNAKE_CASE  : Optional[int]												=		(TimmBackbone,) if is_torch_available() else ()
						_SCREAMING_SNAKE_CASE  : str												=		{"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
						_SCREAMING_SNAKE_CASE  : Optional[Any]												=		False
						_SCREAMING_SNAKE_CASE  : int												=		False
						_SCREAMING_SNAKE_CASE  : List[Any]												=		False
						_SCREAMING_SNAKE_CASE  : List[str]												=		False






						def      __snake_case      (		self  :Dict				)      ->List[str]:
										lowercase    :      List[str]       = TimmBackboneModelTester(self				)
										lowercase    :      Any       = ConfigTester(self			, config_class=__magic_name__			, has_text_modality=__magic_name__				)






						def      __snake_case      (		self  :Optional[Any]				)      ->List[Any]:
										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      __snake_case      (		self  :Union[str, Any]				)      ->Optional[Any]:
										lowercase    :      Dict       = """resnet18"""
										lowercase    :      int       = """microsoft/resnet-18"""

										lowercase    :      Union[str, Any]       = AutoBackbone.from_pretrained(__magic_name__			, use_timm_backbone=__magic_name__				)
										lowercase    :      int       = AutoBackbone.from_pretrained(__magic_name__				)

										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]				)

										lowercase    :      Tuple       = AutoBackbone.from_pretrained(__magic_name__			, use_timm_backbone=__magic_name__			, out_indices=[1, 2, 3]				)
										lowercase    :      Any       = AutoBackbone.from_pretrained(__magic_name__			, 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      __snake_case      (		self  :Tuple				)      ->Optional[int]:
										pass






						@unittest.skip("""TimmBackbone doesn't have num_hidden_layers attribute"""				)
						def      __snake_case      (		self  :Optional[Any]				)      ->int:
										pass






						@unittest.skip("""TimmBackbone initialization is managed on the timm side"""				)
						def      __snake_case      (		self  :Optional[Any]				)      ->Optional[Any]:
										pass






						@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""				)
						def      __snake_case      (		self  :int				)      ->List[Any]:
										pass






						@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""				)
						def      __snake_case      (		self  :int				)      ->Tuple:
										pass






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






						@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""				)
						def      __snake_case      (		self  :int				)      ->Any:
										pass






						@unittest.skip("""model weights aren't tied in TimmBackbone."""				)
						def      __snake_case      (		self  :int				)      ->int:
										pass






						@unittest.skip("""model weights aren't tied in TimmBackbone."""				)
						def      __snake_case      (		self  :str				)      ->Union[str, Any]:
										pass






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






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






						@unittest.skip("""TimmBackbone doesn't have hidden size info in its configuration."""				)
						def      __snake_case      (		self  :Union[str, Any]				)      ->List[Any]:
										pass






						@unittest.skip("""TimmBackbone doesn't support output_attentions."""				)
						def      __snake_case      (		self  :Tuple				)      ->List[Any]:
										pass






						@unittest.skip("""Safetensors is not supported by timm."""				)
						def      __snake_case      (		self  :List[Any]				)      ->int:
										pass






						@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""				)
						def      __snake_case      (		self  :Optional[Any]				)      ->Optional[int]:
										pass






						def      __snake_case      (		self  :Union[str, Any]				)      ->Union[str, Any]:
										lowercase      ,      lowercase    :      Optional[Any]       = self.model_tester.prepare_config_and_inputs_for_common()

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

														lowercase    :      Dict       = ["""pixel_values"""]
														self.assertListEqual(arg_names[:1]			, __magic_name__				)






						def      __snake_case      (		self  :Any				)      ->List[str]:
										lowercase      ,      lowercase    :      str       = self.model_tester.prepare_config_and_inputs_for_common()
										lowercase    :      Any       = True
										lowercase    :      int       = self.has_attentions

										# no need to test all models as different heads yield the same functionality
										lowercase    :      Union[str, Any]       = self.all_model_classes[0]
										lowercase    :      Tuple       = model_class(__magic_name__				)
										model.to(__magic_name__				)

										lowercase    :      Optional[Any]       = self._prepare_for_class(__magic_name__			, __magic_name__				)
										lowercase    :      Dict       = model(**__magic_name__				)
										lowercase    :      List[str]       = outputs[0][-1]

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

										if self.has_attentions:
														lowercase    :      List[Any]       = outputs.attentions[0]
														attentions.retain_grad()

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

										self.assertIsNotNone(hidden_states.grad				)

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






						def      __snake_case      (		self  :Any				)      ->List[Any]:
										lowercase      ,      lowercase    :      int       = self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
														lowercase    :      Optional[int]       = model_class(__magic_name__				)
														model.to(__magic_name__				)
														model.eval()
														lowercase    :      Any       = model(**__magic_name__				)

														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
														lowercase    :      List[Any]       = copy.deepcopy(__magic_name__				)
														lowercase    :      Dict       = None
														lowercase    :      str       = model_class(__magic_name__				)
														model.to(__magic_name__				)
														model.eval()
														lowercase    :      Optional[Any]       = model(**__magic_name__				)

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

														# Check backbone can be initialized with fresh weights
														lowercase    :      str       = copy.deepcopy(__magic_name__				)
														lowercase    :      int       = False
														lowercase    :      List[str]       = model_class(__magic_name__				)
														model.to(__magic_name__				)
														model.eval()
														lowercase    :      Dict       = model(**__magic_name__				)
