def obj_feature_map(self, features, rois): """ Gets the ROI features :param features: [batch_size, dim, IM_SIZE/4, IM_SIZE/4] (features at level p2) :param rois: [num_rois, 5] array of [img_num, x0, y0, x1, y1]. :return: [num_rois, #dim] array """ feature_pool = RoIAlignFunction(self.pooling_size, self.pooling_size, spatial_scale=1 / 16)(features, rois) return self.roi_fmap_obj(feature_pool.view(rois.size(0), -1))
def obj_feature_map(self, features, rois): """ Gets the ROI features :param features: [batch_size, dim, IM_SIZE/4, IM_SIZE/4] (features at level p2) :param rois: [num_rois, 5] array of [img_num, x0, y0, x1, y1]. :return: [num_rois, #dim] array """ feature_pool = RoIAlignFunction( self.pooling_size, self.pooling_size, spatial_scale=1 / 16)( self.compress(features) if self.use_resnet else features, rois) # print("ObjectDetector.obj_feature_map feature_pool.shape", feature_pool.shape) return self.roi_fmap(feature_pool.view(rois.size(0), -1))
def union_boxes(fmap, rois, union_inds, pooling_size=14, stride=16): """ :param fmap: (batch_size, d, IM_SIZE/stride, IM_SIZE/stride) :param rois: (num_rois, 5) with [im_ind, x1, y1, x2, y2] :param union_inds: (num_urois, 2) with [roi_ind1, roi_ind2] :param pooling_size: we'll resize to this :param stride: :return: """ assert union_inds.size(1) == 2 im_inds = rois[:, 0][union_inds[:, 0]] assert (im_inds.data == rois.data[:, 0][union_inds[:, 1]] ).sum() == union_inds.size(0) union_rois = torch.cat(( im_inds[:, None], torch.min(rois[:, 1:3][union_inds[:, 0]], rois[:, 1:3][union_inds[:, 1]]), torch.max(rois[:, 3:5][union_inds[:, 0]], rois[:, 3:5][union_inds[:, 1]]), ), 1) # (num_rois, d, pooling_size, pooling_size) union_pools = RoIAlignFunction(pooling_size, pooling_size, spatial_scale=1 / stride)(fmap, union_rois) return union_pools
def get_node_edge_features(fmap, rois, union_rois=None, union_inds=None, pooling_size=14, stride=16): """ :param fmap: (batch_size, d, IM_SIZE/stride, IM_SIZE/stride) :param rois: (num_rois, 5) with [im_ind, x1, y1, x2, y2] :param union_inds: (num_urois, 2) with [roi_ind1, roi_ind2] :param pooling_size: we'll resize to this :param stride: :return: """ if union_rois is None: assert union_inds.size(1) == 2, union_inds.shape union_rois = torch.cat(( rois[:, 0][union_inds[:, 0]][:, None], torch.min(rois[:, 1:3][union_inds[:, 0]], rois[:, 1:3][union_inds[:, 1]]), torch.max(rois[:, 3:5][union_inds[:, 0]], rois[:, 3:5][union_inds[:, 1]]), ), 1) if TORCH12: node_features = roi_align(fmap, rois, output_size=(pooling_size, pooling_size), spatial_scale=1. / stride, sampling_ratio=-1) edge_features = roi_align(fmap, union_rois, output_size=(pooling_size, pooling_size), spatial_scale=1. / stride, sampling_ratio=-1) else: node_features = RoIAlignFunction(pooling_size, pooling_size, spatial_scale=1. / stride)(fmap, rois) edge_features = RoIAlignFunction(pooling_size, pooling_size, spatial_scale=1. / stride)(fmap, union_rois) return node_features, edge_features
def obj_feature_map(self, features, rois): """ Gets the ROI features Args: features: [batch_size, dim, IM_SIZE/4, IM_SIZE/4] (features at level p2) rois: [num_rois, 5] array of [img_num, x0, y0, x1, y1]. Returns: features: [num_rois, #dim] array """ roi_align_func = RoIAlignFunction(self.pooling_size, self.pooling_size, spatial_scale=1 / 16) feature_pool = roi_align_func(features, rois) return self.roi_fmap(feature_pool.view(rois.size(0), -1))
def obj_feature_map(self, features, rois): """ Gets the ROI features :param features: [batch_size, dim, IM_SIZE/4, IM_SIZE/4] (features at level p2) :param rois: [num_rois, 5] array of [img_num, x0, y0, x1, y1]. :return: [num_rois, #dim] array """ if not self.use_resnet: feature_pool = RoIAlignFunction( self.pooling_size, self.pooling_size, spatial_scale=1 / 16)( self.compress(features) if self.use_resnet else features, rois) return self.roi_fmap(feature_pool.view(rois.size(0), -1)) else: # feature_pool: [batch, 1024, 8, 8]; x: [batch, 1024, 7, 7]; fc7: [2048, 4, 4] --> [2048] feature_pool = RoIAlignFunction(self.pooling_size + 1, self.pooling_size + 1, spatial_scale=1 / 16)(features, rois) x = F.avg_pool2d(feature_pool, kernel_size=2, stride=1) fc7 = self.features.layer4(x) fc7 = fc7.mean(3).mean(2) return fc7
def new_union_boxes(fmap, rois, union_inds, pooling_size=14, stride=16): assert rois.shape[1] == 4 assert union_inds.shape[1] == 2 union_rois = torch.cat((torch.min(rois[:, :2][union_inds[:, 0]], rois[:, :2][union_inds[:, 1]]), torch.max(rois[:, 2:][union_inds[:, 0]], rois[:, 2:][union_inds[:, 1]])), 1) S_union_rois = torch.cat((Variable(union_inds[:, :1].float()), union_rois), dim=1) O_union_rois = torch.cat((Variable(union_inds[:, 1:].float()), union_rois), dim=1) union_S_pools = RoIAlignFunction(pooling_size, pooling_size, spatial_scale=1 / stride)(fmap, S_union_rois) union_O_pools = RoIAlignFunction(pooling_size, pooling_size, spatial_scale=1 / stride)(fmap, O_union_rois) return union_S_pools, union_O_pools
def __init__(self, output_size, scales): """ Arguments: output_size (list[tuple[int]] or list[int]): output size for the pooled region scales (list[float]): scales for each Pooler sampling_ratio (int): sampling ratio for ROIAlign """ super(Pooler, self).__init__() poolers = [] for scale in scales: poolers.append( RoIAlignFunction(output_size[0], output_size[1], spatial_scale=scale)) #self.poolers = nn.ModuleList(poolers) self.poolers = poolers self.output_size = output_size # get the levels in the feature map by leveraging the fact that the network always # downsamples by a factor of 2 at each level. lvl_min = -math.log2(scales[0]) # 2 lvl_max = -math.log2(scales[-1]) # 5 self.map_levels = LevelMapper(lvl_min, lvl_max)
def obj_feature_map(self, features, rois): feature_pool = RoIAlignFunction(self.pooling_size, self.pooling_size, spatial_scale=1 / 16)(features, rois) return self.roi_fmap_obj(feature_pool.view(rois.size(0), -1))
def obj_feature_map(self, features, rois): feature_pool = RoIAlignFunction(self.pooling_size, self.pooling_size, spatial_scale=1 / 16)( features, rois) return feature_pool