def forward(self, x): conv1 = self.conv_block1(x) conv2 = self.conv_block2(conv1) conv3 = self.conv_block3(conv2) conv4 = self.conv_block4(conv3) conv5 = self.conv_block5(conv4) score = self.classifier(conv5) score_pool4 = self.score_pool4(conv4) score = F.upsample_bilinear(score, score_pool4.size()[2:]) score += score_pool4 out = F.upsample_bilinear(score, x.size()[2:]) return out
def batch_augment(images, attention_map, mode='crop', theta=0.5, padding_ratio=0.1): batches, _, imgH, imgW = images.size() if mode == 'crop': crop_images = [] for batch_index in range(batches): atten_map = attention_map[batch_index:batch_index + 1] if isinstance(theta, tuple): theta_c = random.uniform(*theta) * atten_map.max() else: theta_c = theta * atten_map.max() crop_mask = F.upsample_bilinear(atten_map, size=(imgH, imgW)) >= theta_c nonzero_indices = torch.nonzero(crop_mask[0, 0, ...]) height_min = max(int(nonzero_indices[:, 0].min().item() - padding_ratio * imgH), 0) height_max = min(int(nonzero_indices[:, 0].max().item() + padding_ratio * imgH), imgH) width_min = max(int(nonzero_indices[:, 1].min().item() - padding_ratio * imgW), 0) width_max = min(int(nonzero_indices[:, 1].max().item() + padding_ratio * imgW), imgW) crop_images.append( F.upsample_bilinear(images[batch_index:batch_index + 1, :, height_min:height_max, width_min:width_max], size=(imgH, imgW))) crop_images = torch.cat(crop_images, dim=0) return crop_images elif mode == 'drop': drop_masks = [] for batch_index in range(batches): atten_map = attention_map[batch_index:batch_index + 1] if isinstance(theta, tuple): theta_d = random.uniform(*theta) * atten_map.max() else: theta_d = theta * atten_map.max() drop_masks.append(F.upsample_bilinear(atten_map, size=(imgH, imgW)) < theta_d) drop_masks = torch.cat(drop_masks, dim=0) drop_images = images * drop_masks.float() return drop_images else: raise ValueError('Expected mode in [\'crop\', \'drop\'], but received unsupported augmentation method %s' % mode)
def forward(self, x): """ :param x: :return: """ x_size = x.size()[2:] x_conv1 = self.conv1_bn(x) x_conv2 = self.conv2_dw(x_conv1) x_conv3 = self.conv3_dw(x_conv2) x_conv4 = self.conv4_dw(x_conv3) x_conv5 = self.conv5_dw(x_conv4) x_conv6 = self.conv6_dw(x_conv5) x_conv7 = self.conv7_dw(x_conv6) x_conv8 = self.conv8_dw(x_conv7) x_conv9 = self.conv9_dw(x_conv8) x_conv10 = self.conv10_dw(x_conv9) x_conv11 = self.conv11_dw(x_conv10) x_conv12 = self.conv12_dw(x_conv11) x_conv13 = self.conv13_dw(x_conv12) x = self.conv14_dw(x_conv13) # x = self.avg_pool(x) # x = x.view(-1, 1024) # x = self.fc(x) score = self.classifier(x) if self.module_type == '16s' or self.module_type == '8s': score_pool4 = self.score_pool4(x_conv12) if self.module_type == '8s': score_pool3 = self.score_pool3(x_conv6) if self.module_type == '16s' or self.module_type == '8s': score = F.upsample_bilinear(score, score_pool4.size()[2:]) score += score_pool4 if self.module_type == '8s': score = F.upsample_bilinear(score, score_pool3.size()[2:]) score += score_pool3 out = F.upsample_bilinear(score, x_size) return out
def forward(self, x): x_size = x.size()[2:] x_conv1 = self.conv1(x) x = self.bn1(x_conv1) x = self.relu(x) x = self.maxpool(x) x_layer1 = self.layer1(x) x_layer2 = self.layer2(x_layer1) x_layer3 = self.layer3(x_layer2) x = self.layer4(x_layer3) # x = self.avgpool(x) # x = x.view(x.size(0), -1) # x = self.fc(x) score = self.classifier(x) if self.module_type == '16s' or self.module_type == '8s': score_pool4 = self.score_pool4(x_layer3) if self.module_type == '8s': score_pool3 = self.score_pool3(x_layer2) if self.module_type == '16s' or self.module_type == '8s': # print('score_pool4.size():', score_pool4.size()) # print('score.size():', score.size()) if self.upsample_method == 'upsample_bilinear': score = F.upsample_bilinear(score, score_pool4.size()[2:]) elif self.upsample_method == 'ConvTranspose2d': score = self.upsample_1(score) score += score_pool4 if self.module_type == '8s': # print('score_pool3.size():', score_pool3.size()) # print('score.size():', score.size()) if self.upsample_method == 'upsample_bilinear': score = F.upsample_bilinear(score, score_pool3.size()[2:]) elif self.upsample_method == 'ConvTranspose2d': score = self.upsample_2(score) score += score_pool3 out = F.upsample_bilinear(score, x_size) return out
def forward(self, feed_dict): prediction_dict = {} # base model base_feat = self.feature_extractor.first_stage_feature( feed_dict['img']) feed_dict.update({'base_feat': base_feat}) # rpn model prediction_dict.update(self.rpn_model.forward(feed_dict)) # proposals = prediction_dict['proposals_batch'] # shape(N,num_proposals,5) # pre subsample for reduce consume of memory if self.training: self.pre_subsample(prediction_dict, feed_dict) rois_batch = prediction_dict['rois_batch'] # note here base_feat (N,C,H,W),rois_batch (N,num_proposals,5) pooled_feat = self.rcnn_pooling(base_feat, rois_batch.view(-1, 5)) # shape(N,C,1,1) pooled_feat = self.feature_extractor.second_stage_feature(pooled_feat) pooled_feat_cls = self.feature_extractor.third_stage_feature( pooled_feat) # self.add_feat('base_feat', base_feat) # shape(N,C) # pooled_feat_cls = F.upsample_bilinear(pooled_feat, scale_factor=2) pooled_feat_bbox = pooled_feat.mean(3).mean(2) # pooled_feat_cls = pooled_feat_cls.mean(3).mean(2) rcnn_bbox_preds = self.rcnn_bbox_pred(pooled_feat_bbox) rcnn_cls_scores_map = self.rcnn_cls_pred(pooled_feat_cls) rcnn_cls_scores_map = F.upsample_bilinear( rcnn_cls_scores_map, scale_factor=2) rcnn_cls_scores = rcnn_cls_scores_map.view(-1, 2, self.pooling_size * self.pooling_size) rcnn_cls_probs = F.softmax(rcnn_cls_scores, dim=1) rcnn_cls_probs = rcnn_cls_probs.sum(dim=-1) prediction_dict['rcnn_cls_probs'] = rcnn_cls_probs prediction_dict['rcnn_bbox_preds'] = rcnn_bbox_preds prediction_dict['rcnn_cls_scores'] = rcnn_cls_scores # used for track proposals_order = prediction_dict['proposals_order'] prediction_dict['second_rpn_anchors'] = prediction_dict['anchors'][ proposals_order] return prediction_dict
def forward(self, x): original_shape = (x.shape[2], x.shape[3]) x32 = self.x32(x) c32 = self.c32(x32) x16 = self.x16(x32) c16 = self.c16(x16) x8 = self.x8(x16) c8 = self.c8(x8) c32 = F.upsample_bilinear(c32, original_shape) c16 = F.upsample_bilinear(c16, original_shape) c8 = F.upsample_bilinear(c8, original_shape) x = c32 + c16 + c8 x = F.log_softmax(x, dim=1) return x
def forward(self, x): input_size = x.size()[2:] feats = self.feats[0](x) feats3 = self.feats[1](feats) feats4 = self.feats[2](feats3) feats5 = self.feats[3](feats4) feats_fconn = self.fconn(feats5) # feats = [feats, feats3, feats4, feats5, feats_fconn] score_feat3 = self.score[0](feats3) score_feat4 = self.score[1](feats4) score_fconn = self.score[2](feats_fconn) score = F.upsample_bilinear(score_fconn, score_feat4.size()[2:]) score += score_feat4 score = F.upsample_bilinear(score, score_feat3.size()[2:]) score += score_feat3 return F.upsample_bilinear(score, input_size)
def forward(self, x): conv1 = self.conv1(x) denseblock1 = self.denseblock1(conv1) denseblock2 = self.denseblock2(denseblock1) denseblock3 = self.denseblock3(denseblock2) denseblock4 = self.denseblock4(denseblock3) x1 = conv1 x2 = denseblock1 x3 = F.upsample_bilinear(denseblock2, x1.size()[2:]) x4 = F.upsample_bilinear(denseblock3, x1.size()[2:]) x5 = F.upsample_bilinear(denseblock4, x1.size()[2:]) xglobal = F.max_pool2d(x5, kernel_size=x5.size()[2:]) out = torch.cat((x1, x2, x3, x4, x5,xglobal.expand(x1.size()[0],1920,x1.size()[2],x1.size()[3])), 1) # out = torch.cat((x1, x2, x3, x4, x5), 1) return out
def forward(self, x): conv1 = self.conv_block1(x) maskedconv = self.pixelcnn(conv1) conv2 = self.conv_block2(maskedconv) conv3 = self.conv_block3(conv2) conv4 = self.conv_block4(conv3) conv5 = self.conv_block5(conv4) score = self.classifier(conv5) score_pool4 = self.score_pool4(conv4) score_pool3 = self.score_pool3(conv3) score = F.upsample_bilinear(score, score_pool4.size()[2:]) score += score_pool4 score = F.upsample_bilinear(score, score_pool3.size()[2:]) score += score_pool3 out = F.upsample_bilinear(score, x.size()[2:]) return out
def forward(self, imgs, labels): n, h, w = labels.shape out = self.stage1(imgs) out = self.stage2(out) preds1 = self.classifier1(out) preds1 = F.upsample_bilinear(preds1, size=(h, w)) out = self.stage3(out) preds2 = self.classifier2(out) preds2 = F.upsample_bilinear(preds2, size=(h, w)) out = self.stage4(out) preds3 = self.classifier3(out) preds3 = F.upsample_bilinear(preds3, size=(h, w)) #print preds.shape preds = preds1 + preds2 + preds3 loss = F.nll_loss(F.log_softmax(preds), labels) return preds, loss, torch.stack([preds1, preds2, preds3])
def forward(self, x): en1 = self.down1(x) po1 = self.pool1(en1) en2 = self.down2(po1) po2 = self.pool2(en2) en3 = self.down3(po2) po3 = self.pool3(en3) en4 = self.down4(po3) po4 = self.pool4(en4) c1 = self.center(po4) dec1 = self.up1(torch.cat([c1, F.upsample_bilinear(en4, c1.size()[2:])], 1)) dec2 = self.up2(torch.cat([dec1, F.upsample_bilinear(en3, dec1.size()[2:])], 1)) dec3 = self.up3(torch.cat([dec2, F.upsample_bilinear(en2, dec2.size()[2:])], 1)) dec4 = self.up4(torch.cat([dec3, F.upsample_bilinear(en1, dec3.size()[2:])], 1)) out = self.output(dec4) return self.final(out)
def forward(self, x): # if x: 512 fm0 = self.layer0(x) # 256 fm1 = self.layer1(fm0) # 128 fm2 = self.layer2(fm1) # 64 fm3 = self.layer3(fm2) # 32 fm4 = self.layer4(fm3) # 16 gcfm1 = self.brm1(self.gcm1(fm4)) # 16 gcfm2 = self.brm2(self.gcm2(fm3)) # 32 gcfm3 = self.brm3(self.gcm3(fm2)) # 64 gcfm4 = self.brm4(self.gcm4(fm1)) # 128 fs1 = self.brm5(F.upsample_bilinear(gcfm1, fm3.size()[2:]) + gcfm2) # 32 fs2 = self.brm6(F.upsample_bilinear(fs1, fm2.size()[2:]) + gcfm3) # 64 fs3 = self.brm7(F.upsample_bilinear(fs2, fm1.size()[2:]) + gcfm4) # 128 fs4 = self.brm8(F.upsample_bilinear(fs3, fm0.size()[2:])) # 256 out = self.brm9(F.upsample_bilinear(fs4, self.input_size)) # 512 return out
def forward(self, Rf, Mf): Mf_size = Mf.size() # print('Rf.shape:', Rf.shape) # print('Mf.shape:', Mf.shape) mf = self.conv_M2m(Mf) # print('mf.shape:', mf.shape) # print('Rf.shape:', Rf.shape) rf = torch.cat((mf[:, :, :Rf.shape[2], :Rf.shape[3]], Rf), 1) rf = self.conv_R2r(rf) out = F.upsample_bilinear(rf, Mf_size[2:]) return out
def forward(self, x): # if x: 512 fm0 = self.layer0(x) # 256 fm1 = self.layer1(fm0) # 128 fm2 = self.layer2(fm1) # 64 fm3 = self.layer3(fm2) # 32 fm4 = self.layer4(fm3) # 16 gcfm1 = self.brm1(self.gcm1(fm4)) # 16 gcfm2 = self.brm2(self.gcm2(fm3)) # 32 gcfm3 = self.brm3(self.gcm3(fm2)) # 64 gcfm4 = self.brm4(self.gcm4(fm1)) # 128 fs1 = self.brm5(F.upsample_bilinear(gcfm1, fm3.size()[2:]) + gcfm2) # 32 fs2 = self.brm6(F.upsample_bilinear(fs1, fm2.size()[2:]) + gcfm3) # 64 fs3 = self.brm7(F.upsample_bilinear(fs2, fm1.size()[2:]) + gcfm4) # 128 fs4 = self.brm8(F.upsample_bilinear(fs3, fm0.size()[2:])) # 256 out = self.brm9(F.upsample_bilinear(fs4, self.input_size)) # 512 return out
def forward(self, x, low_level_feat): low_level_feat = self.conv1(low_level_feat) low_level_feat = self.bn1(low_level_feat) low_level_feat = self.relu(low_level_feat) x = F.upsample_bilinear(x, size=low_level_feat.size()[2:]) #x = F.interpolate(x, size=low_level_feat.size()[2:], mode='bilinear', align_corners=True) x = torch.cat((x, low_level_feat), dim=1) x = self.last_conv(x) return x
def forward(self, x): x = self.conv1(x) # -,-,320 x = self.norm1(x) x = self.relu1(x) # print(x.size()) x = self.conv2(x) # -,-,160 x = self.norm2(x) x = self.relu2(x) # print(x.size()) x = self.conv3(x) # -,-,80 x = self.norm3(x) x = self.relu3(x) # print(x.size()) x = self.conv4(x) # -,-,40 x = self.norm4(x) x = self.relu4(x) # print(x.size()) x = self.conv5(x) # -,-,20 # print(x.size()) # upsample x = F.upsample_bilinear(x, scale_factor=2) x = x[:, :, :-1, :-1] # -,-, 31,31 # print(x.size()) x = F.upsample_bilinear(x, scale_factor=2) x = x[:, :, :-1, :-1] # -,-,41,41 # print(x.size()) x = F.upsample_bilinear(x, scale_factor=2) x = x[:, :, :-1, :-1] #-,-,81,81 # print(x.size()) x = F.upsample_bilinear(x, scale_factor=2) x = x[:, :, :-1, :-1] #-,-,161,161 # print(x.size()) x = F.upsample_bilinear(x, scale_factor=2) x = x[:, :, :-2, :-2] # -,-,321,321 # print(x.size()) return x
def forward(self, x): # Normalize x x = (x + 1.) / 2.0 x = (x - self.mean) / self.std # Upsample if necessary if x.shape[2] != 299 or x.shape[3] != 299: if torch.__version__ in ['0.4.0']: x = F.upsample_bilinear(x, size=(299, 299)) else: x = F.interpolate(x, size=(299, 299), mode='bilinear', align_corners=True) # 299 x 299 x 3 x = self.net.Conv2d_1a_3x3(x) # 149 x 149 x 32 x = self.net.Conv2d_2a_3x3(x) # 147 x 147 x 32 x = self.net.Conv2d_2b_3x3(x) # 147 x 147 x 64 x = F.max_pool2d(x, kernel_size=3, stride=2) # 73 x 73 x 64 x = self.net.Conv2d_3b_1x1(x) # 73 x 73 x 80 x = self.net.Conv2d_4a_3x3(x) # 71 x 71 x 192 x = F.max_pool2d(x, kernel_size=3, stride=2) # 35 x 35 x 192 x = self.net.Mixed_5b(x) # 35 x 35 x 256 x = self.net.Mixed_5c(x) # 35 x 35 x 288 x = self.net.Mixed_5d(x) # 35 x 35 x 288 x = self.net.Mixed_6a(x) # 17 x 17 x 768 x = self.net.Mixed_6b(x) # 17 x 17 x 768 x = self.net.Mixed_6c(x) # 17 x 17 x 768 x = self.net.Mixed_6d(x) # 17 x 17 x 768 x = self.net.Mixed_6e(x) # 17 x 17 x 768 # 17 x 17 x 768 x = self.net.Mixed_7a(x) # 8 x 8 x 1280 x = self.net.Mixed_7b(x) # 8 x 8 x 2048 x = self.net.Mixed_7c(x) # 8 x 8 x 2048 pool = torch.mean(x.view(x.size(0), x.size(1), -1), 2) # 1 x 1 x 2048 logits = self.net.fc(F.dropout(pool, training=False).view(pool.size(0), -1)) # 1000 (num_classes) return pool, logits
def forward(self, x): enc1 = self.enc1(x) enc2 = self.enc2(enc1) enc3 = self.enc3(enc2) enc4 = self.enc4(enc3) center = self.center(enc4) dec4 = self.dec4( torch.cat( [center, F.upsample_bilinear(enc4, center.size()[2:])], 1)) dec3 = self.dec3( torch.cat([dec4, F.upsample_bilinear(enc3, dec4.size()[2:])], 1)) dec2 = self.dec2( torch.cat([dec3, F.upsample_bilinear(enc2, dec3.size()[2:])], 1)) dec1 = self.dec1( torch.cat([dec2, F.upsample_bilinear(enc1, dec2.size()[2:])], 1)) final = self.final(dec1) return F.upsample_bilinear(final, x.size()[2:])
def forward(self, feats): cls_score, mask_feats = multi_apply(self.forward_single, feats, self.scales) mask_feats[0] = self.solo_mask3(mask_feats[0]) mask_feats[1] = self.solo_mask4(mask_feats[1]) mask_feats[2] = self.solo_mask5(mask_feats[2]) mask_feats[3] = self.solo_mask6(mask_feats[3]) mask_feats[4] = self.solo_mask7(mask_feats[4]) for i in range(5): cls_score[i] = F.upsample_bilinear( cls_score[i], (self.grid_num[i], self.grid_num[i])) return cls_score, mask_feats
def forward(self, x): x_share = self.frontend(x) x_auxiliary = self.auxiliary_backend(x_share) x_auxiliary = self.auxiliary_backend_output_layer(x_auxiliary) x_auxiliary_output = F.upsample_bilinear(x_auxiliary, size=(128, 128)) # 从32x32插值到128x128得到mask map x_trunk = x_share * x_auxiliary_output x_trunk_backend = self.trunk_backend(x_trunk) x_trunk_output = self.density_map_layer(x_trunk_backend) return x_auxiliary_output, x_trunk_output
def forward(self, *input): conv2_2, conv3_3, conv4_4, conv5_4 = input input = torch.cat([conv5_4, conv4_4], 1) input = self.conv1(input) input = self.conv2(input) input = F.upsample_bilinear(input, scale_factor=2) input = torch.cat( [input, conv3_3, F.upsample_bilinear(conv5_4, scale_factor=2)], 1) input = self.conv3(input) input = self.conv4(input) input = F.upsample_bilinear(input, scale_factor=2) input = torch.cat([input, conv2_2], 1) input = self.conv5(input) input = self.conv6(input) input = self.conv7(input) return input
def forward(self, input, upsampling_shape): if self.conv_flag: self.basic_unit = self.attention_branch_base_unit(input) else: self.basic_unit = self.attention_branch_base_unit(input) self.base_unit = F.upsample_bilinear(self.basic_unit, size=upsampling_shape[2:]) self.attention_weights = self.attention_mask(self.basic_unit, upsampling_shape) return self.attention_weights
def forward(self, x): #Size of input=1,num_classes,256,256 feats = self.feats(x) #1,128,64,64 feat3 = self.feat3(feats)#1,256,32,32 feat4 = self.feat4(feat3)#1,512,16,16 feat5 = self.feat5(feat4)#1,512,8,8 fconn = self.fconn(feat5)#1,4096,8,8 score_feat3 = self.score_feat3(feat3)#1,num_classes,32,32 score_feat4 = self.score_feat4(feat4)#1,num_classes,16,16 score_fconn = self.score_fconn(fconn)#1,num_classes,8,8 score = F.upsample_bilinear(score_fconn, score_feat4.size()[2:]) score += score_feat4 score = F.upsample_bilinear(score, score_feat3.size()[2:]) score += score_feat3 output = F.upsample_bilinear(score, x.size()[2:])#1,num_classes,256,256 return output
def forward(self, x): space_nlb_1 = self.space_nlb_1(x) space_nlb_2 = self.space_nlb_2(x) space_nlb_3 = self.space_nlb_3(x) space_nlb_4 = self.space_nlb_4(x) space_nlb_1 = F.upsample_bilinear(space_nlb_1, size=space_nlb_1.size()[2:]) space_nlb_2 = F.upsample_bilinear(space_nlb_2, size=space_nlb_1.size()[2:]) space_nlb_3 = F.upsample_bilinear(space_nlb_3, size=space_nlb_1.size()[2:]) space_nlb_4 = F.upsample_bilinear(space_nlb_4, size=space_nlb_1.size()[2:]) x = F.upsample_bilinear(x, size=space_nlb_1.size()[2:]) SF = self.spatial_fuse( torch.cat((x, space_nlb_1, space_nlb_2, space_nlb_3, space_nlb_4), 1)) return SF
def forward(self, x): conv1 = self.conv_block1(x) ##x shape:(6,3,96,96) conv2 = self.conv_block2(conv1) conv3 = self.conv_block3(conv2) conv4 = self.conv_block4(conv3) conv5 = self.conv_block5(conv4) score = self.classifier(conv5) # score shape:(6,21,4,4) out = F.upsample_bilinear(score, x.size()[2:]) #out shape:(6,21,96,96) return out
def forward(self, x): dec1 = self.dec1(x) dec2 = self.dec2(dec1) dec3 = self.dec3(dec2) dec4 = self.dec4(dec3) center = self.center(dec4) enc4 = self.enc4( torch.cat( [center, F.upsample_bilinear(dec4, center.size()[2:])], 1)) enc3 = self.enc3( torch.cat([enc4, F.upsample_bilinear(dec3, enc4.size()[2:])], 1)) enc2 = self.enc2( torch.cat([enc3, F.upsample_bilinear(dec2, enc3.size()[2:])], 1)) enc1 = self.enc1( torch.cat([enc2, F.upsample_bilinear(dec1, enc2.size()[2:])], 1)) return F.upsample_bilinear(self.final(enc1), x.size()[2:])
def forward(self, x): convert = self.convert(x) conv1 = self.conv_1(convert) b1, c1, h1, w1 = conv1.size() pooling1 = self.pooling_1(conv1) conv2 = self.conv_2(pooling1) b2, c2, h2, w2 = conv2.size() pooling2 = self.pooling_2(conv2) conv3 = self.conv_3(pooling2) conv4 = self.conv_4( self.cat_1( torch.cat([F.upsample_bilinear(conv3, size=[h2, w2]), conv2], dim=1))) conv5 = self.conv_5( self.cat_2( torch.cat([F.upsample_bilinear(conv4, size=[h1, w1]), conv1], dim=1))) rain_streak = self.out(conv5) return rain_streak
def forward(self, x): conv1 = self.conv_block1(x) conv2 = self.conv_block2(conv1) conv3 = self.conv_block3(conv2) conv4 = self.conv_block4(conv3) conv5 = self.conv_block5(conv4) score = self.classifier(conv5) out = F.upsample_bilinear(score, x.size()[2:]) return out
def forward(self, x): #256 down1 = self.down1(x) out = F.max_pool2d(down1, kernel_size=2, stride=2) #64 down2 = self.down2(out) out = F.max_pool2d(down2, kernel_size=2, stride=2) #32 down3 = self.down3(out) out = F.max_pool2d(down3, kernel_size=2, stride=2) #16 down4 = self.down4(out) out = F.max_pool2d(down4, kernel_size=2, stride=2) # 8 out = self.same(out) out = F.upsample_bilinear(out, scale_factor=2) #16 out = torch.cat([down4, out], 1) out = self.up4(out) out = F.upsample_bilinear(out, scale_factor=2) #32 out = torch.cat([down3, out], 1) out = self.up3(out) out = F.upsample_bilinear(out, scale_factor=2) #64 out = torch.cat([down2, out], 1) out = self.up2(out) out = F.upsample_bilinear(out, scale_factor=2) #128 out = torch.cat([down1, out], 1) out = self.up1(out) out = F.upsample_bilinear(out, scale_factor=2) #256 out = self.up0(out) out = self.classify(out) return out
def forward(self, x): input_size = x.size()[2:] x = self.block1(x) x = self.block2(x) x = self.block3(x) if self.scale <= 8: score_8s = self.score_8s(x) x = self.block4(x) if self.scale <= 16: score_16s = self.score_16s(x) x = self.block5(x) score_32s = self.score_32s(x) if self.scale == 32: score = F.upsample_bilinear(score_32s, input_size) elif self.scale == 16: score_16s += F.upsample_bilinear(score_32s, score_16s.size()[2:]) score = F.upsample_bilinear(score_16s, input_size) elif self.scale == 8: score_16s += F.upsample_bilinear(score_32s, score_16s.size()[2:]) score_8s += F.upsample_bilinear(score_16s, score_8s.size()[2:]) score = F.upsample_bilinear(score_8s, input_size) return score
def forward(self, x): input_size = x.size()[2:] x = self.resnet.conv1(x) x = self.resnet.bn1(x) x = self.resnet.relu(x) x = self.resnet.maxpool(x) x = self.resnet.layer1(x) x = self.resnet.layer2(x) if self.scale <= 8: score_8s = self.score_8s(x) x = self.resnet.layer3(x) if self.scale <= 16: score_16s = self.score_16s(x) x = self.resnet.layer4(x) score_32s = self.score_32s(x) if self.scale == 32: score = F.upsample_bilinear(score_32s, input_size) elif self.scale == 16: score_16s += F.upsample_bilinear(score_32s, score_16s.size()[2:]) score = F.upsample_bilinear(score_16s, input_size) elif self.scale == 8: score_16s += F.upsample_bilinear(score_32s, score_16s.size()[2:]) score_8s += F.upsample_bilinear(score_16s, score_8s.size()[2:]) score = F.upsample_bilinear(score_8s, input_size) return score
def forward(self, x): # ----normal forward---- x = self.conv1(x) x = self.bn1(x) x = self.relu(x) x = self.maxpool(x) x_1 = self.layer1(x) x_2 = self.layer2(x_1) x_3 = self.layer3(x_2) x_4 = self.layer4(x_3) # ----normal forward---- x_4 = self.gcn4(x_4) x_4 = self.br1_4(x_4) x_4_up = F.upsample_bilinear(x_4, x_3.size()[2:]) x_3 = self.gcn3(x_3) x_3 = self.br1_3(x_3) x_3_skip = x_3 + x_4_up x_3_skip = self.br2_3(x_3_skip) x_3_up = F.upsample_bilinear(x_3_skip, x_2.size()[2:]) x_2 = self.gcn2(x_2) x_2 = self.br1_2(x_2) x_2_skip = x_2 + x_3_up x_2_skip = self.br2_2(x_2_skip) x_2_up = F.upsample_bilinear(x_2_skip, x_1.size()[2:]) x_1 = self.gcn1(x_1) x_1 = self.br1_1(x_1) x_1_skip = x_1 + x_2_up x_1_skip = self.br2_1(x_1_skip) x_1_up = F.upsample_bilinear(x_1_skip, scale_factor=2) x_out = self.br3_1(x_1_up) x_out = F.upsample_bilinear(x_out, scale_factor=2) x_out = self.br3_2(x_out) return x_out