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
