def get_grad_img(gray_img):
filter_size = 5
gauss = make_gauss_filter(filter_size, 1.1)
# 1.朴素卷积
# smoothed_img = filter2D(gray_img, kernel=gauss)
# 2. im2col卷积
from utils import Conv2d_MULTITHREADS as Conv2d
from utils import Conv2d
filter2D = Conv2d(filter_size,
1,
1,
1,
weight=gauss[np.newaxis, :],
mode='valid')
smoothed_img = filter2D.filter(gray_img)
# 3. c++ im2col
# smoothed_img=example.conv2d(1,"valid",gauss,gray_img)
# 4. c++ im2col threads
# smoothed_img = example.conv2d_multi(1, "valid", gauss, gray_img)
# 5. conv pure
# smoothed_img = example.conv2d_pure(1, "valid", gauss, gray_img)
row_ind, col_ind = np.where(smoothed_img > 255)
smoothed_img[row_ind, col_ind] = 255
# 显示灰度图
# cv2.imshow('wind', np.uint8(smoothed_img))
# cv2.waitKey(0)
laplace = np.array([[0, -1, 0], [-1, 4, -1], [0, -1, 0]], dtype=np.float32)
# 1.
# grad_img = filter2D(smoothed_img, kernel=laplace)
# 2.
filter2D = Conv2d(3, 1, 1, 1, weight=laplace[np.newaxis, :], mode='valid')
grad_img = filter2D(smoothed_img[np.newaxis, :])[0]
# 3.
# grad_img=example.conv2d(1,"valid",laplace,smoothed_img)
# 4.
# grad_img = example.conv2d_multi(1, "valid", laplace, smoothed_img)
# 5.
# grad_img = example.conv2d_pure(1, "valid", laplace, smoothed_img)
# plt.imshow(grad_img)
# plt.show()
grad_img = np.where(grad_img > 7, grad_img, 0)
# plt.imshow(grad_img,cmap="gray")
# plt.show()
return grad_img
def __init__(self):
super(ManipulationNet, self).__init__()
# self.features = nn.Sequential(*make_layers(cfgs['C']))
self.features = models.vgg16_bn().features[:-10]
self.mask_decoder = MaskDecoder(512)
self.classifier = nn.Sequential(Conv2d(6, 1, kernel_size=3),
nn.Sigmoid())
def __init__(self,
device,
input_size=None,
num_classes=2,
trainable=False,
conf_thresh=0.05,
nms_thresh=0.20,
anchor_size=None,
hr=False):
super(YOLOv3tiny, self).__init__()
self.device = device
self.input_size = input_size
self.num_classes = num_classes
self.trainable = trainable
self.conf_thresh = conf_thresh
self.nms_thresh = nms_thresh
self.stride = [16, 32]
self.anchor_size = torch.tensor(anchor_size).view(
2,
len(anchor_size) // 2, 2)
self.anchor_number = self.anchor_size.size(1)
self.grid_cell, self.stride_tensor, self.all_anchors_wh = self.create_grid(
input_size)
self.scale = np.array(
[[[input_size[1], input_size[0], input_size[1], input_size[0]]]])
self.scale_torch = torch.tensor(self.scale.copy(),
device=device).float()
# backbone darknet-light
self.backbone = darknet_light(pretrained=trainable, hr=hr)
# s = 32
self.conv_set_2 = nn.Sequential(
SPP(), Conv2d(1024 * 4, 256, 1, leakyReLU=True))
self.conv_1x1_2 = Conv2d(256, 128, 1, leakyReLU=True)
self.extra_conv_2 = Conv2d(256, 512, 3, padding=1, leakyReLU=True)
self.pred_2 = nn.Conv2d(
512, self.anchor_number * (1 + 4 + self.num_classes), 1)
# s = 16
self.conv_set_1 = Conv2d(384, 256, 3, padding=1, leakyReLU=True)
self.pred_1 = nn.Conv2d(
256, self.anchor_number * (1 + 4 + self.num_classes), 1)
def __init__(self,
device,
input_size=None,
num_classes=20,
trainable=False,
conf_thresh=0.001,
nms_thresh=0.5,
anchor_size=None,
hr=False):
super(myYOLOv2, self).__init__()
self.device = device
self.input_size = input_size
self.num_classes = num_classes
self.trainable = trainable
self.conf_thresh = conf_thresh
self.nms_thresh = nms_thresh
self.anchor_size = torch.tensor(anchor_size)
self.anchor_number = len(anchor_size)
self.stride = 32
self.grid_cell, self.all_anchor_wh = self.create_grid()
self.scale = np.array(
[[input_size[1], input_size[0], input_size[1], input_size[0]]])
self.scale_torch = torch.tensor(self.scale.copy(),
device=device).float()
# backbone darknet-19
self.backbone = darknet19(pretrained=trainable, hr=hr)
# detection head
self.convsets_1 = nn.Sequential(
Conv2d(1024, 1024, 3, 1, leakyReLU=True),
Conv2d(1024, 1024, 3, 1, leakyReLU=True))
# self.route_alyer = nn.Sequential(
# Conv2d(512, 64, 1, leakyReLU=True),
# Conv2d(64, 256, 3, padding=1, stride=2, leakyReLU=True)
# )
self.route_layer = Conv2d(512, 64, 1, leakyReLU=True)
self.reorg = reorg_layer(stride=2)
self.convsets_2 = Conv2d(1280, 1024, 3, 1, leakyReLU=True)
# prediction layer
self.pred = nn.Conv2d(1024,
self.anchor_number * (1 + 4 + self.num_classes),
1)
def __init__(self,
device,
input_size=None,
trainable=False,
num_classes=None,
conf_thresh=0.3,
nms_thresh=0.45,
topk=100,
use_nms=False,
hr=False):
super(CenterNet, self).__init__()
self.device = device
self.input_size = input_size
self.trainable = trainable
self.num_classes = num_classes
self.conf_thresh = conf_thresh
self.nms_thresh = nms_thresh
self.use_nms = use_nms
self.stride = 4
self.topk = topk
self.grid_cell = self.create_grid(input_size)
self.scale = np.array(
[[[input_size, input_size, input_size, input_size]]])
self.scale_torch = torch.tensor(self.scale.copy(),
device=self.device).float()
self.backbone = resnet18(pretrained=trainable)
self.smooth5 = nn.Sequential(SPP(), Conv2d(512 * 4, 256, ksize=1),
Conv2d(256, 512, ksize=3, padding=1))
self.deconv5 = DeConv2d(512, 256, ksize=4, stride=2) # 32 -> 16
self.deconv4 = DeConv2d(256, 256, ksize=4, stride=2) # 16 -> 8
self.deconv3 = DeConv2d(256, 256, ksize=4, stride=2) # 8 -> 4
self.cls_pred = nn.Sequential(
Conv2d(256, 64, ksize=3, padding=1, leakyReLU=True),
nn.Conv2d(64, self.num_classes, kernel_size=1))
self.txty_pred = nn.Sequential(
Conv2d(256, 64, ksize=3, padding=1, leakyReLU=True),
nn.Conv2d(64, 2, kernel_size=1))
self.twth_pred = nn.Sequential(
Conv2d(256, 64, ksize=3, padding=1, leakyReLU=True),
nn.Conv2d(64, 2, kernel_size=1))
def __init__(self):
super(SimilarityNet, self).__init__()
# self.features = nn.Sequential(*make_layers(cfgs['C']))
self.features = models.vgg16_bn().features[:-10]
self.correlation_per_pooling = CorrelationPercPooling(nb_pools=256)
self.mask_decoder = MaskDecoder(256)
self.classifier = nn.Sequential(Conv2d(6, 1, kernel_size=3),
nn.Sigmoid())
def __init__(self, in_planes, out_planes, k=3, stride=1):
super().__init__()
self.conv = Conv2d(in_planes,
out_planes,
kernel_size=(k, k),
stride=stride,
padding=(k // 2, k // 2),
bias=False,
bn=True)
self.activate = nn.ReLU(inplace=True)
def __init__(self, image_size):
super(BusterNet, self).__init__()
self.image_size = image_size
self.manipulation_net = ManipulationNet()
self.similarity_net = SimilarityNet()
self.inception = nn.Sequential(Inception(12, 3, 3, 3, 3, 3),
Conv2d(9, 3, kernel_size=3),
nn.Softmax2d())
def __init__(self, num_convs):
super().__init__()
self.enc = nn.Sequential(*[
Conv2d(2**(4 + i) if i > 0 else 3,
2**(5 + i),
kernel_size=(3, 3),
padding=(1, 1),
stride=2,
activation=nn.LeakyReLU(negative_slope=0.2, inplace=True),
bias=False,
bn=True) for i in range(num_convs)
])
self.pred = Conv2d(2**(5 + num_convs - 1),
1,
kernel_size=(1, 1),
padding=(0, 0),
stride=1,
activation=None,
bias=False,
bn=True)
def __init__(self, num_convs):
super().__init__()
self.enc = nn.ModuleList([
Conv2d(2**(i + 4) if i > 0 else 11,
2**(i + 5),
kernel_size=(3, 3),
padding=(1, 1),
stride=2,
bias=False,
bn=True) for i in range(num_convs)
])
self.features = []
def make_layers(cfg, batch_norm=False):
layers = []
in_channels = 3
for v in cfg:
if v == 'M':
layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
else:
conv2d = Conv2d(in_channels, v, kernel_size=3, padding=1)
if batch_norm:
layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
else:
layers += [conv2d, nn.ReLU(inplace=True)]
in_channels = v
return layers
def __init__(self,
device,
input_size=None,
trainable=False,
conf_thresh=0.3,
nms_thresh=0.3,
topk=200,
hr=False):
super(CenterYOLAF, self).__init__()
self.device = device
self.input_size = input_size
self.trainable = trainable
self.conf_thresh = conf_thresh
self.nms_thresh = nms_thresh
self.stride = 4
self.topk = topk
self.grid_cell = self.create_grid(input_size)
self.scale = np.array(
[[[input_size, input_size, input_size, input_size]]])
self.scale_torch = torch.tensor(self.scale.copy(),
device=self.device).float()
# backbone
self.backbone = resnet18(pretrained=trainable)
# neck: deconv + FPN
self.deconv5 = DeConv2d(512, 256, ksize=2, stride=2) # 32 -> 16
self.deconv4 = DeConv2d(256, 128, ksize=2, stride=2) # 16 -> 8
self.deconv3 = DeConv2d(128, 64, ksize=2, stride=2) # 8 -> 4
self.smooth5 = Conv2d(512, 512, ksize=3, padding=1)
self.smooth4 = Conv2d(256, 256, ksize=3, padding=1)
self.smooth3 = Conv2d(128, 128, ksize=3, padding=1)
self.smooth2 = Conv2d(64, 64, ksize=3, padding=1)
# head: conf, txty, twth
self.conf_pred = nn.Sequential(
Conv2d(64, 32, ksize=3, padding=1, leakyReLU=True),
nn.Conv2d(32, 1, kernel_size=1))
self.txty_pred = nn.Sequential(
Conv2d(64, 32, ksize=3, padding=1, leakyReLU=True),
nn.Conv2d(32, 2, kernel_size=1))
self.twth_pred = nn.Sequential(
Conv2d(64, 32, ksize=3, padding=1, leakyReLU=True),
nn.Conv2d(32, 2, kernel_size=1))
def __init__(self, device, input_size=None, trainable=False, conf_thresh=0.01, nms_thresh=0.3, anchor_size=None, hr=False):
super(TinyYOLAF, self).__init__()
self.device = device
self.input_size = input_size
self.trainable = trainable
self.conf_thresh = conf_thresh
self.nms_thresh = nms_thresh
self.stride = [8, 16, 32]
self.anchor_size = torch.tensor(anchor_size).view(3, len(anchor_size) // 3, 2)
self.anchor_number = self.anchor_size.size(1)
self.grid_cell, self.stride_tensor, self.all_anchors_wh = self.create_grid(input_size)
self.scale = np.array([[[input_size, input_size, input_size, input_size]]])
self.scale_torch = torch.tensor(self.scale.copy(), device=device).float()
# backbone darknet-tiny
self.backbone = darknet_tiny(pretrained=trainable, hr=hr)
# s = 32
self.conv_set_3 = nn.Sequential(
SPP(),
Conv2d(512*4, 256, 1, leakyReLU=True),
Conv2d(256, 512, 3, padding=1, leakyReLU=True)
)
self.conv_1x1_3 = Conv2d(512, 128, 1, leakyReLU=True)
self.pred_3 = nn.Conv2d(512, self.anchor_number*(2 + 4), 1)
# s = 16
self.conv_set_2 = nn.Sequential(
Conv2d(384, 128, 1, leakyReLU=True),
Conv2d(128, 256, 3, padding=1, leakyReLU=True)
)
self.conv_1x1_2 = Conv2d(256, 64, 1, leakyReLU=True)
self.pred_2 = nn.Conv2d(256, self.anchor_number*(2 + 4), 1)
# s = 8
self.conv_set_1 = nn.Sequential(
Conv2d(192, 64, 1, leakyReLU=True),
Conv2d(64, 128, 3, padding=1, leakyReLU=True)
)
self.pred_1 = nn.Conv2d(128, self.anchor_number*(2 + 4), 1)
def __init__(self):
super(cifar_net, self).__init__()
self.conv_1 = nn.Sequential(
Conv2d(3, 32, 3, padding=1, leaky=True),
Conv2d(32, 64, 3, padding=1, stride=2, leaky=True)
)
self.conv_2 = nn.Sequential(
Conv2d(64, 64, 3, padding=1, leaky=True),
Conv2d(64, 128, 3, padding=1, stride=2, leaky=True)
)
self.conv_3 = nn.Sequential(
Conv2d(128, 128, 3, padding=1, leaky=True),
Conv2d(128, 256, 3, padding=1, stride=2, leaky=True)
)
self.conv_4 = nn.Sequential(
Conv2d(256, 256, 3, padding=1, leaky=True),
Conv2d(256, 512, 3, padding=1, stride=2, leaky=True)
)
self.conv_5 = nn.Sequential(
Conv2d(512, 512, 3, padding=1, leaky=True),
Conv2d(512, 1024, 3, padding=1, stride=2, leaky=True)
)
self.conv_6 = nn.Sequential(
Conv2d(1024, 512, 1, leaky=True),
Conv2d(512, 1024, 3, padding=1, leaky=True)
)
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Conv2d(1024, 10, kernel_size=1)
def __init__(self, device, input_size, num_classes=20, trainable=False, conf_thresh=0.05, nms_thresh=0.5, hr=False):
super(FCOS_LITE, self).__init__()
self.device = device
self.input_size = input_size
self.num_classes = num_classes
self.trainable = trainable
self.conf_thresh = conf_thresh
self.nms_thresh = nms_thresh
self.location_weight =torch.tensor([[-1, -1, 1, 1]]).float().to(device)
self.stride = [8, 16, 32, 64]
self.scale_thresholds = [0, 49, 98, 196, 1e10]
self.pixel_location = self.set_init()
self.scale = np.array([[input_size[1], input_size[0], input_size[1], input_size[0]]])
self.scale_torch = torch.tensor(self.scale.copy()).float()
# backbone resnet-18
self.backbone = resnet18(pretrained=trainable)
# C_5 -> C_6
self.conv_3x3_C_6 = Conv2d(512, 1024, 3, padding=1, stride=2)
# detection head
# All branches share the self.head
# 1 is for background label
# P_6
self.conv_set_6 = nn.Sequential(
Conv2d(1024, 512, 1),
Conv2d(512, 1024, 3, padding=1),
Conv2d(1024, 512, 1),
)
self.pred_6 = nn.Sequential(
Conv2d(512, 1024, 3, padding=1),
nn.Conv2d(1024, 1 + self.num_classes + 1 + 4, 1)
)
# P_5
self.conv_set_5 = nn.Sequential(
Conv2d(512, 256, 1),
Conv2d(256, 512, 3, padding=1),
Conv2d(512, 256, 1)
)
self.conv_1x1_5 = Conv2d(256, 128, 1)
self.pred_5 = nn.Sequential(
Conv2d(256, 512, 3, padding=1),
nn.Conv2d(512, 1 + self.num_classes + 1 + 4, 1)
)
# P_4
self.conv_set_4 = nn.Sequential(
Conv2d(384, 128, 1),
Conv2d(128, 256, 3, padding=1),
Conv2d(256, 128, 1)
)
self.conv_1x1_4 = Conv2d(128, 64, 1)
self.pred_4 = nn.Sequential(
Conv2d(128, 256, 3, padding=1),
nn.Conv2d(256, 1 + self.num_classes + 1 + 4, 1)
)
# P_3
self.conv_set_3 = nn.Sequential(
Conv2d(192, 64, 1),
Conv2d(64, 128, 3, padding=1),
Conv2d(128, 64, 1)
)
self.pred_3 = nn.Sequential(
Conv2d(64, 128, 3, padding=1),
nn.Conv2d(128, 1 + self.num_classes + 1 + 4, 1)
)
def __init__(self,
device,
input_size=None,
num_classes=20,
trainable=False,
conf_thresh=0.001,
nms_thresh=0.50,
anchor_size=None,
hr=False):
super(myYOLOv3, self).__init__()
self.device = device
self.input_size = input_size
self.num_classes = num_classes
self.trainable = trainable
self.conf_thresh = conf_thresh
self.nms_thresh = nms_thresh
self.stride = [8, 16, 32]
self.anchor_size = torch.tensor(anchor_size).view(
3,
len(anchor_size) // 3, 2)
self.anchor_number = self.anchor_size.size(1)
self.grid_cell, self.stride_tensor, self.all_anchors_wh = self.create_grid(
input_size)
self.scale = np.array(
[[[input_size[1], input_size[0], input_size[1], input_size[0]]]])
self.scale_torch = torch.tensor(self.scale.copy(),
device=device).float()
# backbone darknet-53 (optional: darknet-19)
self.backbone = darknet53(pretrained=trainable, hr=hr)
# s = 32
self.conv_set_3 = nn.Sequential(
Conv2d(1024, 512, 1, leakyReLU=True),
Conv2d(512, 1024, 3, padding=1, leakyReLU=True),
Conv2d(1024, 512, 1, leakyReLU=True),
Conv2d(512, 1024, 3, padding=1, leakyReLU=True),
Conv2d(1024, 512, 1, leakyReLU=True),
)
self.conv_1x1_3 = Conv2d(512, 256, 1, leakyReLU=True)
self.extra_conv_3 = Conv2d(512, 1024, 3, padding=1, leakyReLU=True)
self.pred_3 = nn.Conv2d(
1024, self.anchor_number * (1 + 4 + self.num_classes), 1)
# s = 16
self.conv_set_2 = nn.Sequential(
Conv2d(768, 256, 1, leakyReLU=True),
Conv2d(256, 512, 3, padding=1, leakyReLU=True),
Conv2d(512, 256, 1, leakyReLU=True),
Conv2d(256, 512, 3, padding=1, leakyReLU=True),
Conv2d(512, 256, 1, leakyReLU=True),
)
self.conv_1x1_2 = Conv2d(256, 128, 1, leakyReLU=True)
self.extra_conv_2 = Conv2d(256, 512, 3, padding=1, leakyReLU=True)
self.pred_2 = nn.Conv2d(
512, self.anchor_number * (1 + 4 + self.num_classes), 1)
# s = 8
self.conv_set_1 = nn.Sequential(
Conv2d(384, 128, 1, leakyReLU=True),
Conv2d(128, 256, 3, padding=1, leakyReLU=True),
Conv2d(256, 128, 1, leakyReLU=True),
Conv2d(128, 256, 3, padding=1, leakyReLU=True),
Conv2d(256, 128, 1, leakyReLU=True),
)
self.extra_conv_1 = Conv2d(128, 256, 3, padding=1, leakyReLU=True)
self.pred_1 = nn.Conv2d(
256, self.anchor_number * (1 + 4 + self.num_classes), 1)
def __init__(self, device, input_size, num_classes=20, trainable=False, conf_thresh=0.001, nms_thresh=0.5, hr=False):
super(FCOS_LITE, self).__init__()
self.device = device
self.input_size = input_size
self.num_classes = num_classes
self.trainable = trainable
self.conf_thresh = conf_thresh
self.nms_thresh = nms_thresh
self.location_weight =torch.tensor([[-1], [-1], [1], [1]]).float().to(device)
self.stride = [8, 16, 32]
self.scale_thresholds = [0, 64, 128, 1e10]
self.pixel_location = self.set_init()
self.scale = np.array([[input_size[1], input_size[0], input_size[1], input_size[0]]])
self.scale_torch = torch.tensor(self.scale.copy()).float()
# backbone resnet-18
self.backbone = darknet19(pretrained=trainable, hr=hr)
# C_i -> P_i
self.conv_1x1_C_5 = Conv2d(1024, 256, 1, leakyReLU=True)
self.conv_1x1_C_4 = Conv2d(512, 256, 1, leakyReLU=True)
self.conv_1x1_C_3 = Conv2d(256, 256, 1, leakyReLU=True)
self.conv_3x3_C_4 = Conv2d(256, 256, 3, padding=1, leakyReLU=True)
self.conv_3x3_C_3 = Conv2d(256, 256, 3, padding=1, leakyReLU=True)
# detection head
# All branches share the self.head
# 1 is for background label
self.pred_cls_ctn = nn.Sequential(
Conv2d(256, 128, 1, leakyReLU=True),
Conv2d(128, 256, 3, padding=1, leakyReLU=True),
Conv2d(256, 128, 1, leakyReLU=True),
Conv2d(128, 256, 3, padding=1, leakyReLU=True),
nn.Conv2d(256, 1 + self.num_classes + 1, 1)
)
self.pred_loc = nn.Sequential(
Conv2d(256, 128, 1, leakyReLU=True),
Conv2d(128, 256, 3, padding=1, leakyReLU=True),
Conv2d(256, 128, 1, leakyReLU=True),
Conv2d(128, 256, 3, padding=1, leakyReLU=True),
nn.Conv2d(256, 4, 1)
)
# adaptive scale for location
self.s_3 = nn.Conv2d(4, 4, 1)
self.s_4 = nn.Conv2d(4, 4, 1)
self.s_5 = nn.Conv2d(4, 4, 1)
def __init__(self, in_channels, out_channels, **kwargs):
super(BasicConv2D, self).__init__()
self.conv = Conv2d(in_channels, out_channels, bias=True, **kwargs)
self.bn = nn.BatchNorm2d(out_channels, eps=1e-3)
def forward(self):
ret = (torch.norm(self.x - self.y)**2) / 2 + self.lam * (
torch.norm(Conv2d(self.x, self.grad_x), p=self.norm) +
torch.norm(Conv2d(self.x, self.grad_y), p=self.norm))
return ret
