def init_modules(self): self.feature_extractor = ResNetFeatureExtractor( self.feature_extractor_config) self.modify_feature_extractor() self.rpn_model = RPNModel(self.rpn_config) if self.pooling_mode == 'align': self.rcnn_pooling = RoIAlignAvg(self.pooling_size, self.pooling_size, 1.0 / 16.0) elif self.pooling_mode == 'ps': self.rcnn_pooling = PSRoIPool(7, 7, 1.0 / 16, 7, self.n_classes) elif self.pooling_mode == 'psalign': raise NotImplementedError('have not implemented yet!') elif self.pooling_mode == 'deformable_psalign': raise NotImplementedError('have not implemented yet!') self.mask_rcnn_pooling = RoIAlignAvg(14, 14, 1.0 / 16.0) # self.rcnn_cls_pred = nn.Linear(2048, self.n_classes) self.rcnn_cls_pred = nn.Conv2d(2048, self.n_classes, 3, 1, 1) if self.reduce: in_channels = 2048 else: in_channels = 2048 * 4 * 4 if self.class_agnostic: self.rcnn_bbox_pred = nn.Linear(in_channels, 4) else: self.rcnn_bbox_pred = nn.Linear(in_channels, 4 * self.n_classes) # loss module if self.use_focal_loss: self.rcnn_cls_loss = FocalLoss(2) else: self.rcnn_cls_loss = functools.partial(F.cross_entropy, reduce=False) self.rcnn_kp_loss = functools.partial(F.cross_entropy, reduce=False, ignore_index=-1) self.rcnn_bbox_loss = nn.modules.SmoothL1Loss(reduce=False) # some 3d statistic # some 2d points projected from 3d self.rcnn_3d_pred = nn.Linear(in_channels, 3) # self.rcnn_3d_loss = MultiBinLoss(num_bins=self.num_bins) # self.rcnn_3d_loss = MultiBinRegLoss(num_bins=self.num_bins) self.rcnn_3d_loss = OrientationLoss(split_loss=True) self.keypoint_predictor = KeyPointPredictor2(1024)
def __init__(self, classes, class_agnostic, alpha_con=None): super(_fasterRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # crowds alpha_con self.alpha_con = alpha_con # label source self.label_source = cfg.LABEL_SOURCE # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model, self.classes, self.n_classes) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_aggregation_layer = _RCNNAggregationLayer() self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop()
def init_modules(self): self.feature_extractor = ResNetFeatureExtractor( self.feature_extractor_config) self.rpn_model = IoURPNModel(self.rpn_config) self.rcnn_pooling = RoIAlignAvg(self.pooling_size, self.pooling_size, 1.0 / 16.0) self.rcnn_cls_pred = nn.Conv2d(2048, self.n_classes, 3, 1, 1) in_channels = 2048 self.rcnn_iou = nn.Linear(in_channels, self.n_classes) self.rcnn_iog = nn.Linear(in_channels, self.n_classes) self.rcnn_iod = nn.Linear(in_channels, self.n_classes) if self.class_agnostic: self.rcnn_bbox_pred = nn.Linear(in_channels, 4) else: self.rcnn_bbox_pred = nn.Linear(in_channels, 4 * self.n_classes) # loss module if self.use_focal_loss: self.rcnn_cls_loss = FocalLoss(2) else: self.rcnn_cls_loss = functools.partial(F.cross_entropy, reduce=False) self.rcnn_iou_loss = nn.MSELoss(reduce=False) self.rcnn_bbox_loss = nn.modules.SmoothL1Loss(reduce=False)
def __init__(self, classes, class_agnostic, meta_train, meta_test=None, meta_loss=None): super(_fasterRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic self.meta_train = meta_train self.meta_test = meta_test self.meta_loss = meta_loss # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop()
def __init__(self, classes, class_agnostic): super(_fasterRCNN2Fc, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling( cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0/16.0) self.RCNN_roi_align = RoIAlignAvg( cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0/16.0) self.RFCN_psroi_pool = None self.grid_size = cfg.POOLING_SIZE * \ 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop() # attention # self.conv_new_1 = nn.Conv2d(2048, 256, 1) # self.fc_new_1 = nn.dense(name='fc1_new_1', num_hidden=1024) # self.fc_new_2 = nn.dense(name='fc2_new_2', num_hidden=1024) self.fc1 = nn.Linear(2048, 1024) self.fc2 = nn.Linear(1024, 1024) self.nongt_dim = 256 if self.training else cfg.TEST.RPN_POST_NMS_TOP_N
def __init__(self, classes, class_agnostic, num_class=20): super(_FPN, self).__init__() self.num_classes = num_class self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 self.maxpool2d = nn.MaxPool2d(1, stride=2) # define rpn self.RCNN_rpn = _RPN_FPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) # NOTE: the original paper used pool_size = 7 for cls branch, and 14 for mask branch, to save the # computation time, we first use 14 as the pool_size, and then do stride=2 pooling for cls branch. self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop() self.top = nn.Sequential( nn.Linear(in_features=12544, out_features=4096, bias=True), nn.ReLU(inplace=True), nn.Dropout(0.5), nn.Linear(in_features=4096, out_features=4096, bias=True), nn.ReLU(inplace=True), nn.Dropout(0.5)) self.fc8c = nn.Linear(4096, self.num_classes) self.fc8d = nn.Linear(4096, self.num_classes)
def __init__(self, classes, class_agnostic, shrink=1, mimic=False, rois=None): super(_fasterRCNN, self).__init__() self.shrink = shrink self.student = True if shrink >= 2 else False self.mimic = mimic self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop()
def __init__(self, classes, class_agnostic): super(_FPN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 self.maxpool2d = nn.MaxPool2d(1, stride=2) # define rpn self.RCNN_rpn = _RPN_FPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) # NOTE: the original paper used pool_size = 7 for cls branch, and 14 for mask branch, to save the # computation time, we first use 14 as the pool_size, and then do stride=2 pooling for cls branch. self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_prroi = PrRoIPool2D( cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) ######## add precision roi pooling ##### self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop()
def __init__(self, classes, class_agnostic, lighthead=False, compact_mode=False): super(_fasterRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic self.lighthead = lighthead # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define Large Separable Convolution Layer if self.lighthead: self.lh_mode = 'S' if compact_mode else 'L' self.lsconv = LargeSeparableConv2d( self.dout_lh_base_model, bias=False, bn=False, setting=self.lh_mode) self.lh_relu = nn.ReLU(inplace=True) # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop() self.rpn_time = None self.pre_roi_time = None self.roi_pooling_time = None self.subnet_time = None
def __init__(self, classes, class_agnostic): super(_fasterRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_deform_roi_pool_1 = DeformRoIFunction(pool_height=7, pool_width=7, spatial_scale=1.0 / 16.0, no_trans=True, trans_std=0.1, sample_per_part=4, output_dim=256, group_size=1, part_size=7) self.RCNN_deform_roi_pool_2 = DeformRoIFunction(pool_height=7, pool_width=7, spatial_scale=1.0 / 16.0, no_trans=False, trans_std=0.1, sample_per_part=4, output_dim=256, group_size=1, part_size=7) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop()
def __init__(self, classes, class_agnostic): super(_fasterRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_rpn_t = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop() self.RCNN_imageDA_3 = _ImageDA(256) self.RCNN_imageDA_4 = _ImageDA(512) self.RCNN_imageDA = _ImageDA(self.dout_base_model) self.RCNN_instanceDA = _InstanceDA()
def __init__(self, classes, class_agnostic): super(CoupleNet, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 self.box_num_classes = 1 if class_agnostic else self.n_classes # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_crop = _RoICrop() self.RCNN_psroi_pool_cls = PSRoIPool(cfg.POOLING_SIZE, cfg.POOLING_SIZE, spatial_scale=1 / 16.0, group_size=cfg.POOLING_SIZE, output_dim=self.n_classes) self.RCNN_psroi_pool_loc = PSRoIPool(cfg.POOLING_SIZE, cfg.POOLING_SIZE, spatial_scale=1 / 16.0, group_size=cfg.POOLING_SIZE, output_dim=self.box_num_classes * 4) self.avg_pooling = nn.AvgPool2d(kernel_size=cfg.POOLING_SIZE, stride=cfg.POOLING_SIZE) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE
def __init__(self, main_classes, sub_classes, class_agnostic): super(_hierarchyFasterRCNN, self).__init__() #self.classes = classes self.main_classes = main_classes self.sub_classes = sub_classes self.n_sub_classes = len(sub_classes) self.n_main_classes = len(main_classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_sub_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RFCN_psroi_pool = None self.grid_size = cfg.POOLING_SIZE * \ 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop()
def init_modules(self): self.feature_extractor = ResNetFeatureExtractor( self.feature_extractor_config) self.rpn_model = RPNModel(self.rpn_config) self.rcnn_pooling = RoIAlignAvg(self.pooling_size, self.pooling_size, 1.0 / 16.0) # self.rcnn_cls_pred = nn.Conv2d(2048, self.n_classes, 3, 1, 1) self.rcnn_cls_pred = nn.Linear(2048, self.n_classes) self.rcnn_bbox_pred = nn.Conv2d(2048, 4, 3, 1, 1) # if self.class_agnostic: # self.rcnn_bbox_pred = nn.Linear(2048, 4) # else: # self.rcnn_bbox_pred = nn.Linear(2048, 4 * self.n_classes) # loss module # if self.use_focal_loss: # self.rcnn_cls_loss = FocalLoss(2) # else: # self.rcnn_cls_loss = functools.partial( # F.cross_entropy, reduce=False) self.rcnn_cls_loss = nn.MSELoss(reduce=False) self.rcnn_bbox_loss = nn.modules.SmoothL1Loss(reduce=False) # attention self.spatial_attention = nn.Conv2d(2048, 1, 3, 1, 1)
def _init_modules(self, load_model=True): resnet = resnet101() self.RCNN_base = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, resnet.layer2, resnet.layer3) self.RCNN_top = nn.Sequential(resnet.layer4) self.Linear_top = nn.Linear(2048, self.embedding_dim) if load_model: state_dict = torch.load(self.oneshot_model_path)['model'] self.load_state_dict({ k: v for k, v in state_dict.items() if k in self.state_dict() }) self.det_module = pseudo_siamese_det(self.det_model_path) self.det_module.create_architecture(load_det_model=load_model) self.det_module.training = False self.RCNN_roi_crop = _RoICrop() self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0)
def __init__(self, classes, num_ways, class_agnostic, meta_train, meta_test=None, meta_loss=None, transductive=None, visualization=None): super(_fasterRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic self.meta_train = meta_train self.meta_test = meta_test self.meta_loss = meta_loss self.simloss = True self.dis_simloss = True self.transductive = transductive self.visualization = visualization # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop() self.num_layers_g = 3 self.num_ways = num_ways self.alpha = 0.5
def __init__(self, classes, class_agnostic): super(_fasterRCNN_OCR, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) # self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_ocr_roi_pooling = roi_pooling(2) # ocr roi_pooling self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop() # rnn初始化,隐藏节点256 nh = 256 nclass = len('0123456789.') + 1 self.rnn = nn.Sequential(BidirectionalLSTM(1024, nh, nh), BidirectionalLSTM(nh, nh, nclass)) self.ctc_critition = CTCLoss().cuda()
def init_modules(self): self.feature_extractor = ResNetFeatureExtractor( self.feature_extractor_config) self.rpn_model = RPNModel(self.rpn_config) if self.pooling_mode == 'align': self.rcnn_pooling = RoIAlignAvg(self.pooling_size, self.pooling_size, 1.0 / 16.0) elif self.pooling_mode == 'ps': self.rcnn_pooling = PSRoIPool(7, 7, 1.0 / 16, 7, self.n_classes) elif self.pooling_mode == 'psalign': raise NotImplementedError('have not implemented yet!') elif self.pooling_mode == 'deformable_psalign': raise NotImplementedError('have not implemented yet!') self.rcnn_cls_pred = nn.Linear(2048, self.n_classes * 2048) # self.rcnn_cls_pred = nn.Conv2d(2048, self.n_classes, 3, 1, 1) if self.class_agnostic: # self.bottle_neck = nn.Sequential( # nn.Linear(2048, 512), # nn.BatchNorm2d(512), # nn.ReLU(inplace=True), # nn.Linear(512, 2048)) # self.rcnn_bbox_pred_top = nn.Linear(2048, 4) # self.relu_top = nn.ReLU(inplace=True) self.rcnn_bbox_pred = nn.Conv2d(2048, 4, 3, 1, 1) else: self.rcnn_bbox_pred = nn.Linear(2048, 4 * self.n_classes) # loss module if self.use_focal_loss: self.rcnn_cls_loss = FocalLoss(2) else: self.rcnn_cls_loss = functools.partial( F.cross_entropy, reduce=False) self.rcnn_bbox_loss = nn.modules.SmoothL1Loss(reduce=False)
def __init__(self, args, num_classes=20): super(WSDDN_VGG16, self).__init__() self.args = args self.num_classes = num_classes self.pretrained_dir = os.path.join(args.dataroot, args.pretrained_path, args.pretrained_model) # VGG16, pth(weakly게 아닐 수도 있음) vgg_model = torchvision.models.vgg16() # 찍어보자 if self.pretrained_dir is None: logger.debug('There is no VGG16 pretrained model') else: logger.info('Loading pretrained VGG16') state_dict = torch.load(self.pretrained_dir) vgg_model.load_state_dict({k: v for k, v in state_dict.items() if k in vgg_model.state_dict()}) """ Network debug """ for k in vgg_model.state_dict(): print('k, v', k) #fc6 어디감? self.base_network = nn.Sequential(*list(vgg_model.features._modules.values())[:-1]) self.top_network = nn.Sequential(*list(vgg_model.classifier._modules.values())[:-1]) self.fc8c = nn.Linear(4096, self.num_classes) self.fc8d = nn.Linear(4096, self.num_classes) # OICR 참고해보자 self.roi_pooling = _RoIPooling(7, 7, 1.0 / 16.0) self.roi_align = RoIAlignAvg(7, 7, 1.0 / 16.0) self._init_weights()
def __init__(self, classes, class_agnostic): super(_fasterRCNN, self).__init__() # 继承父类的__init__()方法 self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn # 实例化,RPN网络(self.dout_base_model)是512,vgg16子类中定义,输入rpn的维度 self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) # grid_size = 7 * 2 = 14 self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop() # dout_base_model = 512 self.RCNN_imageDA = _ImageDA(self.dout_base_model) self.RCNN_instanceDA = _InstanceDA() self.consistency_loss = torch.nn.MSELoss(size_average=False)
def __init__(self, classes, class_agnostic, rpn_batchsize): super(_fasterRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic self.rpn_batchsize = rpn_batchsize # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model, self.rpn_batchsize) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) print 'INFO: pooling size is: ', cfg.POOLING_SIZE_H, cfg.POOLING_SIZE_W self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE_H, cfg.POOLING_SIZE_W, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE_H, cfg.POOLING_SIZE_W, 1.0 / 16.0) ## wrote by Xudong Wang self.grid_size_H = cfg.POOLING_SIZE_H * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE_H self.grid_size_W = cfg.POOLING_SIZE_W * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE_W ## end self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop()
def __init__(self, classes, class_agnostic): super(_fasterRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # define rpn self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop() self.spaCNN = SpaConv() self.spa_cls_score = nn.Sequential(nn.Linear(5408, 1024), nn.LeakyReLU(), nn.Dropout(p=0.5), nn.Linear(1024, self.n_classes)) self.obj_cls_score = nn.Sequential(nn.Linear(300, 512), nn.LeakyReLU(), nn.Linear(512, self.n_classes)) self.obj_attention = nn.Sequential(nn.Linear(300, 512), nn.LeakyReLU(), nn.Linear(512, 6))
def __init__(self, classes, class_agnostic, transfer): super(_fasterRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop() #transfer setting self.transfer = transfer if self.transfer: self.transfer_weight = Variable(torch.Tensor([cfg.TRANSFER_WEIGHT ]).cuda(), requires_grad=True) self.grl = cfg.TRANSFER_GRL self.weight = Variable(torch.zeros(0).cuda(), requires_grad=False) self.transfer_select = cfg.TRANSFER_SELECT self.transfer_gamma = cfg.TRANSFER_GAMMA
def __init__(self, classes, class_agnostic, context, S_agent, T_agent, ts, tt, select_num, candidate_num): super(_fasterRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic self.select_num = select_num self.candidate_num = candidate_num print("self.select_num: %d self.candidate_num: %d " % (self.select_num, self.candidate_num)) # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 self.context = context # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.epsilon_by_epoch = lambda epoch_idx: cfg.epsilon_final + (cfg.epsilon_start - \ cfg.epsilon_final) * math.exp(-1. * epoch_idx / cfg.epsilon_decay) self.iter_dqn = 0 self.epsilon_by_epoch_T = lambda epoch_idx: cfg.epsilon_final + (cfg.epsilon_start - \ cfg.epsilon_final) * math.exp(-1. * epoch_idx / cfg.epsilon_decay) self.iter_dqn_T = 0 self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop()
def __init__(self, classes, class_agnostic): super(_fasterRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) #for p in self.RCNN_rpn.parameters(): p.requires_grad = False self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) # roi pooling in vgg16 # stride = 16 self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) # roi pooling in Generator Network # stride = 2 self.RCNN_roi_pool_conv1 = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 2.0) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop()
def init_modules(self): self.feature_extractor = ResNetFeatureExtractor( self.feature_extractor_config) self.rpn_model = RPNModel(self.rpn_config) if self.pooling_mode == 'align': self.rcnn_pooling = RoIAlignAvg(self.pooling_size, self.pooling_size, 1.0 / 16.0) elif self.pooling_mode == 'ps': self.rcnn_pooling = PSRoIPool(7, 7, 1.0 / 16, 7, self.n_classes) elif self.pooling_mode == 'psalign': raise NotImplementedError('have not implemented yet!') elif self.pooling_mode == 'deformable_psalign': raise NotImplementedError('have not implemented yet!') self.rcnn_cls_pred = nn.Linear(2048, self.n_classes) if self.reduce: in_channels = 2048 else: in_channels = 2048 * 4 * 4 if self.class_agnostic: self.rcnn_bbox_pred = nn.Linear(in_channels, 4) else: self.rcnn_bbox_pred = nn.Linear(in_channels, 4 * self.n_classes) # loss module if self.use_focal_loss: self.rcnn_cls_loss = FocalLoss(2) else: self.rcnn_cls_loss = functools.partial(F.cross_entropy, reduce=False) self.rcnn_bbox_loss = nn.modules.SmoothL1Loss(reduce=False)
def __init__(self, classes, class_agnostic): super(_Deconv, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic #loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 self.maxpool2d = nn.MaxPool2d(1, stride=2) #define rpn # if USE_ONE_FEATURE == 0: self.RCNN_rpn = _RPN_Deconv(self.dout_base_model) # else: # self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop()
def init_modules(self): self.feature_extractor = ResNetFeatureExtractor( self.feature_extractor_config) self.rpn_model = RPNModel(self.rpn_config) if self.pooling_mode == 'align': self.rcnn_pooling = RoIAlignAvg(self.pooling_size, self.pooling_size, 1.0 / 16.0) elif self.pooling_mode == 'ps': self.rcnn_pooling = PSRoIPool(7, 7, 1.0 / 16, 7, self.n_classes) elif self.pooling_mode == 'psalign': raise NotImplementedError('have not implemented yet!') elif self.pooling_mode == 'deformable_psalign': raise NotImplementedError('have not implemented yet!') # self.rcnn_cls_pred = nn.Linear(2048, self.n_classes) self.rcnn_cls_pred = nn.Conv2d(2048, self.n_classes, 3, 1, 1) if self.reduce: in_channels = 2048 else: in_channels = 2048 * 4 * 4 if self.class_agnostic: self.rcnn_bbox_pred = nn.Linear(in_channels, 4) else: self.rcnn_bbox_pred = nn.Linear(in_channels, 4 * self.n_classes) # loss module if self.use_focal_loss: self.rcnn_cls_loss = FocalLoss(2) else: self.rcnn_cls_loss = functools.partial(F.cross_entropy, reduce=False) self.rcnn_bbox_loss = nn.modules.SmoothL1Loss(reduce=False) # some 3d statistic # some 2d points projected from 3d # self.rcnn_3d_preds_new = nn.Linear(in_channels, 3 + 4 * self.num_bins) self.rcnn_3d_loss = MultiBinLoss(num_bins=self.num_bins) # dims self.rcnn_dims_pred = nn.Sequential( *[nn.Linear(in_channels, 256), nn.ReLU(), nn.Linear(256, 3)]) # angle self.rcnn_angle_pred = nn.Sequential(*[ nn.Linear(in_channels, 256), nn.ReLU(), nn.Linear(256, self.num_bins * 2) ]) # angle conf self.rcnn_angle_conf_pred = nn.Sequential(*[ nn.Linear(in_channels, 256), nn.ReLU(), nn.Linear(256, self.num_bins * 2) ])
def init_modules(self): """ some modules """ self.feature_extractor = OFTNetFeatureExtractor( self.feature_extractor_config) feats_reduce_1 = nn.Conv2d(128, self.feat_size, 1, 1, 0) feats_reduce_2 = nn.Conv2d(256, self.feat_size, 1, 1, 0) feats_reduce_3 = nn.Conv2d(512, self.feat_size, 1, 1, 0) self.feats_reduces = nn.ModuleList( [feats_reduce_1, feats_reduce_2, feats_reduce_3]) self.feat_collapse = nn.Conv2d(8, 1, 1, 1, 0) self.rcnn_output_head = nn.Conv2d(1152, self.rcnn_output_channels, 1, 1, 0) self.rpn_output_head = nn.Conv2d(256 * 4, self.rpn_output_channels, 1, 1, 0) # loss self.reg_loss = nn.L1Loss(reduce=False) # self.reg_loss = nn.SmoothL1Loss(reduce=False) # if self.use_focal_loss: # self.conf_loss = FocalLoss( # self.n_classes, alpha=0.2, gamma=2, auto_alpha=False) # else: # self.conf_loss = nn.CrossEntropyLoss(reduce=False) self.conf_loss = nn.L1Loss(reduce=False) self.angle_loss = MultiBinLoss(num_bins=self.num_bins) # fusion layer # self.upconv1 = nn.ConvTranspose2d(self.feat_size, self.feat_size, 2, 2, # 0) self.fusion1 = nn.Conv2d(2 * self.feat_size, self.feat_size, 3, 1, 1) self.fusion1_bn = nn.BatchNorm2d(self.feat_size) self.relu1 = nn.ReLU() self.upconv2 = nn.ConvTranspose2d(self.feat_size, self.feat_size, 2, 2, 0) self.upconv2_bn = nn.BatchNorm2d(self.feat_size) self.upconv2_relu = nn.ReLU() self.relu2 = nn.ReLU() self.fusion2 = nn.Conv2d(2 * self.feat_size, self.feat_size, 3, 1, 1) self.fusion2_bn = nn.BatchNorm2d(self.feat_size) self.upconv3 = nn.ConvTranspose2d(self.feat_size, self.feat_size, 2, 2, 0) self.upconv3_bn = nn.BatchNorm2d(self.feat_size) self.upconv3_relu = nn.ReLU() # self.fusion3 = nn.Conv2d(self.feat_size, self.feat_size, 3, 1, 1) # self.relu3 = nn.ReLU() self.rcnn_pooling = RoIAlignAvg(self.pooling_size, self.pooling_size, 1.0 / 8.0)
def __init__(self, classes, class_agnostic): super(_fasterRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) self.class_agnostic = class_agnostic # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 16.0) self.RCNN_roi_align_32 = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0 / 32.0) self.RCNN_roi_align_16 = RoIAlignAvg(14, 14, 1.0 / 16.0) self.RCNN_roi_align_8 = RoIAlignAvg(28, 28, 1.0 / 8.0) self.RCNN_roi_align_4 = RoIAlignAvg(56, 56, 1.0 / 4.0) self.RCNN_roi_align_2 = RoIAlignAvg(112, 112, 1.0 / 2.0) self.RCNN_roi_align_1 = RoIAlignAvg(224, 224, 1.0 / 1.0) self.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE self.RCNN_roi_crop = _RoICrop()