






"""simple docstring"""







import argparse

import requests
import torch

# pip3 install salesforce-lavis
# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis
from lavis.models import load_model_and_preprocess
from PIL import Image

from transformers import (
    AutoTokenizer,
    BlipaConfig,
    BlipaForConditionalGeneration,
    BlipaProcessor,
    BlipaVisionConfig,
    BlipImageProcessor,
    OPTConfig,
    TaConfig,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD


def      UpperCamelCase       ( )     ->       List[Any]:
				lowercase    :      Any       = """https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png"""
				lowercase    :      Tuple       = Image.open(requests.get(_A  ,				stream=_A ).raw ).convert("""RGB""" )

				return image


def      UpperCamelCase       ( _A )     ->       Any:
				lowercase    :      Optional[Any]       = []
				# fmt: off

				# vision encoder
				rename_keys.append(("""visual_encoder.cls_token""", """vision_model.embeddings.class_embedding""") )
				rename_keys.append(("""visual_encoder.pos_embed""", """vision_model.embeddings.position_embedding""") )
				rename_keys.append(("""visual_encoder.patch_embed.proj.weight""", """vision_model.embeddings.patch_embedding.weight""") )
				rename_keys.append(("""visual_encoder.patch_embed.proj.bias""", """vision_model.embeddings.patch_embedding.bias""") )
				rename_keys.append(("""ln_vision.weight""", """vision_model.post_layernorm.weight""") )
				rename_keys.append(("""ln_vision.bias""", """vision_model.post_layernorm.bias""") )

				for i in range(config.vision_config.num_hidden_layers ):
								rename_keys.append((F"""visual_encoder.blocks.{i}.norm1.weight""", F"""vision_model.encoder.layers.{i}.layer_norm1.weight""") )
								rename_keys.append((F"""visual_encoder.blocks.{i}.norm1.bias""", F"""vision_model.encoder.layers.{i}.layer_norm1.bias""") )
								rename_keys.append((F"""visual_encoder.blocks.{i}.norm2.weight""", F"""vision_model.encoder.layers.{i}.layer_norm2.weight""") )
								rename_keys.append((F"""visual_encoder.blocks.{i}.norm2.bias""", F"""vision_model.encoder.layers.{i}.layer_norm2.bias""") )
								rename_keys.append((F"""visual_encoder.blocks.{i}.attn.qkv.weight""", F"""vision_model.encoder.layers.{i}.self_attn.qkv.weight""") )
								rename_keys.append((F"""visual_encoder.blocks.{i}.attn.proj.weight""", F"""vision_model.encoder.layers.{i}.self_attn.projection.weight""",) )
								rename_keys.append((F"""visual_encoder.blocks.{i}.attn.proj.bias""", F"""vision_model.encoder.layers.{i}.self_attn.projection.bias""") )
								rename_keys.append((F"""visual_encoder.blocks.{i}.mlp.fc1.weight""", F"""vision_model.encoder.layers.{i}.mlp.fc1.weight""") )
								rename_keys.append((F"""visual_encoder.blocks.{i}.mlp.fc1.bias""", F"""vision_model.encoder.layers.{i}.mlp.fc1.bias""") )
								rename_keys.append((F"""visual_encoder.blocks.{i}.mlp.fc2.weight""", F"""vision_model.encoder.layers.{i}.mlp.fc2.weight""") )
								rename_keys.append((F"""visual_encoder.blocks.{i}.mlp.fc2.bias""", F"""vision_model.encoder.layers.{i}.mlp.fc2.bias""") )

				# QFormer
				rename_keys.append(("""Qformer.bert.embeddings.LayerNorm.weight""", """qformer.layernorm.weight""") )
				rename_keys.append(("""Qformer.bert.embeddings.LayerNorm.bias""", """qformer.layernorm.bias""") )

				# fmt: on
				return rename_keys


def      UpperCamelCase       ( _A  ,				_A  ,				_A )     ->       Dict:
				lowercase    :      int       = dct.pop(_A )
				lowercase    :      List[str]       = val


def      UpperCamelCase       ( _A  ,				_A )     ->       Tuple:
				for i in range(config.vision_config.num_hidden_layers ):
								# read in original q and v biases
								lowercase    :      Optional[int]       = state_dict.pop(F"""visual_encoder.blocks.{i}.attn.q_bias""" )
								lowercase    :      Union[str, Any]       = state_dict.pop(F"""visual_encoder.blocks.{i}.attn.v_bias""" )

								# next, set bias in the state dict
								lowercase    :      str       = torch.cat((q_bias, torch.zeros_like(_A  ,				requires_grad=_A ), v_bias) )
								lowercase    :      str       = qkv_bias


def      UpperCamelCase       ( _A  ,				_A )     ->       Tuple:
				lowercase    :      List[Any]       = 364 if """coco""" in model_name else 224
				lowercase    :      int       = BlipaVisionConfig(image_size=_A ).to_dict()

				# make sure the models have proper bos_token_id and eos_token_id set (important for generation)
				# seems like flan-T5 models don't have bos_token_id properly set?
				if "opt-2.7b" in model_name:
								lowercase    :      str       = OPTConfig.from_pretrained("""facebook/opt-2.7b"""  ,				eos_token_id=_A ).to_dict()
				elif "opt-6.7b" in model_name:
								lowercase    :      int       = OPTConfig.from_pretrained("""facebook/opt-6.7b"""  ,				eos_token_id=_A ).to_dict()
				elif "t5-xl" in model_name:
								lowercase    :      Any       = TaConfig.from_pretrained("""google/flan-t5-xl"""  ,				dense_act_fn="""gelu"""  ,				bos_token_id=1 ).to_dict()
				elif "t5-xxl" in model_name:
								lowercase    :      Union[str, Any]       = TaConfig.from_pretrained("""google/flan-t5-xxl"""  ,				dense_act_fn="""gelu"""  ,				bos_token_id=1 ).to_dict()

				lowercase    :      Dict       = BlipaConfig(vision_config=_A  ,				text_config=_A )

				return config, image_size


@torch.no_grad()
def      UpperCamelCase       ( _A  ,				_A=None  ,				_A=False )     ->       Union[str, Any]:
				lowercase    :      List[str]       = (
				    AutoTokenizer.from_pretrained("""facebook/opt-2.7b""" )
				    if """opt""" in model_name
				    else AutoTokenizer.from_pretrained("""google/flan-t5-xl""" )
				)
				lowercase    :      Optional[Any]       = tokenizer("""\n"""  ,				add_special_tokens=_A ).input_ids[0]
				lowercase      ,      lowercase    :      List[Any]       = get_blipa_config(_A  ,				eos_token_id=_A )

				lowercase    :      Union[str, Any]       = BlipaForConditionalGeneration(_A ).eval()

				lowercase    :      int       = {
				    """blip2-opt-2.7b""": ("""blip2_opt""", """pretrain_opt2.7b"""),
				    """blip2-opt-6.7b""": ("""blip2_opt""", """pretrain_opt6.7b"""),
				    """blip2-opt-2.7b-coco""": ("""blip2_opt""", """caption_coco_opt2.7b"""),
				    """blip2-opt-6.7b-coco""": ("""blip2_opt""", """caption_coco_opt6.7b"""),
				    """blip2-flan-t5-xl""": ("""blip2_t5""", """pretrain_flant5xl"""),
				    """blip2-flan-t5-xl-coco""": ("""blip2_t5""", """caption_coco_flant5xl"""),
				    """blip2-flan-t5-xxl""": ("""blip2_t5""", """pretrain_flant5xxl"""),
				}

				lowercase      ,      lowercase    :      str       = model_name_to_original[model_name]

				# load original model
				print("""Loading original model...""" )
				lowercase    :      Optional[int]       = """cuda""" if torch.cuda.is_available() else """cpu"""
				lowercase      ,      lowercase      ,      lowercase    :      Any       = load_model_and_preprocess(
				    name=_A  ,				model_type=_A  ,				is_eval=_A  ,				device=_A )
				original_model.eval()
				print("""Done!""" )

				# update state dict keys
				lowercase    :      str       = original_model.state_dict()
				lowercase    :      str       = create_rename_keys(_A )
				for src, dest in rename_keys:
								rename_key(_A  ,				_A  ,				_A )

				# some keys can be renamed efficiently
				for key, val in state_dict.copy().items():
								lowercase    :      Tuple       = state_dict.pop(_A )
								if key.startswith("""Qformer.bert""" ):
												lowercase    :      Optional[int]       = key.replace("""Qformer.bert"""  ,				"""qformer""" )
								if "attention.self" in key:
												lowercase    :      List[str]       = key.replace("""self"""  ,				"""attention""" )
								if "opt_proj" in key:
												lowercase    :      int       = key.replace("""opt_proj"""  ,				"""language_projection""" )
								if "t5_proj" in key:
												lowercase    :      str       = key.replace("""t5_proj"""  ,				"""language_projection""" )
								if key.startswith("""opt""" ):
												lowercase    :      str       = key.replace("""opt"""  ,				"""language""" )
								if key.startswith("""t5""" ):
												lowercase    :      Optional[int]       = key.replace("""t5"""  ,				"""language""" )
								lowercase    :      List[Any]       = val

				# read in qv biases
				read_in_q_v_bias(_A  ,				_A )

				lowercase      ,      lowercase    :      Optional[Any]       = hf_model.load_state_dict(_A  ,				strict=_A )
				assert len(_A ) == 0
				assert unexpected_keys == ["qformer.embeddings.position_ids"]

				lowercase    :      Optional[int]       = load_demo_image()
				lowercase    :      Optional[Any]       = vis_processors["""eval"""](_A ).unsqueeze(0 ).to(_A )
				lowercase    :      List[Any]       = tokenizer(["""\n"""]  ,				return_tensors="""pt""" ).input_ids.to(_A )

				# create processor
				lowercase    :      str       = BlipImageProcessor(
				    size={"""height""": image_size, """width""": image_size}  ,				image_mean=_A  ,				image_std=_A )
				lowercase    :      Union[str, Any]       = BlipaProcessor(image_processor=_A  ,				tokenizer=_A )
				lowercase    :      Dict       = processor(images=_A  ,				return_tensors="""pt""" ).pixel_values.to(_A )

				# make sure processor creates exact same pixel values
				assert torch.allclose(_A  ,				_A )

				original_model.to(_A )
				hf_model.to(_A )
				with torch.no_grad():
								if "opt" in model_name:
												lowercase    :      Dict       = original_model({"""image""": original_pixel_values, """text_input""": [""""""]} ).logits
												lowercase    :      Optional[Any]       = hf_model(_A  ,				_A ).logits
								else:
												lowercase    :      Union[str, Any]       = original_model(
												    {"""image""": original_pixel_values, """text_input""": ["""\n"""], """text_output""": ["""\n"""]} ).logits
												lowercase    :      Union[str, Any]       = input_ids.masked_fill(input_ids == tokenizer.pad_token_id  ,				-100 )
												lowercase    :      Optional[Any]       = hf_model(_A  ,				_A  ,				labels=_A ).logits

				assert original_logits.shape == logits.shape
				print("""First values of original logits:"""  ,				original_logits[0, :3, :3] )
				print("""First values of HF logits:"""  ,				logits[0, :3, :3] )

				# assert values
				if model_name == "blip2-flan-t5-xl":
								lowercase    :      str       = torch.tensor(
								    [[-41.5850, -4.4440, -8.9922], [-47.4322, -5.9143, -1.7340]]  ,				device=_A )
								assert torch.allclose(logits[0, :3, :3]  ,				_A  ,				atol=1e-4 )
				elif model_name == "blip2-flan-t5-xl-coco":
								lowercase    :      str       = torch.tensor(
								    [[-57.0109, -9.8967, -12.6280], [-68.6578, -12.7191, -10.5065]]  ,				device=_A )
				else:
								# cast to same type
								lowercase    :      Union[str, Any]       = logits.dtype
								assert torch.allclose(original_logits.to(_A )  ,				_A  ,				atol=1e-2 )
				print("""Looks ok!""" )

				print("""Generating a caption...""" )
				lowercase    :      Any       = """"""
				lowercase    :      List[Any]       = tokenizer(_A  ,				return_tensors="""pt""" ).input_ids.to(_A )

				lowercase    :      Dict       = original_model.generate({"""image""": original_pixel_values} )
				lowercase    :      str       = hf_model.generate(
				    _A  ,				_A  ,				do_sample=_A  ,				num_beams=5  ,				max_length=30  ,				min_length=1  ,				top_p=0.9  ,				repetition_penalty=1.0  ,				length_penalty=1.0  ,				temperature=1  ,				)
				print("""Original generation:"""  ,				_A )
				lowercase    :      Dict       = input_ids.shape[1]
				lowercase    :      Union[str, Any]       = processor.batch_decode(outputs[:, prompt_length:]  ,				skip_special_tokens=_A )
				lowercase    :      str       = [text.strip() for text in output_text]
				print("""HF generation:"""  ,				_A )

				if pytorch_dump_folder_path is not None:
								processor.save_pretrained(_A )
								hf_model.save_pretrained(_A )

				if push_to_hub:
								processor.push_to_hub(F"""nielsr/{model_name}""" )
								hf_model.push_to_hub(F"""nielsr/{model_name}""" )


if __name__ == "__main__":
				_lowerCAmelCase            =	argparse.ArgumentParser()
				_lowerCAmelCase            =	[
				    'blip2-opt-2.7b',
				    'blip2-opt-6.7b',
				    'blip2-opt-2.7b-coco',
				    'blip2-opt-6.7b-coco',
				    'blip2-flan-t5-xl',
				    'blip2-flan-t5-xl-coco',
				    'blip2-flan-t5-xxl',
				]
				parser.add_argument(
				    '--model_name',
				    default='blip2-opt-2.7b',
				    choices=choices,
				    type=str,
				    help='Path to hf config.json of model to convert',
				)
				parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
				parser.add_argument(
				    '--push_to_hub',
				    action='store_true',
				    help='Whether to push the model and processor to the hub after converting',
				)

				_lowerCAmelCase            =	parser.parse_args()

				convert_blipa_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








"""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__				)
