
"""simple docstring"""





import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import TimesformerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch
				from torch import nn

				from transformers import (
				    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
				    TimesformerForVideoClassification,
				    TimesformerModel,
				)
				from transformers.models.timesformer.modeling_timesformer import TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from transformers import VideoMAEImageProcessor






class        _UpperCAmelCase:



		def __init__(   self							,						__a							,						__a=13							,						__a=10							,						__a=3							,						__a=2							,						__a=2							,						__a=True							,						__a=True							,						__a=32							,						__a=5							,						__a=4							,						__a=37							,						__a="gelu"							,						__a=0.1							,						__a=0.1							,						__a=10							,						__a=0.02							,						__a="divided_space_time"							,						__a=None							,						)			->			List[str]:






							'''simple docstring'''
							_UpperCamelCase									=    parent
							_UpperCamelCase									=    batch_size
							_UpperCamelCase									=    image_size
							_UpperCamelCase									=    num_channels
							_UpperCamelCase									=    patch_size
							_UpperCamelCase									=    num_frames
							_UpperCamelCase									=    is_training
							_UpperCamelCase									=    use_labels
							_UpperCamelCase									=    hidden_size
							_UpperCamelCase									=    num_hidden_layers
							_UpperCamelCase									=    num_attention_heads
							_UpperCamelCase									=    intermediate_size
							_UpperCamelCase									=    hidden_act
							_UpperCamelCase									=    hidden_dropout_prob
							_UpperCamelCase									=    attention_probs_dropout_prob
							_UpperCamelCase									=    attention_type
							_UpperCamelCase									=    initializer_range
							_UpperCamelCase									=    scope
							_UpperCamelCase									=    num_labels

							# in TimeSformer, the number of spatial tokens equals num_frames * num_patches per frame + 1 CLS token
							_UpperCamelCase									=    (image_size // patch_size) ** 2
							_UpperCamelCase									=    (num_frames) * self.num_patches_per_frame + 1



		def 		UpperCAmelCase				(   self)			->			Tuple:






							'''simple docstring'''
							_UpperCamelCase									=    floats_tensor(
							    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size])

							_UpperCamelCase									=    None
							if self.use_labels:
												_UpperCamelCase									=    ids_tensor([self.batch_size]							,						self.num_labels)

							_UpperCamelCase									=    self.get_config()

							return config, pixel_values, labels



		def 		UpperCAmelCase				(   self)			->			Tuple:






							'''simple docstring'''
							_UpperCamelCase									=    TimesformerConfig(
							    image_size=self.image_size							,						patch_size=self.patch_size							,						num_channels=self.num_channels							,						num_frames=self.num_frames							,						hidden_size=self.hidden_size							,						num_hidden_layers=self.num_hidden_layers							,						num_attention_heads=self.num_attention_heads							,						intermediate_size=self.intermediate_size							,						hidden_act=self.hidden_act							,						hidden_dropout_prob=self.hidden_dropout_prob							,						attention_probs_dropout_prob=self.attention_probs_dropout_prob							,						initializer_range=self.initializer_range							,						attention_type=self.attention_type							,						)
							_UpperCamelCase									=    self.num_labels
							return config



		def 		UpperCAmelCase				(   self							,						__a							,						__a							,						__a)			->			Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase									=    TimesformerModel(config=__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase									=    model(__a)
							self.parent.assertEqual(result.last_hidden_state.shape							,						(self.batch_size, self.seq_length, self.hidden_size))



		def 		UpperCAmelCase				(   self							,						__a							,						__a							,						__a)			->			Dict:






							'''simple docstring'''
							_UpperCamelCase									=    TimesformerForVideoClassification(__a)
							model.to(__a)
							model.eval()

							_UpperCamelCase									=    model(__a)

							# verify the logits shape
							_UpperCamelCase									=    torch.Size((self.batch_size, self.num_labels))
							self.parent.assertEqual(result.logits.shape							,						__a)




		def 		UpperCAmelCase				(   self)			->			Optional[int]:






							'''simple docstring'''
							_UpperCamelCase									=    self.prepare_config_and_inputs()
							_UpperCamelCase					,    _UpperCamelCase					,    _UpperCamelCase									=    config_and_inputs
							_UpperCamelCase									=    {'''pixel_values''': pixel_values}
							return config, inputs_dict






@require_torch
class        _UpperCAmelCase(       lowerCamelCase ,	lowerCamelCase ,	unittest.TestCase      ):
		lowercase__         = (TimesformerModel, TimesformerForVideoClassification) if is_torch_available() else ()
		lowercase__         = (
		    {'feature-extraction': TimesformerModel, 'video-classification': TimesformerForVideoClassification}
		    if is_torch_available()
		    else {}
		)

		lowercase__         = False
		lowercase__         = False
		lowercase__         = False
		lowercase__         = False



		def 		UpperCAmelCase				(   self)			->			Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase									=    TimesformerModelTester(self)
							_UpperCamelCase									=    ConfigTester(
							    self							,						config_class=__a							,						has_text_modality=__a							,						hidden_size=37)



		def 		UpperCAmelCase				(   self							,						__a							,						__a							,						__a=False)			->			List[str]:






							'''simple docstring'''
							_UpperCamelCase									=    copy.deepcopy(__a)

							if return_labels:
												if model_class in get_values(__a):
																	_UpperCamelCase									=    torch.zeros(
																	    self.model_tester.batch_size							,						dtype=torch.long							,						device=__a)

							return inputs_dict



		def 		UpperCAmelCase				(   self)			->			Dict:






							'''simple docstring'''
							self.config_tester.run_common_tests()



		@unittest.skip(reason='''TimeSformer does not use inputs_embeds''')
		def 		UpperCAmelCase				(   self)			->			Any:






							'''simple docstring'''
							pass



		def 		UpperCAmelCase				(   self)			->			str:






							'''simple docstring'''
							_UpperCamelCase					,    _UpperCamelCase									=    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												_UpperCamelCase									=    model_class(__a)
												self.assertIsInstance(model.get_input_embeddings()							,						(nn.Module))
												_UpperCamelCase									=    model.get_output_embeddings()
												self.assertTrue(x is None or isinstance(__a							,						nn.Linear))



		def 		UpperCAmelCase				(   self)			->			str:






							'''simple docstring'''
							_UpperCamelCase					,    _UpperCamelCase									=    self.model_tester.prepare_config_and_inputs_for_common()

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

												_UpperCamelCase									=    ['''pixel_values''']
												self.assertListEqual(arg_names[:1]							,						__a)



		def 		UpperCAmelCase				(   self)			->			Dict:






							'''simple docstring'''
							_UpperCamelCase									=    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__a)



		def 		UpperCAmelCase				(   self)			->			Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase									=    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_video_classification(*__a)



		@slow
		def 		UpperCAmelCase				(   self)			->			int:






							'''simple docstring'''
							for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase									=    TimesformerModel.from_pretrained(__a)
												self.assertIsNotNone(__a)



		def 		UpperCAmelCase				(   self)			->			Optional[int]:






							'''simple docstring'''
							if not self.has_attentions:
												pass

							else:
												_UpperCamelCase					,    _UpperCamelCase									=    self.model_tester.prepare_config_and_inputs_for_common()
												_UpperCamelCase									=    True

												for model_class in self.all_model_classes:
																	_UpperCamelCase									=    self.model_tester.seq_length
																	_UpperCamelCase									=    self.model_tester.num_frames

																	_UpperCamelCase									=    True
																	_UpperCamelCase									=    False
																	_UpperCamelCase									=    True
																	_UpperCamelCase									=    model_class(__a)
																	model.to(__a)
																	model.eval()
																	with torch.no_grad():
																						_UpperCamelCase									=    model(**self._prepare_for_class(__a							,						__a))
																	_UpperCamelCase									=    outputs.attentions
																	self.assertEqual(len(__a)							,						self.model_tester.num_hidden_layers)

																	# check that output_attentions also work using config
																	del inputs_dict["output_attentions"]
																	_UpperCamelCase									=    True
																	_UpperCamelCase									=    model_class(__a)
																	model.to(__a)
																	model.eval()
																	with torch.no_grad():
																						_UpperCamelCase									=    model(**self._prepare_for_class(__a							,						__a))
																	_UpperCamelCase									=    outputs.attentions
																	self.assertEqual(len(__a)							,						self.model_tester.num_hidden_layers)

																	# attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
																	self.assertListEqual(
																	    list(attentions[0].shape[-3:])							,						[self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1]							,						)
																	_UpperCamelCase									=    len(__a)

																	# Check attention is always last and order is fine
																	_UpperCamelCase									=    True
																	_UpperCamelCase									=    True
																	_UpperCamelCase									=    model_class(__a)
																	model.to(__a)
																	model.eval()
																	with torch.no_grad():
																						_UpperCamelCase									=    model(**self._prepare_for_class(__a							,						__a))

																	self.assertEqual(out_len + 1							,						len(__a))

																	_UpperCamelCase									=    outputs.attentions

																	self.assertEqual(len(__a)							,						self.model_tester.num_hidden_layers)

																	# attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
																	self.assertListEqual(
																	    list(self_attentions[0].shape[-3:])							,						[self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1]							,						)




		def 		UpperCAmelCase				(   self)			->			int:






							'''simple docstring'''
							def check_hidden_states_output(__a							,						__a							,						__a):
												_UpperCamelCase									=    model_class(__a)
												model.to(__a)
												model.eval()

												with torch.no_grad():
																	_UpperCamelCase									=    model(**self._prepare_for_class(__a							,						__a))

												_UpperCamelCase									=    outputs.hidden_states
												_UpperCamelCase									=    self.model_tester.num_hidden_layers + 1
												self.assertEqual(len(__a)							,						__a)

												_UpperCamelCase									=    self.model_tester.seq_length

												self.assertListEqual(
												    list(hidden_states[0].shape[-2:])							,						[seq_length, self.model_tester.hidden_size]							,						)

							_UpperCamelCase					,    _UpperCamelCase									=    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												_UpperCamelCase									=    True
												check_hidden_states_output(__a							,						__a							,						__a)

												# check that output_hidden_states also work using config
												del inputs_dict["output_hidden_states"]
												_UpperCamelCase									=    True

												check_hidden_states_output(__a							,						__a							,						__a)





