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