def test_channel_prune(self): orig_net = resnet18(num_classes=10).to(device) channel_prune(orig_net) state_dict = torch.load(MODEL_FILE) orig_net = resnet18(num_classes=10).to(device) orig_net.load_state_dict(state_dict) apply_compression_results(orig_net, MASK_FILE) orig_net.eval() net = resnet18(num_classes=10).to(device) net.load_state_dict(state_dict) net.eval() data = torch.randn(BATCH_SIZE, 3, 128, 128).to(device) ms = ModelSpeedup(net, data, MASK_FILE, confidence=8) ms.speedup_model() ms.bound_model(data) net.eval() ori_sum = orig_net(data).abs().sum().item() speeded_sum = net(data).abs().sum().item() print(ori_sum, speeded_sum) assert (abs(ori_sum - speeded_sum) / abs(ori_sum) < RELATIVE_THRESHOLD) or \ (abs(ori_sum - speeded_sum) < ABSOLUTE_THRESHOLD)
def __init__(self, emb_dim, type=18, fc_dim=None, norm=True, pretrained=True, lock=False): super(ResNetEncoder, self).__init__() self.fc_dim = fc_dim self.norm = norm self.pretrained = pretrained if type == 18: if self.pretrained: self.backbone = nn.Sequential( *list(resnet18(pretrained=True).children())[:-1]) if lock: for param in self.backbone.parameters(): param.requires_grad = False ll_size = 512 elif fc_dim: self.backbone = resnet18(pretrained=False, num_classes=fc_dim) else: self.backbone = resnet18(pretrained=False, num_classes=emb_dim) elif type == 50: if self.pretrained: self.backbone = nn.Sequential( *list(resnet50(pretrained=True).children())[:-1]) if lock: for param in self.backbone.parameters(): param.requires_grad = False ll_size = 2048 elif fc_dim: self.backbone = resnet50(pretrained=False, num_classes=fc_dim) else: self.backbone = resnet50(pretrained=False, num_classes=emb_dim) if self.pretrained: if fc_dim: self.fc1 = nn.Linear(ll_size, fc_dim) self.bn1 = nn.BatchNorm1d(fc_dim) self.fc2 = nn.Linear(fc_dim, emb_dim) else: self.fc1 = nn.Linear(ll_size, emb_dim) else: if fc_dim: self.bn1 = nn.BatchNorm1d(fc_dim) self.fc1 = nn.Linear(fc_dim, emb_dim)
def __init__(self, classes=19): """ Model initialization :param x_n: number of input neurons :type x_n: int """ super().__init__() base = resnet.resnet18(pretrained=True) self.in_block = nn.Sequential(base.conv1, base.bn1, base.relu, base.maxpool) self.encoder1 = base.layer1 self.encoder2 = base.layer2 self.encoder3 = base.layer3 self.encoder4 = base.layer4 self.decoder1 = Decoder(64, 64, 3, 1, 1, 0) self.decoder2 = Decoder(128, 64, 3, 2, 1, 1) self.decoder3 = Decoder(256, 128, 3, 2, 1, 1) self.decoder4 = Decoder(512, 256, 3, 2, 1, 1) # Classifier self.tp_conv1 = nn.Sequential( nn.ConvTranspose2d(64, 32, 3, 2, 1, 1), nn.BatchNorm2d(32), nn.ReLU(inplace=True), ) self.conv2 = nn.Sequential( nn.Conv2d(32, 32, 3, 1, 1), nn.BatchNorm2d(32), nn.ReLU(inplace=True), ) self.tp_conv2 = nn.ConvTranspose2d(32, classes, 2, 2, 0)
def __init__( self, model_arch: str, num_input_channels: int, num_targets: int, weights_scaling: List[float], criterion: nn.Module, pretrained: bool = True, ) -> None: super().__init__() self.model_arch = model_arch self.num_input_channels = num_input_channels self.num_targets = num_targets self.register_buffer("weights_scaling", torch.tensor(weights_scaling)) self.pretrained = pretrained self.criterion = criterion if pretrained and self.num_input_channels != 3: warnings.warn("There is no pre-trained model with num_in_channels != 3, first layer will be reset") if model_arch == "resnet18": self.model = resnet18(pretrained=pretrained) self.model.fc = nn.Linear(in_features=512, out_features=num_targets) elif model_arch == "resnet50": self.model = resnet50(pretrained=pretrained) self.model.fc = nn.Linear(in_features=2048, out_features=num_targets) else: raise NotImplementedError(f"Model arch {model_arch} unknown") if self.num_input_channels != 3: self.model.conv1 = nn.Conv2d( self.num_input_channels, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False )
def __init__(self, num_classes): super(CelebNet, self).__init__() self.num_classes = num_classes self.resnet = resnet18(num_classes=512) self.relu = nn.ReLU() for i in range(self.num_classes): self.add_module(f"seq_class_{i}", self._make_node())
def resnet18_reid(features=128, classes=1502): resnet = resnet18(pretrained=True) resnet.layer4[0].downsample[0].stride = (1, 1) resnet.layer4[0].conv1.stride = (1, 1) resnet.fc = None model = ReIDResnet(resnet, 512, features, classes) return model
def __init__( self, model_file='../resvar_weights/labeled-resvar-latest.torch', model_file2='../resvar_weights/segmentation-network-latest.torch'): # You should # 1. create the model object # 2. load your state_dict # 3. call cuda() # self.model = ... # device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') self.model = Prototype(device, hidden_dim=1024, variational=True) from torchvision.models.resnet import resnet18 from model.util import remove_backbone_head seg_backbone, _ = remove_backbone_head(resnet18(pretrained=False)) self.seg_model = SegmentationNetwork(seg_backbone, 2) #self.seg_model = SegmentationNetwork(self.model.backbone, 3) # Load models self.model.load_state_dict(torch.load(model_file)) self.seg_model.load_state_dict(torch.load(model_file2)) self.model.eval() self.seg_model.eval() self.model.to(device) self.seg_model.to(device)
def __init__(self, cfg: Dict): super().__init__() self.backbone = resnet18(pretrained=True, progress=True) num_history_channels = (cfg["model_params"]["history_num_frames"] + 1) * 2 num_in_channels = 3 + num_history_channels self.backbone.conv1 = nn.Conv2d( num_in_channels, self.backbone.conv1.out_channels, kernel_size=self.backbone.conv1.kernel_size, stride=self.backbone.conv1.stride, padding=self.backbone.conv1.padding, bias=False, ) # This is 512 for resnet18 and resnet34; # And it is 2048 for the other resnets backbone_out_features = 512 # X, Y coords for the future positions (output shape: Bx50x2) num_targets = 2 * cfg["model_params"]["future_num_frames"] # You can add more layers here. self.head = nn.Sequential( # nn.Dropout(0.2), nn.Linear(in_features=backbone_out_features, out_features=4096), ) self.logit = nn.Linear(4096, out_features=num_targets)
def __init__(self, im_size, hidden_dim, n_classes): ''' Create components of a two layer neural net classifier (often referred to as an MLP) and initialize their weights. Arguments: im_size (tuple): A tuple of ints with (channels, height, width) hidden_dim (int): Number of hidden activations to use n_classes (int): Number of classes to score ''' super(ResnetTwoLayerNN, self).__init__() ############################################################################# # TODO: Initialize anything you need for the forward pass # ############################################################################# self.model = resNet.resnet18(pretrained=True) for param in self.model.parameters(): param.requires_grad = False self.model.fc = nn.Sequential( nn.Linear(512, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, n_classes), ) self.softmax = nn.Softmax(dim=1) self.upsample_image = nn.Upsample(scale_factor=7, mode="bilinear", align_corners=True)
def __init__(self, n_classes=21): """ Initialization """ super(InstrumentsMFF, self).__init__() self.spp = spatialPyramidPooling(pool_sizes=[16, 8, 4, 2]) self.mff_sub24_x2 = multiresolutionFeatureFusion(n_classes, 128, 512, 512, with_bn=True ) base = resnet.resnet18(pretrained=True) self.in_block = nn.Sequential(base.conv1, base.bn1, base.relu, base.maxpool) self.encoder1 = base.layer1 self.encoder2 = base.layer2 self.encoder3 = base.layer3 self.encoder4 = base.layer4 # decoder self.decoder1 = Decoder(64, 64, 3, 1, 1, 0) self.decoder2 = Decoder(128, 64, 3, 2, 1, 1) self.decoder3 = Decoder(256, 128, 3, 2, 1, 1) self.decoder4 = Decoder(512, 256, 3, 2, 1, 1) self.decoder4_x2 = Decoder(512, 128, 3, 2, 1, 1) # Classifier self.deconv1 = nn.Sequential(nn.ConvTranspose2d(64, 32, 3, 2, 1, 1), nn.BatchNorm2d(32), nn.ReLU(inplace=True), ) self.conv2 = nn.Sequential(nn.Conv2d(32, 32, 3, 1, 1), nn.BatchNorm2d(32), nn.ReLU(inplace=True), ) self.conv2_x2 = nn.Sequential(nn.Conv2d(128, 32, 3, 1, 1), nn.BatchNorm2d(32), nn.ReLU(inplace=True), ) self.deconv2 = nn.ConvTranspose2d(32, n_classes, 2, 2, 0) self.lsm = nn.LogSoftmax(dim=1)
def __init__(self, pretrained=None): super(HeadCommon, self).__init__() self.config = ConfigParser() config_path = os.path.abspath( os.path.join(__file__, "../../", "config.ini")) assert os.path.exists(config_path), "config.ini not exists!" self.config.read(config_path) self.backbone_type = self.config['BACKBONE']['BACKBONE_TYPE'] _pretrained = True if pretrained is not None else False assert self.backbone_type in ['resnet', 'vgg16'] if self.backbone_type == 'resnet': resnet_layer = int(self.config['BACKBONE']['RESNET_LAYER']) assert resnet_layer in [18, 34, 50, 101, 152] if resnet_layer == 18: _resnet = resnet.resnet18(_pretrained) elif resnet_layer == 34: _resnet = resnet.resnet34(_pretrained) elif resnet_layer == 50: _resnet = resnet.resnet50(_pretrained) elif resnet_layer == 101: _resnet = resnet.resnet101(_pretrained) else: _resnet = resnet.resnet152(_pretrained) # using resnet_c5 the last bottle neck of resnet _resnet.layer4[0].conv2.stride = (1, 1) _resnet.layer4[0].downsample[0].stride = (1, 1) self.resnet_c5 = _resnet.layer4 self.resnet_c5_avg = _resnet.avgpool elif self.backbone_type == 'vgg16': assert not bool(int(self.config['HEAD']['MASK_HEAD_ON'])), ( "When mask head on, not support vgg16 backbone.") vgg = vgg16(pretrained=True) self.vgg_fc = nn.Sequential( *list(vgg.classifier._modules.values())[:-1])
def __init__(self, cfg, encoder='resnet18', upsample=True, device=None): super(TRecgNet_Upsample_Resiual, self).__init__() self.encoder = encoder self.cfg = cfg self.upsample = upsample self.dim_noise = 128 self.device = device self.avg_pool_size = 14 dims = [32, 64, 128, 256, 512, 1024, 2048] if cfg.PRETRAINED == 'imagenet' or cfg.PRETRAINED == 'place': pretrained = True else: pretrained = False if cfg.PRETRAINED == 'place': resnet = models.__dict__['resnet18'](num_classes=365) # places model downloaded from http://places2.csail.mit.edu/ checkpoint = torch.load(self.cfg.CONTENT_MODEL_PATH, map_location=lambda storage, loc: storage) state_dict = { str.replace(k, 'module.', ''): v for k, v in checkpoint['state_dict'].items() } resnet.load_state_dict(state_dict) print('place resnet18 loaded....') else: resnet = resnet18(pretrained=pretrained) print('{0} pretrained:{1}'.format(encoder, str(pretrained))) self.conv1 = resnet.conv1 self.bn1 = resnet.bn1 self.relu = resnet.relu self.maxpool = resnet.maxpool # 1/4 self.layer1 = resnet.layer1 # 1/4 self.layer2 = resnet.layer2 # 1/8 self.layer3 = resnet.layer3 # 1/16 self.layer4 = resnet.layer4 # 1/32 self.build_upsample_layers(dims) self.avgpool = nn.AvgPool2d(self.avg_pool_size, 1) self.fc = nn.Linear(dims[4], cfg.NUM_CLASSES) if pretrained and upsample: init_weights(self.up1, 'normal') init_weights(self.up2, 'normal') init_weights(self.up3, 'normal') init_weights(self.up4, 'normal') init_weights(self.skip_3, 'normal') init_weights(self.skip_2, 'normal') init_weights(self.skip_1, 'normal') init_weights(self.up_image, 'normal') elif not pretrained: init_weights(self, 'normal')
def __init__(self, im_size, hidden_dim, kernel_size, n_classes): ''' Create components of a CNN classifier and initialize their weights. Arguments: im_size (tuple): A tuple of ints with (channels, height, width) hidden_dim (int): Number of hidden activations to use kernel_size (int): Width and height of (square) convolution filters n_classes (int): Number of classes to score ''' super(ONLYRESNET, self).__init__() ############################################################################# # TODO: Initialize anything you need for the forward pass ############################################################################# import torchvision.models as models #Begin of New Code self.resnet18_full = resnet18(pretrained=True) #self.resnet18 = nn.Sequential(*list(self.resnet18_full.children())[:-1]) #for param in self.resnet18.parameters(): # param.requires_grad= False #self.upsample_img = nn.Upsample(scale_factor=7, mode="bilinear", align_corners=True) #End of New Code pass
def __init__(self, feature_dim=128, resnet_depth=18): super(Model, self).__init__() self.f = [] if resnet_depth == 18: my_resnet = resnet18() resnet_output_dim = 512 elif resnet_depth == 34: my_resnet = resnet34() resnet_output_dim = 512 elif resnet_depth == 50: my_resnet = resnet50() resnet_output_dim = 2048 for name, module in my_resnet.named_children(): if name == 'conv1': module = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) if not isinstance(module, nn.Linear) and not isinstance( module, nn.MaxPool2d): self.f.append(module) # encoder self.f = nn.Sequential(*self.f) # projection head self.g = nn.Sequential(nn.Linear(resnet_output_dim, 512, bias=False), nn.BatchNorm1d(512), nn.ReLU(inplace=True), nn.Linear(512, feature_dim, bias=True))
def __init__(self, rnn_hidden=256, out_size=12): super(ConvNet, self).__init__() self.rnn_hidden = rnn_hidden self.num_layers = 4 self.out_size = out_size self.lstm_input_size = out_size self.encoder = resnet18(pretrained=True) # Disable grad # for param in self.encoder.parameters(): # param.requires_grad = False # for param in self.encoder.layer4.parameters(): # param.requires_grad = True self.encoder.fc = torch.nn.Linear(self.encoder.fc.in_features, 512) self.cnn2h0 = torch.nn.Sequential( torch.nn.Dropout(0.4), torch.nn.Linear(512, self.num_layers * self.rnn_hidden)) self.cnn2c0 = torch.nn.Sequential( torch.nn.Dropout(0.4), torch.nn.Linear(512, self.num_layers * self.rnn_hidden)) self.lstm = torch.nn.LSTM(input_size=self.lstm_input_size, hidden_size=rnn_hidden, num_layers=self.num_layers, dropout=0.4, batch_first=True) self.linear = torch.nn.Sequential( torch.nn.Linear(rnn_hidden, rnn_hidden), torch.nn.Dropout(0.4), torch.nn.Linear(rnn_hidden, out_size)) self.hidden_w = None
def load_net(net_name, pretrained_path=None, zoo_pretrained=False): if net_name == 'resnet18': net = resnet18(zoo_pretrained, num_classes=1108) net.conv1 = nn.Conv2d(6, 64, kernel_size=7, stride=2, padding=3, bias=False) elif net_name == 'resnet50': net = resnet50(zoo_pretrained, num_classes=1108) net.conv1 = nn.Conv2d(6, 64, kernel_size=7, stride=2, padding=3, bias=False) elif net_name == 'mobilenet': raise NotImplementedError elif net_name == 'vggnet': raise NotImplementedError else: raise ValueError("invalid net_name : {}".format(net_name)) if pretrained_path is not None: net.load_state_dict(torch.load(pretrained_path)) print("pretrained {} weights will be used".format(pretrained_path)) return net
def get_classification_model(classifier_name='resnet18', num_classes=1000, pretrained=True): """ Get the detection model :param pretrained: :param classifier_name: :param num_classes: :return: """ if classifier_name == 'resnet18': model = resnet18(pretrained, num_classes=num_classes) elif classifier_name == 'resnet34': model = resnet34(pretrained, num_classes=num_classes) elif classifier_name == 'resnet50': model = resnet50(pretrained, num_classes=num_classes) elif classifier_name == 'resnet101': model = resnet101(pretrained, num_classes=num_classes) elif classifier_name == 'resnet152': model = resnet152(pretrained, num_classes=num_classes) else: raise ValueError('Unsupported resnet type.') return model
def test_int8(): from torchvision.models.resnet import resnet18 from calibration import ImageCalibrator imgs_dir = '/mnt/data/sample_comparison/sample_comp/train_ori' images = [os.path.join(imgs_dir, img) for img in os.listdir(imgs_dir)[:3]] calibrator = ImageCalibrator(images, width=256, height=256, channel=3, batch_size=1, cache_file='./{}.cache'.format('int8')) engine_name = 'model_i8.engine' input_names = ['input'] output_names = ['output'] print('Build Engine Model.') batch_size = 1 x = torch.ones((batch_size, 3, 256, 256)).cuda() model = resnet18(num_classes=5).cuda().eval() input_names, output_names = build_tensorRT_model(model, [x], input_names=input_names, output_names=output_names, int8_mode=True, calibrator=calibrator, engine_name=engine_name) model = load_tensorRT_model(engine_name, input_names, output_names) model(x)
def __init__(self, feature_dim=128): super(TEST_MODEL, self).__init__() self.f = [] for name, module in resnet18().named_children(): if name == 'conv1': module = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) if not isinstance(module, nn.Linear) and not isinstance(module, nn.MaxPool2d): self.f.append(module) # encoder self.f = nn.Sequential(*self.f) # projection mlp self.projection = nn.Sequential(*[nn.Linear(512, 2048, bias=True), nn.BatchNorm1d(2048), nn.ReLU(inplace=True), nn.Linear(2048, 2048, bias=True), nn.BatchNorm1d(2048), nn.ReLU(inplace=True), nn.Linear(2048, feature_dim, bias=True), nn.BatchNorm1d(feature_dim)]) # prediction mlp self.h = nn.Sequential( nn.Linear(feature_dim, 512, bias=True), nn.BatchNorm1d(512), nn.ReLU(inplace=True), nn.Linear(512, feature_dim, bias=True), )
def __init__(self, arch="resnet18", num_classes=1000, torchvision_pretrained=False, pretrained_num_classes=1000, fix_bn=False, partial_bn=False, zero_init_residual=False): super(TorchvisionResNet, self).__init__() self.num_classes = num_classes self.fix_bn = fix_bn self.partial_bn = partial_bn if arch == 'resnet18': self.model = resnet18(pretrained=torchvision_pretrained, num_classes=pretrained_num_classes, zero_init_residual=zero_init_residual) elif arch == 'resnet50': self.model = resnet50(pretrained=torchvision_pretrained, num_classes=pretrained_num_classes, zero_init_residual=zero_init_residual) elif arch == 'resnext50_32x4d': self.model = resnext50_32x4d(pretrained=torchvision_pretrained, num_classes=pretrained_num_classes, zero_init_residual=zero_init_residual) else: raise ValueError('no such value') self.init_weights(num_classes, pretrained_num_classes)
def __init__(self, backbone='resnet50', pretrained_path=None): super().__init__() if backbone == 'resnet18': backbone = resnet18(pretrained=not pretrained_path) self.final_out_channels = 256 self.low_level_inplanes = 64 elif backbone == 'resnet34': backbone = resnet34(pretrained=not pretrained_path) self.final_out_channels = 256 self.low_level_inplanes = 64 elif backbone == 'resnet50': backbone = resnet50(pretrained=not pretrained_path) self.final_out_channels = 1024 self.low_level_inplanes = 256 elif backbone == 'resnet101': backbone = resnet101(pretrained=not pretrained_path) self.final_out_channels = 1024 self.low_level_inplanes = 256 else: # backbone == 'resnet152': backbone = resnet152(pretrained=not pretrained_path) self.final_out_channels = 1024 self.low_level_inplanes = 256 if pretrained_path: backbone.load_state_dict(torch.load(pretrained_path)) self.early_extractor = nn.Sequential(*list(backbone.children())[:5]) self.later_extractor = nn.Sequential(*list(backbone.children())[5:7]) conv4_block1 = self.later_extractor[-1][0] conv4_block1.conv1.stride = (1, 1) conv4_block1.conv2.stride = (1, 1) conv4_block1.downsample[0].stride = (1, 1)
def __init__(self, backbone='resnet50', backbone_path=None): super().__init__() if backbone == 'resnet18': backbone = resnet18(pretrained=not backbone_path) self.out_channels = [256, 512, 512, 256, 256, 128] elif backbone == 'resnet34': backbone = resnet34(pretrained=not backbone_path) self.out_channels = [256, 512, 512, 256, 256, 256] elif backbone == 'resnet50': backbone = resnet50(pretrained=not backbone_path) self.out_channels = [1024, 512, 512, 256, 256, 256] elif backbone == 'resnet101': backbone = resnet101(pretrained=not backbone_path) self.out_channels = [1024, 512, 512, 256, 256, 256] else: # backbone == 'resnet152': backbone = resnet152(pretrained=not backbone_path) self.out_channels = [1024, 512, 512, 256, 256, 256] if backbone_path: backbone.load_state_dict(torch.load(backbone_path)) for name, parameter in backbone.named_parameters(): if 'layer2' not in name and 'layer3' not in name and 'layer4' not in name: parameter.requires_grad_(False) self.feature_extractor = nn.Sequential(*list(backbone.children())[:7]) conv4_block1 = self.feature_extractor[-1][0] conv4_block1.conv1.stride = (1, 1) conv4_block1.conv2.stride = (1, 1) conv4_block1.downsample[0].stride = (1, 1)
def __init__(self, num_output): super().__init__() # self.resizing = nn.UpsamplingBilinear2d(size=(224, 224)) # self.feature_extractor = torch.hub.load('pytorch/vision:v0.6.0', 'resnet18', pretrained=False) self.feature_extractor = resnet18(norm_layer=Norm_Layer) self.feature_extractor.fc =nn.Linear(self.feature_extractor.fc.in_features, num_output) self.apply(init_layers)
def __init__(self, backbone, num_classes=21): super().__init__() if backbone == 'resnet-18': self.backbone = resnet18() self.in_channel = [512, 128, 64, 64] self.out_channel = [256, 64, 64, 64] elif backbone == 'resnet-34': self.backbone = resnet34() self.in_channel = [512, 128, 64, 64] self.out_channel = [256, 64, 64, 64] elif backbone == 'resnet-50': self.backbone = resnet50() self.in_channel = [2048, 512, 256, 64] self.out_channel = [1024, 256, 64, 64] elif backbone == 'resnet-101': self.backbone = resnet101() self.in_channel = [2048, 512, 256, 64] self.out_channel = [1024, 256, 64, 64] elif backbone == 'resnet-152': self.backbone = resnet152() self.in_channel = [2048, 512, 256, 64] self.out_channel = [1024, 256, 64, 64] else: raise NotImplementedError self.encoder = Encoder(self.backbone) self.decoder = Decoder(self.in_channel, self.out_channel) self.out = nn.Conv2d(64, num_classes, 1) self._init_weight()
def __init__(self): super(YOLO_v1, self).__init__() resnet = resnet18(pretrained=True) # 调用torchvision里的resnet34预训练模型 resnet_out_channel = resnet.fc.in_features # 记录resnet全连接层之前的网络输出通道数,方便连入后续卷积网络中 self.resnet = nn.Sequential(*list( resnet.children())[:-2]) # 去除resnet的最后两层 # 以下是YOLOv1的最后四个卷积层 self.Conv_layers = nn.Sequential( nn.Conv2d(resnet_out_channel, 1024, 3, padding=1), nn.BatchNorm2d(1024), # 为了加快训练,这里增加了BN层,原论文里YOLOv1是没有的 nn.LeakyReLU(), nn.Conv2d(1024, 1024, 3, stride=2, padding=1), nn.BatchNorm2d(1024), nn.LeakyReLU(), nn.Conv2d(1024, 1024, 3, padding=1), nn.BatchNorm2d(1024), nn.LeakyReLU(), nn.Conv2d(1024, 1024, 3, padding=1), nn.BatchNorm2d(1024), nn.LeakyReLU(), ) # 以下是YOLOv1的最后2个全连接层 self.Conn_layers = nn.Sequential( nn.Linear(7 * 7 * 1024, 4096), nn.LeakyReLU(), nn.Linear(4096, 7 * 7 * 30), nn.Sigmoid( ) # 增加sigmoid函数是为了将输出全部映射到(0,1)之间,因为如果出现负数或太大的数,后续计算loss会很麻烦 )
def __init__(self, backbone="resnet50", backbone_path=None): super().__init__() if backbone == "resnet18": backbone = resnet18(pretrained=not backbone_path) self.out_channels = [256, 512, 512, 256, 256, 128] elif backbone == "resnet34": backbone = resnet34(pretrained=not backbone_path) self.out_channels = [256, 512, 512, 256, 256, 256] elif backbone == "resnet50": backbone = resnet50(pretrained=not backbone_path) self.out_channels = [1024, 512, 512, 256, 256, 256] elif backbone == "resnet101": backbone = resnet101(pretrained=not backbone_path) self.out_channels = [1024, 512, 512, 256, 256, 256] else: backbone = resnet152(pretrained=not backbone_path) self.out_channels = [1024, 512, 512, 256, 256, 256] if backbone_path: backbone.load_state_dict(torch.load(backbone_path)) self.feature_extractor = nn.Sequential(*list(backbone.children())[:7]) conv4_block1 = self.feature_extractor[-1][0] conv4_block1.conv1.stride = (1, 1) conv4_block1.conv2.stride = (1, 1) conv4_block1.downsample[0].stride = (1, 1)
def __init__(self, chan_in=3, chan_out=64, pretrained=True): super().__init__() resnet = resnet18(pretrained=pretrained) self.inconv = ConvBlock(chan_in, 64, k=3) self.layer1 = resnet.layer1 self.layer2 = resnet.layer1 self.outconv = ConvBlock(64, chan_out, k=1, activation=False)
def __init__(self, inC, outC): super(BevEncode, self).__init__() trunk = resnet18(pretrained=False, zero_init_residual=True) self.conv1 = nn.Conv2d(inC, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = trunk.bn1 self.relu = trunk.relu self.layer1 = trunk.layer1 self.layer2 = trunk.layer2 self.layer3 = trunk.layer3 self.up1 = Up(64 + 256, 256, scale_factor=4) self.up2 = nn.Sequential( nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True), nn.Conv2d(256, 128, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.Conv2d(128, outC, kernel_size=1, padding=0), )
def __init__(self, cin, cout, with_skip, dropout_p): super(CNN, self).__init__() self.cin = cin self.cout = cout self.trunk = resnet18(pretrained=False, zero_init_residual=True) self.trunk.conv1 = nn.Conv2d(cin, 64, kernel_size=7, stride=2, padding=3, bias=False) self.downscale = nn.Sequential( nn.Conv2d(512, 512, kernel_size=3, stride=2, padding=1, bias=False), ) self.upscale0 = gen_up(512, 512, scale=2) self.upscale1 = gen_up(512, 256, scale=4) if with_skip: self.upscale2 = gen_up(256+128, 256, scale=2) self.upscale3 = gen_up(256+64, 128, scale=4) else: self.upscale2 = gen_up(256, 256, scale=2) self.upscale3 = gen_up(256, 128, scale=4) self.with_skip = with_skip self.final = nn.Conv2d(128, cout, 1) self.dropout = nn.Dropout(p=dropout_p, inplace=False)
def __init__(self, backbone='resnet50'): super().__init__() if backbone == 'resnet18': backbone = resnet18(pretrained=True) self.out_channels = [256, 512, 512, 256, 256, 128] elif backbone == 'resnet34': backbone = resnet34(pretrained=True) self.out_channels = [256, 512, 512, 256, 256, 256] elif backbone == 'resnet50': backbone = resnet50(pretrained=True) self.out_channels = [1024, 512, 512, 256, 256, 256] elif backbone == 'resnet101': backbone = resnet101(pretrained=True) self.out_channels = [1024, 512, 512, 256, 256, 256] else: # backbone == 'resnet152': backbone = resnet152(pretrained=True) self.out_channels = [1024, 512, 512, 256, 256, 256] self.feature_extractor = nn.Sequential(*list(backbone.children())[:7]) conv4_block1 = self.feature_extractor[-1][0] conv4_block1.conv1.stride = (1, 1) conv4_block1.conv2.stride = (1, 1) conv4_block1.downsample[0].stride = (1, 1)
def create_model(model_name, num_classes=1000, pretrained=False, **kwargs): if 'test_time_pool' in kwargs: test_time_pool = kwargs.pop('test_time_pool') else: test_time_pool = True if 'extra' in kwargs: extra = kwargs.pop('extra') else: extra = True if model_name == 'dpn68': model = dpn68( num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool) elif model_name == 'dpn68b': model = dpn68b( num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool) elif model_name == 'dpn92': model = dpn92( num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool, extra=extra) elif model_name == 'dpn98': model = dpn98( num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool) elif model_name == 'dpn131': model = dpn131( num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool) elif model_name == 'dpn107': model = dpn107( num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool) elif model_name == 'resnet18': model = resnet18(num_classes=num_classes, pretrained=pretrained, **kwargs) elif model_name == 'resnet34': model = resnet34(num_classes=num_classes, pretrained=pretrained, **kwargs) elif model_name == 'resnet50': model = resnet50(num_classes=num_classes, pretrained=pretrained, **kwargs) elif model_name == 'resnet101': model = resnet101(num_classes=num_classes, pretrained=pretrained, **kwargs) elif model_name == 'resnet152': model = resnet152(num_classes=num_classes, pretrained=pretrained, **kwargs) elif model_name == 'densenet121': model = densenet121(num_classes=num_classes, pretrained=pretrained, **kwargs) elif model_name == 'densenet161': model = densenet161(num_classes=num_classes, pretrained=pretrained, **kwargs) elif model_name == 'densenet169': model = densenet169(num_classes=num_classes, pretrained=pretrained, **kwargs) elif model_name == 'densenet201': model = densenet201(num_classes=num_classes, pretrained=pretrained, **kwargs) elif model_name == 'inception_v3': model = inception_v3( num_classes=num_classes, pretrained=pretrained, transform_input=False, **kwargs) else: assert False, "Unknown model architecture (%s)" % model_name return model