def  lowerCamelCase__						(     )				->						List[Any]:


					"""simple docstring"""





					_UpperCamelCase									=    hf_hub_download(
					    repo_id='''hf-internal-testing/spaghetti-video''',	filename='''eating_spaghetti.npy''',	repo_type='''dataset'''      )
					_UpperCamelCase									=    np.load(__snake_case      )
					return list(__snake_case      )






@require_torch
@require_vision
class        _UpperCAmelCase(       unittest.TestCase      ):



		@cached_property
		def 		UpperCAmelCase				(   self)			->			List[str]:






							'''simple docstring'''
							# logits were tested with a different mean and std, so we use the same here
							return (
							    VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]							,						image_std=[0.5, 0.5, 0.5])
							    if is_vision_available()
							    else None
							)




		@slow
		def 		UpperCAmelCase				(   self)			->			List[str]:






							'''simple docstring'''
							_UpperCamelCase									=    TimesformerForVideoClassification.from_pretrained('''facebook/timesformer-base-finetuned-k400''').to(
							    __a)

							_UpperCamelCase									=    self.default_image_processor
							_UpperCamelCase									=    prepare_video()
							_UpperCamelCase									=    image_processor(video[:8]							,						return_tensors='''pt''').to(__a)

							# forward pass
							with torch.no_grad():
												_UpperCamelCase									=    model(**__a)

							# verify the logits
							_UpperCamelCase									=    torch.Size((1, 4_00))
							self.assertEqual(outputs.logits.shape							,						__a)

							_UpperCamelCase									=    torch.tensor([-0.3016, -0.7713, -0.4205]).to(__a)

							self.assertTrue(torch.allclose(outputs.logits[0, :3]							,						__a							,						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__				)
