def __init__(self):
#3 input image channels and 12 possible actionTrue
super(FocusPolicy, self).__init__()
self.pool_size = 23
self.resnet = resnet(
pretrained=True,
num_classes=64) # num_classes torch.rand(10,3,256,256)
self.conv1 = nn.Conv2d(64 * 11, 64, 3)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(64, 32, 3)
self.bn1 = nn.BatchNorm2d(64)
#self.conv4c=nn.Conv2d(16,16,3)
#self.fc1=nn.Linear(16*9*13+16*self.pool_size*self.pool_size,120)
self.fc1 = nn.Linear(32 * (8) * (8), 128)
#self.fc2=nn.Linear(128,128)
self.roialign = ROIAlign((self.pool_size, self.pool_size), 0.25, 2)
self.action_head = nn.Linear(128, 12)
angle = -5 * math.pi / 180
self.theta1 = torch.tensor(
[[math.cos(angle), math.sin(-angle), 0],
[math.sin(angle), math.cos(angle), 0]],
dtype=torch.float)
angle = 5 * math.pi / 180
self.theta2 = torch.tensor(
[[math.cos(angle), math.sin(-angle), 0],
[math.sin(angle), math.cos(angle), 0]],
dtype=torch.float)
def __init__(self,
output_size,
scales,
sampling_ratio,
deformable=False,
output_channel=256):
"""
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(
ROIAlign(output_size,
spatial_scale=scale,
sampling_ratio=sampling_ratio)
if not deformable else DCNPooling(spatial_scale=scale,
pooled_size=output_size,
no_trans=False,
group_size=1,
trans_std=0.1,
output_dim=output_channel))
self.poolers = nn.ModuleList(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 = -torch.log2(torch.tensor(scales[0],
dtype=torch.float32)).item()
lvl_max = -torch.log2(torch.tensor(scales[-1],
dtype=torch.float32)).item()
self.map_levels = LevelMapper(lvl_min, lvl_max, canonical_scale=160)
def __init__(self, neighbor_expand, roi_expand, output_size, scales,
sampling_ratio):
"""
Arguments:
neighbor_expand (float): scale for enlarged proposals
roi_expand (bool): if the output size is expanded like the proposals
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(PoolerNeighbor, self).__init__()
self.neighbor_expand = neighbor_expand
## expand the output as well
if roi_expand:
output_size = tuple(
[int(x * neighbor_expand) for x in output_size])
poolers = []
for scale in scales:
poolers.append(
ROIAlign(output_size,
spatial_scale=scale,
sampling_ratio=sampling_ratio))
self.poolers = nn.ModuleList(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 = -torch.log2(torch.tensor(scales[0],
dtype=torch.float32)).item()
lvl_max = -torch.log2(torch.tensor(scales[-1],
dtype=torch.float32)).item()
self.map_levels = LevelMapper(lvl_min, lvl_max)
def __init__(self, output_size, scales, sampling_ratio):
"""
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(
ROIAlign(output_size,
spatial_scale=scale,
sampling_ratio=sampling_ratio))
self.poolers = nn.ModuleList(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 = -torch.log2(torch.tensor(scales[0],
dtype=torch.float32)).item()
lvl_max = -torch.log2(torch.tensor(scales[-1],
dtype=torch.float32)).item()
self.map_levels = LevelMapper(lvl_min, lvl_max)
self.onnx_export = False
def _make_roi_align(cfg, scale):
resolution = cfg.POOLER_RESOLUTION
sampling_ratio = cfg.POOLER_SAMPLING_RATIO
return ROIAlign((resolution, resolution),
spatial_scale=scale,
sampling_ratio=sampling_ratio)
def __init__(self, pooler_type, output_size, scales, sampling_ratio=None):
"""
Arguments:
pooler_type (str): Type of pooling, roi_align or prpool supported
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:
if pooler_type == 'roi_align':
poolers.append(
ROIAlign(output_size,
spatial_scale=scale,
sampling_ratio=sampling_ratio))
elif pooler_type == 'prpool':
poolers.append(PrPool(output_size, spatial_scale=scale))
else:
raise ValueError
self.poolers = nn.ModuleList(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 = -torch.log2(torch.tensor(scales[0],
dtype=torch.float32)).item()
lvl_max = -torch.log2(torch.tensor(scales[-1],
dtype=torch.float32)).item()
self.map_levels = LevelMapper(lvl_min, lvl_max)
def __init__(self, scales, output_size, sampling_ratio):
super(SuppAlignLayer, self).__init__()
poolers = []
for scale in scales:
poolers.append(
ROIAlign(output_size,
spatial_scale=scale,
sampling_ratio=sampling_ratio))
self.poolers = nn.ModuleList(poolers)
def __init__(self, output_size, scales, sampling_ratio):
"""
Arguments:
output_size (list[tuple[int]] or list[int]): output size for the pooled region
scales (list[flaot]): scales for each Pooler
sampling_ratio (int): sampling ratio for ROIAlign
"""
super(IndividualPooler, self).__init__()
poolers = []
for scale in scales:
poolers.append(
ROIAlign(output_size,
spatial_scale=scale,
sampling_ratio=sampling_ratio))
self.poolers = nn.ModuleList(poolers)
self.output_size = output_size
def __init__(self, output_sizes, scales, sampling_ratio):
"""
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(Encoder_Pooler, self).__init__()
assert len(output_sizes) == len(scales)
poolers = []
for output_size, scale in zip(output_sizes, scales):
poolers.append(
ROIAlign((output_size, output_size),
spatial_scale=scale,
sampling_ratio=sampling_ratio))
self.poolers = nn.ModuleList(poolers)
self.output_sizes = output_sizes
def __init__(self,
output_size,
scales,
sampling_ratio,
output_channel=256,
canonical_scale=160,
mode='align'):
"""
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:
if mode == 'align':
pooler = ROIAlign(output_size,
spatial_scale=scale,
sampling_ratio=sampling_ratio)
elif mode == 'deformable':
pooler = ModulatedDeformRoIPoolingPack(
spatial_scale=scale,
out_size=output_size[0],
out_channels=output_channel,
no_trans=False,
group_size=1,
trans_std=0.1)
elif mode == 'bezier':
pooler = BezierAlign(output_size,
spatial_scale=scale,
sampling_ratio=1)
else:
raise NotImplementedError()
poolers.append(pooler)
self.poolers = nn.ModuleList(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 = -torch.log2(torch.tensor(scales[0],
dtype=torch.float32)).item()
lvl_max = -torch.log2(torch.tensor(scales[-1],
dtype=torch.float32)).item()
self.map_levels = LevelMapper(lvl_min,
lvl_max,
canonical_scale=canonical_scale)
def __init__(self, output_size, scales, sampling_ratio, drop_last):
"""
Arguments:
output_size (list[tuple[int]] or list[int]): output size for the pooled region
scales (list[flaot]): scales for each Pooler
sampling_ratio (int): sampling ratio for ROIAlign
drop_last (bool): if passed, drop the last feature map
"""
super(Pooler, self).__init__()
poolers = []
for scale in scales:
poolers.append(
ROIAlign(output_size,
spatial_scale=scale,
sampling_ratio=sampling_ratio))
self.poolers = nn.ModuleList(poolers)
self.drop_last = drop_last
def build_roi_align(cfg, head_name):
"""
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
"""
resolution = cfg.MODEL[head_name].POOLER_RESOLUTION
scales = cfg.MODEL[head_name].POOLER_SCALES
sampling_ratio = cfg.MODEL[head_name].POOLER_SAMPLING_RATIO
output_size = (resolution, resolution)
use_torchvision = cfg.MODEL[head_name].USE_TORCH_VISION_POOLING
poolers = []
for scale in scales:
pooler = ROIAlign(output_size, spatial_scale=scale, sampling_ratio=sampling_ratio, use_torchvision=use_torchvision)
poolers.append(pooler)
return poolers
def __init__(self,
output_size,
scales,
sampling_ratio,
level_map='scale',
level_map_kwargs=None): # add by hui
"""
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
# add by hui
level_map: 'scale' mean origin FPN map;
'fixed' will use given 'level_min' and 'level_max' in level_map_kwargs, such as, 2, 5 mean use P2~P5
"""
super(Pooler, self).__init__()
poolers = []
for scale in scales:
poolers.append(
ROIAlign(output_size,
spatial_scale=scale,
sampling_ratio=sampling_ratio))
self.poolers = nn.ModuleList(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.
# ######################## changed by hui ################################################
if level_map == 'scale':
lvl_min = -torch.log2(torch.tensor(scales[0],
dtype=torch.float32)).item()
lvl_max = -torch.log2(torch.tensor(scales[-1],
dtype=torch.float32)).item()
self.map_levels = LevelMapper(lvl_min, lvl_max)
elif level_map == 'fixed':
lvl_min, lvl_max = level_map_kwargs.LEVEL_MIN, level_map_kwargs.LEVEL_MAX
self.map_levels = LevelMapper(lvl_min, lvl_max)
def __init__(self,
output_size,
scales,
sampling_ratio,
in_channels=512,
cat_all_levels=False):
"""
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(
ROIAlign(output_size,
spatial_scale=scale,
sampling_ratio=sampling_ratio))
self.poolers = nn.ModuleList(poolers)
self.output_size = output_size
self.cat_all_levels = cat_all_levels
# 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 = -torch.log2(torch.tensor(scales[0],
dtype=torch.float32)).item()
lvl_max = -torch.log2(torch.tensor(scales[-1],
dtype=torch.float32)).item()
self.map_levels = LevelMapper(lvl_min, lvl_max)
# reduce the channels
if self.cat_all_levels:
self.reduce_channel = make_conv3x3(in_channels * len(self.poolers),
in_channels,
dilation=1,
stride=1,
use_relu=True)
return x
import numpy as np
import cv2
from sklearn.externals import joblib
import torch.nn as nn
import torch.nn.functional as F
from maskrcnn_benchmark.layers import nms as _box_nms
from maskrcnn_benchmark.layers import ROIAlign
from MTCNN.tool.P_net import P_net
from MTCNN.tool.R_net import R_net
from MTCNN.tool.config import Config
from datetime import datetime
roialign_24 = ROIAlign((24, 24), 1 / 1., 2)
def loc2bbox(pre_loc, anchor):
c_hw = anchor[..., 2:4] - anchor[..., 0:2]
hw = pre_loc[..., 2:4] * c_hw
yx1 = anchor[..., :2] + pre_loc[..., :2] * c_hw
yx2 = yx1 + hw
bboxes = torch.cat((yx1, yx2), dim=-1)
return bboxes
def bbox2square(bboxes):
if bboxes.shape[0] > 0:
wh = bboxes[:, 2:4] - bboxes[:, :2]
wh, _ = wh.max(dim=-1)
x = x.cuda()
return x
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from maskrcnn_benchmark.layers import ROIAlign
from MTCNN.tool.R_net import R_net
from MTCNN.tool.read_Data_step2 import Read_Data
from MTCNN.tool.torch_ATC import AnchorTargetCreator
from MTCNN.tool.config import Config
from datetime import datetime
roialign = ROIAlign((24, 24), 1 / 1., 2)
ce_loss = nn.CrossEntropyLoss(reduction='none')
mse_loss = nn.MSELoss()
def bbox2square(bboxes):
if bboxes.shape[0] > 0:
wh = bboxes[..., 2:4] - bboxes[..., :2]
wh, _ = wh.max(dim=-1)
wh = wh[:, None]
xy = (bboxes[..., 2:4] + bboxes[..., :2]) / 2
xy1 = xy - wh / 2
xy1 = torch.max(xy1, cuda(torch.Tensor([0])))
xy2 = xy1 + wh
bboxes = torch.cat([xy1, xy2], dim=-1)
return bboxes
from pytorch_object_detection.tool.torch_ATC_FPN import AnchorTargetCreator
from pytorch_object_detection.tool.torch_PC_FPN import ProposalCreator
from pytorch_object_detection.tool.torch_PTC_mask import ProposalTargetCreator
from maskrcnn_benchmark.layers import ROIAlign
from pytorch_object_detection.tool.resnet import resnet101
from pytorch_object_detection.tool.FPN_net import FPN_net
from pytorch_object_detection.tool.FPN_RPN import RPN_net
from pytorch_object_detection.tool.FPN_Fast import Fast_net
from pytorch_object_detection.tool.Mask_net import Mask_net
import torch.nn.functional as F
from pytorch_object_detection.tool.read_Data_mask import Read_Data
from torch.utils.data import Dataset, DataLoader
ce_loss = nn.CrossEntropyLoss()
bce_loss = nn.BCEWithLogitsLoss()
roialign_list_7 = [ROIAlign((7, 7), 1 / 4., 2), ROIAlign((7, 7), 1 / 8., 2), ROIAlign((7, 7), 1 / 16., 2),
ROIAlign((7, 7), 1 / 32., 2)]
roialign_list_14 = [ROIAlign((14, 14), 1 / 4., 2), ROIAlign((14, 14), 1 / 8., 2), ROIAlign((14, 14), 1 / 16., 2),
ROIAlign((14, 14), 1 / 32., 2)]
roialign_28 = ROIAlign((28, 28), 1 / 1., 2)
def SmoothL1Loss(net_loc_train, loc, sigma, num):
t = torch.abs(net_loc_train - loc)
a = t[t < 1]
b = t[t >= 1]
loss1 = (a * sigma) ** 2 / 2
loss2 = b - 0.5 / sigma ** 2
loss = (loss1.sum() + loss2.sum()) / num
return loss
from cascade_rcnn.tool.config import Config
from cascade_rcnn.tool.get_anchors import get_anchors
from cascade_rcnn.tool.torch_ATC_test import AnchorTargetCreator
from cascade_rcnn.tool.torch_PC_test import ProposalCreator
from cascade_rcnn.tool.torch_PTC_test import ProposalTargetCreator
from maskrcnn_benchmark.layers import ROIAlign
from torchvision.models import vgg16
from cascade_rcnn.tool.RPN_net import RPN_net
from cascade_rcnn.tool.Fast_net import Fast_net
import torch.nn.functional as F
from cascade_rcnn.tool.read_Data import Read_Data
from torch.utils.data import DataLoader
ce_loss = nn.CrossEntropyLoss()
roialign = ROIAlign((7, 7), 1 / 16., 2)
def SmoothL1Loss(net_loc_train, loc, sigma, num):
t = torch.abs(net_loc_train - loc)
a = t[t < 1]
b = t[t >= 1]
loss1 = (a * sigma)**2 / 2
loss2 = b - 0.5 / sigma**2
loss = (loss1.sum() + loss2.sum()) / num
return loss
class Faster_Rcnn(nn.Module):
def __init__(self, config):
super(Faster_Rcnn, self).__init__()
x = x.cuda()
return x
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from maskrcnn_benchmark.layers import ROIAlign
from MTCNN.tool.P_net import P_net
from MTCNN.tool.read_Data_step1 import Read_Data
from MTCNN.tool.torch_ATC import AnchorTargetCreator
from MTCNN.tool.config import Config
from datetime import datetime
roialign = ROIAlign((12, 12), 1 / 1., 2)
ce_loss = nn.CrossEntropyLoss(reduction='none')
mse_loss = nn.MSELoss()
def get_xy(N):
t = np.arange(N)
x, y = np.meshgrid(t, t)
x = x[..., None]
y = y[..., None]
xy = np.concatenate((x, y), axis=-1)
return xy
def get_anchors(N):
super(Fast_net, self).__init__()
self.Linear1 = nn.Linear(2048, num_classes + 1)
self.Linear2 = nn.Linear(2048, (num_classes + 1) * 4)
nn.init.normal_(self.Linear1.weight, std=0.01)
nn.init.normal_(self.Linear2.weight, std=0.001)
pass
def forward(self, x):
fast_logits = self.Linear1(x)
fast_loc = self.Linear2(x)
fast_loc = fast_loc.view(fast_loc.shape[0], -1, 4)
return fast_logits, fast_loc
ce_loss = nn.CrossEntropyLoss()
roialign = ROIAlign((14, 14), 1 / 16., 2)
def SmoothL1Loss(net_loc_train, loc, sigma, num):
t = torch.abs(net_loc_train - loc)
a = t[t < 1]
b = t[t >= 1]
loss1 = (a * sigma)**2 / 2
loss2 = b - 0.5 / sigma**2
loss = (loss1.sum() + loss2.sum()) / num
return loss
def conv3x3(in_planes, out_planes, stride=1):
"""3x3 convolution with padding"""
return nn.Conv2d(in_planes,
x = x.cuda()
return x
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from maskrcnn_benchmark.layers import ROIAlign
from MTCNN.tool.O_net import O_net
from MTCNN.tool.read_Data_step2 import Read_Data
from MTCNN.tool.torch_ATC import AnchorTargetCreator
from MTCNN.tool.config import Config
from datetime import datetime
roialign = ROIAlign((48, 48), 1 / 1., 2)
ce_loss = nn.CrossEntropyLoss(reduction='none')
mse_loss = nn.MSELoss()
def bbox2square(bboxes):
if bboxes.shape[0] > 0:
wh = bboxes[..., 2:4] - bboxes[..., :2]
wh, _ = wh.max(dim=-1)
wh = wh[:, None]
xy = (bboxes[..., 2:4] + bboxes[..., :2]) / 2
xy1 = xy - wh / 2
xy1 = torch.max(xy1, cuda(torch.Tensor([0])))
xy2 = xy1 + wh
bboxes = torch.cat([xy1, xy2], dim=-1)
return bboxes
import numpy as np
import cv2
import codecs
from sklearn.externals import joblib
import torch.nn.functional as F
from maskrcnn_benchmark.layers import nms as _box_nms
from maskrcnn_benchmark.layers import ROIAlign
from MTCNN.tool.P_net import P_net
from MTCNN.tool.R_net import R_net
from MTCNN.tool.O_net import O_net
from MTCNN.tool.nms import nms, py_nms
from MTCNN.tool.config import Config
from datetime import datetime
roialign_24 = ROIAlign((24, 24), 1 / 1., 2)
roialign_48 = ROIAlign((48, 48), 1 / 1., 2)
def loc2bbox(pre_loc, anchor):
c_hw = anchor[..., 2:4] - anchor[..., 0:2]
hw = pre_loc[..., 2:4] * c_hw
yx1 = anchor[..., :2] + pre_loc[..., :2] * c_hw
yx2 = yx1 + hw
bboxes = torch.cat((yx1, yx2), dim=-1)
return bboxes
def landmarks2landmark2(bboxes, landmarks):
xy1 = bboxes[..., :2]
wh = bboxes[..., 2:4] - xy1
def get_P_net_res(self, x):
h, w = x.shape[2:]
roi = cuda(torch.tensor([[0, 0, 0, w, h]]).float())
i = 0
all_bboxes = []
all_score = []
while True:
n_h, n_w = int(h * self.scale ** i), int(w * self.scale ** i)
if n_h < 12 or n_w < 12:
break
roialign = ROIAlign((n_h, n_w), 1 / 1., 2)
xx = roialign(x, roi)
# xx = F.interpolate(x, size=(n_h, n_w))
a = np.ceil(n_h / 12.) * 12
b = np.ceil(n_w / 12.) * 12
a = int(a)
b = int(b)
xx = F.pad(xx, (0, b - n_w, 0, a - n_h), mode='constant', value=127.5)
xx = (xx - 127.5) / 128.0
P_net_logits, P_net_loc, P_net_landmarks = self.P_net(xx)
map_H, map_W = P_net_logits.shape[2:]
P_net_logits = P_net_logits.permute(0, 2, 3, 1).contiguous().view(-1, 2)
P_net_loc = P_net_loc.permute(0, 2, 3, 1).contiguous().view(-1, 4)
P_net_landmarks = P_net_landmarks.permute(0, 2, 3, 1).contiguous().view(-1, 10)
anchors = self.anchors[:map_H, :map_W].contiguous().view(-1, 4) / self.scale ** i
i += 1
score = F.softmax(P_net_logits, dim=-1)[..., 1]
inds = score >= self.config.P_net_conf_thresh
if inds.sum() == 0:
continue
score = score[inds]
P_net_loc = P_net_loc[inds]
anchors = anchors[inds]
bboxes = loc2bbox(P_net_loc, anchors)
bboxes[..., slice(0, 4, 2)] = torch.clamp(bboxes[..., slice(0, 4, 2)], 0, w - 1)
bboxes[..., slice(1, 4, 2)] = torch.clamp(bboxes[..., slice(1, 4, 2)], 0, h - 1)
hw = bboxes[..., 2:4] - bboxes[..., :2]
inds = hw >= self.config.roi_min_size[0]
inds = inds.all(dim=-1)
if inds.sum() == 0:
continue
bboxes = bboxes[inds]
score = score[inds]
score, inds = score.sort(descending=True)
bboxes = bboxes[inds]
keep = _box_nms(bboxes, score, 0.5)
score = score[keep]
bboxes = bboxes[keep]
all_bboxes.append(bboxes)
all_score.append(score)
if len(all_bboxes) == 0:
return cuda(torch.zeros((0, 5)))
bboxes = torch.cat(all_bboxes, dim=0)
score = torch.cat(all_score, dim=0)
score, inds = score.sort(descending=True)
bboxes = bboxes[inds]
keep = _box_nms(bboxes, score, self.config.P_net_iou_thresh)
bboxes = bboxes[keep]
score = score[keep]
return torch.cat([bboxes, score.view(-1, 1)], dim=1)
import torch.nn as nn
import torch.nn.functional as F
# torch.backends.cudnn.benchmark =True
from cascade_rcnn.tool.config import Config
from cascade_rcnn.tool.get_anchors import get_anchors
from cascade_rcnn.tool.torch_PC_FPN import ProposalCreator
from maskrcnn_benchmark.layers import ROIAlign
from cascade_rcnn.tool.resnet import resnet101
from cascade_rcnn.tool.FPN_net import FPN_net
from cascade_rcnn.tool.FPN_RPN import RPN_net
from cascade_rcnn.tool.FPN_Fast import Fast_net
from cascade_rcnn.tool.Mask_net import Mask_net
from cascade_rcnn.tool.cascade_predict import predict
roialign_list_7 = [
ROIAlign((7, 7), 1 / 4., 2),
ROIAlign((7, 7), 1 / 8., 2),
ROIAlign((7, 7), 1 / 16., 2),
ROIAlign((7, 7), 1 / 32., 2)
]
roialign_list_14 = [
ROIAlign((14, 14), 1 / 4., 2),
ROIAlign((14, 14), 1 / 8., 2),
ROIAlign((14, 14), 1 / 16., 2),
ROIAlign((14, 14), 1 / 32., 2)
]
roialign_28 = ROIAlign((28, 28), 1 / 1., 2)
def SmoothL1Loss(net_loc_train, loc, sigma, num):
# torch.backends.cudnn.benchmark =True
from cascade_rcnn.tool.config import Config
from cascade_rcnn.tool.get_anchors import get_anchors
from cascade_rcnn.tool.torch_PC_FPN import ProposalCreator
from maskrcnn_benchmark.layers import ROIAlign
from cascade_rcnn.tool.resnet import resnet101
from cascade_rcnn.tool.FPN_net import FPN_net
from cascade_rcnn.tool.FPN_RPN import RPN_net
from cascade_rcnn.tool.FPN_Fast import Fast_net
from cascade_rcnn.tool.faster_predict import predict
import torch.nn.functional as F
roialign_list = [ROIAlign((7, 7), 1 / 4., 2), ROIAlign((7, 7), 1 / 8., 2), ROIAlign((7, 7), 1 / 16., 2),
ROIAlign((7, 7), 1 / 32., 2)]
class Faster_Rcnn(nn.Module):
def __init__(self, config):
super(Faster_Rcnn, self).__init__()
self.config = config
self.Mean = torch.tensor(config.Mean, dtype=torch.float32)
self.num_anchor = len(config.anchor_scales) * len(config.anchor_ratios)
self.anchors = []
self.num_anchor = []
for i in range(5):
self.num_anchor.append(len(config.anchor_scales[i]) * len(config.anchor_ratios[i]))
stride = 4 * 2 ** i
print(stride, self.config.anchor_scales[i], self.config.anchor_ratios[i])
