def __init__(self, classes0, classes1, class_agnostic, use_share_regress=False, use_progress=False):
super(_fasterRCNN, self).__init__()
self.classes0 = classes0
self.classes1 = classes1
self.n_classes0 = len(classes0)
self.n_classes1 = len(classes1)
self.class_agnostic = class_agnostic
# loss
self.RCNN_loss_cls = 0
self.RCNN_loss_bbox = 0
# define rpn
self.RCNN_rpn0 = _RPN(self.dout_base_model)
self.RCNN_rpn1 = _RPN(self.dout_base_model)
self.RCNN_proposal_target0 = _ProposalTargetLayer(self.n_classes0)
self.RCNN_proposal_target1 = _ProposalTargetLayer(self.n_classes1)
self.use_share_regress = use_share_regress
self.use_progress = use_progress
self.RCNN_roi_align = RoIAlign((cfg.POOLING_SIZE, cfg.POOLING_SIZE), spatial_scale=1.0/16.0, sampling_ratio=0)
if self.use_share_regress:
self.RCNN_share_regress = nn.Linear(2048, 1)
if self.use_progress:
self.fc_progress = nn.Linear(1024, 3)
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,
classes,
class_agnostic,
compact_mode=False):
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
# self.focalloss_handle = FocalLossV4(num_class=21, alpha=0.25, gamma=2.0, balance_index=2)
# define Large Separable Convolution Layer
self.rpn = RPN(in_channels=245, f_channels=256)
self.sam = SAM(256,245)
# define rpn
self.RCNN_rpn = _RPN(self.dout_base_model)
self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes)
self.rpn_time = None
self.pre_roi_time = None
self.roi_pooling_time = None
self.subnet_time = None
self.psroiAlign = PSROIAlignhandle(1./16, 7,2, 5)
self.psroiPool = PSROIPoolhandle(7,7,1./16,7,5)
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, n_way=2, n_shot=5):
super(_fgnRCNN, self).__init__()
self.classes = classes
self.n_classes = len(classes)
# loss
self.RCNN_loss_cls = 0
self.RCNN_loss_bbox = 0
# define rpn
self.RCNN_rpn = _RPN(self.dout_base_model)
# for proposal-target matching
self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes)
# pooling or align
self.RCNN_roi_pool = ROIPool((cfg.POOLING_SIZE, cfg.POOLING_SIZE),
1.0 / 16.0)
self.RCNN_roi_align = ROIAlign((cfg.POOLING_SIZE, cfg.POOLING_SIZE),
1.0 / 16.0, 0)
# few shot rcnn head
self.avgpool_rpn = nn.AvgPool2d(20)
self.avgpool_rcnn = nn.AvgPool2d(14, stride=1)
self.cls_conv1 = nn.Conv2d(2048, 512, 3, padding=0, bias=False)
self.bn1 = nn.BatchNorm2d(512)
self.cls_conv2 = nn.Conv2d(512, 128, 3, padding=0, bias=False)
self.bn2 = nn.BatchNorm2d(128)
# few shot settings
self.n_way = n_way
self.n_shot = n_shot
def __init__(self, classes, class_agnostic, in_channel=4096):
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_pool = ROIPool((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0 / 16.0)
self.RCNN_roi_align = ROIAlign(
(cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0 / 16.0, 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 = _ImageDA(self.dout_base_model)
self.RCNN_instanceDA = _InstanceDA(in_channel)
self.consistency_loss = torch.nn.MSELoss(size_average=False)
self.conv_lst = nn.Conv2d(self.dout_base_model, self.n_classes - 1, 1, 1, 0)
self.avg_pool = nn.AdaptiveAvgPool2d(output_size=(1, 1))
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):
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()
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__(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, 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(_RFCN, self).__init__()
self.classes = classes
self.n_classes = len(classes)
self.class_agnostic = class_agnostic
# loss
self.RFCN_loss_cls = 0
self.RFCN_loss_bbox = 0
self.box_num_classes = (1 if class_agnostic else len(classes))
#print(self.box_num_classes)
#input()
# define rpn
self.RFCN_rpn = _RPN(self.dout_base_model)
self.RFCN_proposal_target = _ProposalTargetLayer(self.n_classes)
self.RFCN_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.RFCN_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.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
self.RFCN_cls_net = nn.Conv2d(512,self.n_classes*7*7, [1,1], padding=0, stride=1)
nn.init.normal(self.RFCN_cls_net.weight.data, 0.0, 0.01)
self.RFCN_bbox_net = nn.Conv2d(512, 4*self.box_num_classes*7*7, [1,1], padding=0, stride=1)
nn.init.normal(self.RFCN_bbox_net.weight.data, 0.0, 0.01)
self.RFCN_cls_score = nn.AvgPool2d((7,7), stride=(7,7))
#print(self.RFCN_cls_score)
#input()
self.RFCN_bbox_pred = nn.AvgPool2d((7,7), stride=(7,7))
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__(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,
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(_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_pool = ROIPool((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0/16.0)
self.RCNN_roi_align = ROIAlign((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0/16.0, 0)
self.DCR_proposal = _DCRProposalLayer(self.class_agnostic)
self.DCR_target_proposal = _DCRTargetLayer(self.n_classes, self.class_agnostic)
# self.DCR_roi_pool = ROIPool((112, 112), 1.0/4.0)
self.DCR_roi_pool = ROIAlign((56, 56), 1.0/4.0, 0)
# self.DCR_roi_pool = ROIPool((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0/16.0)
# self.DCR_roi_pool = ROIPool((28, 28), 1.0/8.0)
if cfg.TRAIN.ATTENTION_MODEL:
self.levelattentionLoss = Attention_loss()
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,
pooling_size=7,
pooling_mode="align",
thresh=0.05,
relation_module=False):
super(_fasterRCNN, self).__init__()
self.classes = classes
self.n_classes = len(classes)
self.class_agnostic = class_agnostic
self.thresh = thresh
# loss
self.RCNN_loss_cls = 0
self.RCNN_loss_bbox = 0
# define rpn
self.RCNN_rpn = _RPN(self.dout_base_model)
self.bbox_normalize_targets_precomputed = True,
self.bbox_normalize_means = [0.0, 0.0, 0.0, 0.0]
self.bbox_normalize_stds = [0.1, 0.1, 0.2, 0.2]
self.RCNN_proposal_target = _ProposalTargetLayer(
self.n_classes,
bbox_normalize_targets_precomputed=self.
bbox_normalize_targets_precomputed,
bbox_normalize_means=self.bbox_normalize_means,
bbox_normalize_stds=self.bbox_normalize_stds)
self.pooling_mode = pooling_mode
self.RCNN_roi_pool = RoIPool((pooling_size, pooling_size), 1.0 / 16.0)
self.RCNN_roi_align = RoIAlign((pooling_size, pooling_size),
1.0 / 16.0, 0)
self.relation_module = relation_module # whether add relation network
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.rpn_time = None
self.pre_roi_time = None
self.roi_pooling_time = None
self.subnet_time = None
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__(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, 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)
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(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, classes: Tuple[str], class_agnostic: bool):
super(OneShotBase, self).__init__()
self.classes = classes
self.n_classes = len(classes)
self.class_agnostic = class_agnostic
self.match_net = match_block(self.dout_base_model)
# 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_pool = ROIPool((cfg.POOLING_SIZE, cfg.POOLING_SIZE),
1.0 / 16.0)
self.RCNN_roi_align = ROIAlign((cfg.POOLING_SIZE, cfg.POOLING_SIZE),
1.0 / 16.0, 0)
self.triplet_loss = torch.nn.MarginRankingLoss(margin=cfg.TRAIN.MARGIN)
self.RCNN_base = nn.Module() # implement in inherit class
self.RCNN_top = nn.Module() # implement in inherit class
self.RCNN_cls_score = nn.Module() # implement in inherit class
self.RCNN_bbox_pred = nn.Module() # implement in inherit clas
def __init__(self, classes, attention_type, rpn_reduce_dim, rcnn_reduce_dim, n_way=2, n_shot=5, pos_encoding=True):
super(_MAML_CISA, self).__init__()
self.classes = classes
self.n_classes = len(classes)
self.n_way = n_way
self.n_shot = n_shot
self.attention_type = attention_type
self.unary_gamma = 0.1
self.rpn_reduce_dim = rpn_reduce_dim
self.rcnn_reduce_dim = rcnn_reduce_dim
# loss
self.RCNN_loss_cls = 0
self.RCNN_loss_bbox = 0
# pooling or align
self.RCNN_roi_pool = ROIPool((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0/16.0)
self.RCNN_roi_align = ROIAlign((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0/16.0, 0)
# few shot rcnn head
self.pool_feat_dim = 1024
self.rcnn_dim = 64
self.avgpool = nn.AvgPool2d(14, stride=1)
dim_in = self.pool_feat_dim
################
self.rpn_unary_layer = nn.Linear(dim_in, 1)
init.normal_(self.rpn_unary_layer.weight, std=0.01)
init.constant_(self.rpn_unary_layer.bias, 0)
self.rcnn_unary_layer = nn.Linear(dim_in, 1)
init.normal_(self.rcnn_unary_layer.weight, std=0.01)
init.constant_(self.rcnn_unary_layer.bias, 0)
self.rpn_adapt_q_layer = nn.Linear(dim_in, rpn_reduce_dim)
init.normal_(self.rpn_adapt_q_layer.weight, std=0.01)
init.constant_(self.rpn_adapt_q_layer.bias, 0)
self.rpn_adapt_k_layer = nn.Linear(dim_in, rpn_reduce_dim)
init.normal_(self.rpn_adapt_k_layer.weight, std=0.01)
init.constant_(self.rpn_adapt_k_layer.bias, 0)
self.rcnn_adapt_q_layer = nn.Linear(dim_in, rcnn_reduce_dim)
init.normal_(self.rcnn_adapt_q_layer.weight, std=0.01)
init.constant_(self.rcnn_adapt_q_layer.bias, 0)
self.rcnn_adapt_k_layer = nn.Linear(dim_in, rcnn_reduce_dim)
init.normal_(self.rcnn_adapt_k_layer.weight, std=0.01)
init.constant_(self.rcnn_adapt_k_layer.bias, 0)
self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes)
if self.attention_type == 'concat':
self.RCNN_rpn = _RPN(2048)
self.rcnn_transform_layer = nn.Linear(2048, self.rcnn_dim)
elif self.attention_type == 'product':
self.RCNN_rpn = _RPN(1024)
self.rcnn_transform_layer = nn.Linear(1024, self.rcnn_dim)
self.output_score_layer = FFN(64* 49, dim_in)
# positional encoding
self.pos_encoding = pos_encoding
if pos_encoding:
self.pos_encoding_layer = PositionalEncoding()
self.rpn_pos_encoding_layer = PositionalEncoding(max_len=400)
def __init__(self, classes, n_head, d_feat=64, n_way=2, n_shot=5, pos_encoding=True):
super(_multiRCNN, self).__init__()
self.classes = classes
self.n_classes = len(classes)
# loss
self.RCNN_loss_cls = 0
self.RCNN_loss_bbox = 0
# for proposal-target matching
self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes)
# pooling or align
self.RCNN_roi_pool = ROIPool((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0/16.0)
self.RCNN_roi_align = ROIAlign((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0/16.0, 0)
# few shot rcnn head
self.global_relation = True
self.local_correlation = True
self.pool_feat_dim = 1024
self.soft_gamma = 10
self.avgpool = nn.AvgPool2d(14, stride=1)
# self.maxpool_fc = nn.MaxPool1d(49)
dim_in = self.pool_feat_dim
################
self.h = n_head
if self.h == 4:
d_rpn_in = 1024
d_rpn_hidden = 512
d_rcnn_hidden = 64
d_ffn_hidden = 1024
elif self.h == 2:
d_rpn_in = 512
d_rpn_hidden = 256
d_rcnn_hidden = 64
d_ffn_hidden = 1024
elif self.h == 1:
d_rpn_in = 256
d_rpn_hidden = 128
d_rcnn_hidden = 32
d_ffn_hidden = 512
else:
raise Exception(f'{self.h}')
self.d_feat = d_feat
self.multihead_attention_layer = MultiheadAttentionModule(dim_in, d_feat=self.d_feat, h=self.h)
self.rpn_attention_linear = nn.Linear(400 * self.h, d_rpn_in)
self.RCNN_rpn = _MultiheadRPN(d_rpn_in, d_rpn_hidden)
self.rcnn_attention_linear = nn.Linear(49 * self.h, d_rcnn_hidden)
self.rcnn_ffn_layer = FFN(49 * d_rcnn_hidden, d_ffn_hidden)
################
self.pos_encoding = pos_encoding
if pos_encoding:
self.pos_encoding_layer = PositionalEncoding()
self.rpn_pos_encoding_layer = PositionalEncoding(max_len=400)
################
# few shot settings
self.n_way = n_way
self.n_shot = n_shot
def __init__(self, main_classes, sub_classes, class_agnostic, casecade_type='add_score', alpha=0.5):
super(_hierarchyAttentionFasterRCNN, self).__init__()
#self.classes = classes
# type: add_score, add_prob, mul_score, mul_prob
self.casecade_type = casecade_type
self.alpha = alpha
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()
self.main2sub_idx_dict = defaultdict(list)
for key, val in sub2main_dict.items():
try:
# not all cls in dict are in this imdb
self.main2sub_idx_dict[self.main_classes.index(
val)].append(self.sub_classes.index(key))
except:
print("key:{}, val:{} may not in this imdb".format(key, val))
# attention
self.fc1 = nn.Linear(2048, 1024)
self.fc2 = nn.Linear(1024, 1024)
self.nongt_dim = 300 if self.training else cfg.TEST.RPN_POST_NMS_TOP_N
self.attention_1 = attention_module_multi_head(nongt_dim=self.nongt_dim,
fc_dim=16, feat_dim=1024, index=1, group=16,
dim=(1024, 1024, 1024))
self.attention_2 = attention_module_multi_head(nongt_dim=self.nongt_dim,
fc_dim=16, feat_dim=1024, index=2, group=16,
dim=(1024, 1024, 1024))
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)
def __init__(self, classes):
super(faster, self).__init__()
self.n_classes = classes + 1
# 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 = ROIPool(7, 7, 1.0 / 16.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.grid_size = cfg.POOLING_SIZE * 2 if cfg.CROP_RESIZE_WITH_MAX_POOL else cfg.POOLING_SIZE
self.RCNN_roi_crop = _RoICrop()
