精华内容
下载资源
问答
  • 特征融合代码理解

    2020-11-23 18:32:47
    特征融合代码理解特种融合代码理解新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...

    特征融合代码理解

    特种融合代码理解

    集成学习的方法在这类比赛中经常使用,要想获得好成绩集成学习必须做得好。在这里简单谈谈思路,我们使用了两个模型,我们模型也会采取不同参数去训练和预测,那么我们就会得到很多预测MASK图,此时 我们可以采取模型融合的思路,对每张结果图的每个像素点采取投票表决的思路,对每张图相应位置的像素点的类别进行预测,票数最多的类别即为该像素点的类别。正所谓“三个臭皮匠,胜过诸葛亮”,我们这种ensemble的思路,可以很好地去掉一些明显分类错误的像素点,很大程度上改善模型的预测能力。

    少数服从多数的投票表决策略代码

    // An highlighted block
    import numpy as np
    import cv2
    import argparse
     
    RESULT_PREFIXX = ['./result1/','./result2/','./result3/']
    # each mask has 5 classes: 0~4
     
    def vote_per_image(image_id):
        result_list = []
        for j in range(len(RESULT_PREFIXX)):
            im = cv2.imread(RESULT_PREFIXX[j]+str(image_id)+'.png',0)
            result_list.append(im)
            
        # each pixel
        height,width = result_list[0].shape
        vote_mask = np.zeros((height,width))
        for h in range(height):
            for w in range(width):
                record = np.zeros((1,5))
                for n in range(len(result_list)):
                    mask = result_list[n]
                    pixel = mask[h,w]
                    #print('pix:',pixel)
                    record[0,pixel]+=1
               
                label = record.argmax()
                #print(label)
                vote_mask[h,w] = label
        
        cv2.imwrite('vote_mask'+str(image_id)+'.png',vote_mask)
            
     
    vote_per_image(3)
    
    展开全文
  • 用于语义边缘检测(DFF)的动态特征融合 胡媛,陈云鹏,李翔和冯家石 影片示范 我们已经在和上发布了DFF的演示视频。 介绍 该存储库包含使用Pytorch 1.0进行DFF的整个管道(包括数据预处理,培训,测试,可视化,...
  • mcca特征融合matlab代码

    2019-01-26 14:41:05
    多类典型性相关分析MCCA的matlab代码,可以直接使用。
  • PANET代码 特征融合

    2020-06-10 21:00:25
    #多尺度特征融合 #不同ROI特征融合 ############################### x = KL.Add(name=“mrcnn_mask_add_2_3”)([x2, x3]) x = KL.Add(name=“mrcnn_mask_add_2_4”)([x, x4]) x = KL.Add(name=“mrcnn_mask_add_2_5...

    在这里插入图片描述 ################################
    #多尺度特征融合
    #不同ROI特征融合
    ###############################
    x = KL.Add(name=“mrcnn_mask_add_2_3”)([x2, x3])
    x = KL.Add(name=“mrcnn_mask_add_2_4”)([x, x4])
    x = KL.Add(name=“mrcnn_mask_add_2_5”)([x, x5])

    def fpn_classifier_graph(rois, feature_maps, image_meta,
                             pool_size, num_classes, train_bn=True,
                             fc_layers_size=1024):
        """Builds the computation graph of the feature pyramid network classifier
        and regressor heads.
        rois: [batch, num_rois, (y1, x1, y2, x2)] Proposal boxes in normalized
              coordinates.
        feature_maps: List of feature maps from different layers of the pyramid,
                      [P2, P3, P4, P5]. Each has a different resolution.
        image_meta: [batch, (meta data)] Image details. See compose_image_meta()
        pool_size: The width of the square feature map generated from ROI Pooling.
        num_classes: number of classes, which determines the depth of the results
        train_bn: Boolean. Train or freeze Batch Norm layers
        fc_layers_size: Size of the 2 FC layers
        Returns:
            logits: [batch, num_rois, NUM_CLASSES] classifier logits (before softmax)
            probs: [batch, num_rois, NUM_CLASSES] classifier probabilities
            bbox_deltas: [batch, num_rois, NUM_CLASSES, (dy, dx, log(dh), log(dw))] Deltas to apply to
                         proposal boxes
        """
        # ROI Pooling
        # Shape: [batch, num_rois, POOL_SIZE, POOL_SIZE, channels]
        x2 = PyramidROIAlign_AFN([pool_size, pool_size],2,
                            name="roi_align_classifier_2")([rois, image_meta] + feature_maps)
    
        # Two 1024 FC layers (implemented with Conv2D for consistency)
        x2 = KL.TimeDistributed(KL.Conv2D(fc_layers_size, (pool_size, pool_size), padding="valid"),
                               name="mrcnn_class_conv1_2")(x2)
        x2 = KL.TimeDistributed(BatchNorm(), name='mrcnn_class_bn1_2')(x2, training=train_bn)
        x2 = KL.Activation('relu')(x2)
        #3
        x3 = PyramidROIAlign_AFN([pool_size, pool_size], 3,
                              name="roi_align_classifier_3")([rois, image_meta] + feature_maps)
    
        # Two 1024 FC layers (implemented with Conv2D for consistency)
        x3 = KL.TimeDistributed(KL.Conv2D(fc_layers_size, (pool_size, pool_size), padding="valid"),
                                name="mrcnn_class_conv1_3")(x3)
        x3 = KL.TimeDistributed(BatchNorm(), name='mrcnn_class_bn1_3')(x3, training=train_bn)
        x3 = KL.Activation('relu')(x3)
        #4
        x4 = PyramidROIAlign_AFN([pool_size, pool_size], 4,
                             name="roi_align_classifier_4")([rois, image_meta] + feature_maps)
    
        # Two 1024 FC layers (implemented with Conv2D for consistency)
        x4 = KL.TimeDistributed(KL.Conv2D(fc_layers_size, (pool_size, pool_size), padding="valid"),
                                name="mrcnn_class_conv1_4")(x4)
        x4 = KL.TimeDistributed(BatchNorm(), name='mrcnn_class_bn1_4')(x4, training=train_bn)
        x4 = KL.Activation('relu')(x4)
        #5
        x5 = PyramidROIAlign_AFN([pool_size, pool_size], 5,
                              name="roi_align_classifier_5")([rois, image_meta] + feature_maps)
    
        # Two 1024 FC layers (implemented with Conv2D for consistency)
        x5 = KL.TimeDistributed(KL.Conv2D(fc_layers_size, (pool_size, pool_size), padding="valid"),
                                name="mrcnn_class_conv1_5")(x5)
        x5 = KL.TimeDistributed(BatchNorm(), name='mrcnn_class_bn1_5')(x5, training=train_bn)
        x5 = KL.Activation('relu')(x5)
        ################################
        #多尺度特征融合
        #不同ROI特征融合
        ###############################
        x = KL.Add(name="mrcnn_mask_add_2_3")([x2, x3])
        x = KL.Add(name="mrcnn_mask_add_2_4")([x, x4])
        x = KL.Add(name="mrcnn_mask_add_2_5")([x, x5])
    
        x = KL.TimeDistributed(KL.Conv2D(fc_layers_size, (1, 1)),
                               name="mrcnn_class_conv2")(x)
        x = KL.TimeDistributed(BatchNorm(), name='mrcnn_class_bn2')(x, training=train_bn)
        x = KL.Activation('relu')(x)
    
        shared = KL.Lambda(lambda x: K.squeeze(K.squeeze(x, 3), 2),
                           name="pool_squeeze")(x)
    
        # Classifier head
        mrcnn_class_logits = KL.TimeDistributed(KL.Dense(num_classes),
                                                name='mrcnn_class_logits')(shared)
        mrcnn_probs = KL.TimeDistributed(KL.Activation("softmax"),
                                         name="mrcnn_class")(mrcnn_class_logits)
    
        # BBox head
        # [batch, num_rois, NUM_CLASSES * (dy, dx, log(dh), log(dw))]
        x = KL.TimeDistributed(KL.Dense(num_classes * 4, activation='linear'),
                               name='mrcnn_bbox_fc')(shared)
        # Reshape to [batch, num_rois, NUM_CLASSES, (dy, dx, log(dh), log(dw))]
        s = K.int_shape(x)
        mrcnn_bbox = KL.Reshape((s[1], num_classes, 4), name="mrcnn_bbox")(x)
    
        return mrcnn_class_logits, mrcnn_probs, mrcnn_bbox
    
      for i, level in enumerate(range(2, 6)):
                ix = tf.where(tf.equal(roi_level, level))
                level_boxes = tf.gather_nd(boxes, ix)
    
                # Box indices for crop_and_resize.
                box_indices = tf.cast(ix[:, 0], tf.int32)
    
                # Keep track of which box is mapped to which level
                box_to_level.append(ix)
    
                # Stop gradient propogation to ROI proposals
                level_boxes = tf.stop_gradient(level_boxes)
                box_indices = tf.stop_gradient(box_indices)
    
                # Crop and Resize
                # From Mask R-CNN paper: "We sample four regular locations, so
                # that we can evaluate either max or average pooling. In fact,
                # interpolating only a single value at each bin center (without
                # pooling) is nearly as effective."
                #
                # Here we use the simplified approach of a single value per bin,
                # which is how it's done in tf.crop_and_resize()
                # Result: [batch * num_boxes, pool_height, pool_width, channels]
                pooled.append(tf.image.crop_and_resize(
                    feature_maps[i], level_boxes, box_indices, self.pool_shape,
                    method="bilinear"))
    
            # Pack pooled features into one tensor
            pooled = tf.concat(pooled, axis=0)
    
    

    在这里插入图片描述

    def build_fpn_mask_graph(rois, feature_maps, image_meta,
                             pool_size, num_classes, train_bn=True):
        """Builds the computation graph of the mask head of Feature Pyramid Network.
        rois: [batch, num_rois, (y1, x1, y2, x2)] Proposal boxes in normalized
              coordinates.
        feature_maps: List of feature maps from different layers of the pyramid,
                      [P2, P3, P4, P5]. Each has a different resolution.
        image_meta: [batch, (meta data)] Image details. See compose_image_meta()
        pool_size: The width of the square feature map generated from ROI Pooling.
        num_classes: number of classes, which determines the depth of the results
        train_bn: Boolean. Train or freeze Batch Norm layers
        Returns: Masks [batch, num_rois, MASK_POOL_SIZE, MASK_POOL_SIZE, NUM_CLASSES]
        """
        # ROI Pooling
        # Shape: [batch, num_rois, MASK_POOL_SIZE, MASK_POOL_SIZE, channels]
        x = PyramidROIAlign([pool_size, pool_size],
                            name="roi_align_mask")([rois, image_meta] + feature_maps)
    
        # Conv layers
        x = KL.TimeDistributed(KL.Conv2D(256, (3, 3), padding="same"),
                               name="mrcnn_mask_conv1")(x)
        x = KL.TimeDistributed(BatchNorm(),
                               name='mrcnn_mask_bn1')(x, training=train_bn)
        x = KL.Activation('relu')(x)
    
        x = KL.TimeDistributed(KL.Conv2D(256, (3, 3), padding="same"),
                               name="mrcnn_mask_conv2")(x)
        x = KL.TimeDistributed(BatchNorm(),
                               name='mrcnn_mask_bn2')(x, training=train_bn)
        x = KL.Activation('relu')(x)
    
        x = KL.TimeDistributed(KL.Conv2D(256, (3, 3), padding="same"),
                               name="mrcnn_mask_conv3")(x)
        x = KL.TimeDistributed(BatchNorm(),
                               name='mrcnn_mask_bn3')(x, training=train_bn)
        x = KL.Activation('relu')(x)
    
        x1 = KL.TimeDistributed(KL.Conv2D(256, (3, 3), padding="same"),
                               name="mrcnn_mask_conv4_fc")(x)
        x1 = KL.TimeDistributed(BatchNorm(),
                               name='mrcnn_mask_conv4bn')(x1, training=train_bn)
        x1 = KL.Activation('relu')(x1)
    
        x1 = KL.TimeDistributed(KL.Conv2D(256, (3, 3),strides=(2,2), padding="same"),
                               name="mrcnn_mask_conv5_fc")(x1)
        x1 = KL.TimeDistributed(BatchNorm(),
                                name='mrcnn_mask_conv5bn')(x1, training=train_bn)
        x1 = KL.Activation('relu')(x1)
    
        #x1 = KL.TimeDistributed(KL.Dense(256*4*4,activation="sigmoid"),
        #                       name="mrcnn_mask_fc")(x1)
        x1 = KL.TimeDistributed(KL.Flatten())(x1)
        x1 = KL.TimeDistributed(KL.Dense(28*28*num_classes),name='mrcnn_mask_fc_logits')(x1)
    
        x1 = KL.Activation("softmax",name="mrcnn_class_fc")(x1)
    
    
    
        s = K.int_shape(x1)
        x1 = KL.Reshape(( s[1],28,28, num_classes), name="mrcnn_mask_fc_reshape")(x1)
        #x1 = KL.TimeDistributed(KL.Reshape((14,14)),name="mrcnn_mask_fc_reshape")(x1)
    
        x = KL.TimeDistributed(KL.Conv2D(256, (3, 3), padding="same"),
                               name="mrcnn_mask_conv4")(x)
        x = KL.TimeDistributed(BatchNorm(),
                               name='mrcnn_mask_bn4')(x, training=train_bn)
        x = KL.Activation('relu')(x)
    
        x = KL.TimeDistributed(KL.Conv2DTranspose(256, (2, 2), strides=2, activation="relu"),
                               name="mrcnn_mask_deconv")(x)
    
    
        x = KL.TimeDistributed(KL.Conv2D(num_classes, (1, 1), strides=1, activation="softmax"),
                               name="mrcnn_mask")(x)
        x = KL.Add(name="mrcnn_mask_add")([x, x1])
        x = KL.Activation('tanh',name="mrcnn_masksoftmax")(x)
    
    
        return x
    
    展开全文
  • 用于语义边缘检测的动态特征融合(DFF)代码
  • 用于“注意特征融合”的MXNet / Gluon代码 到目前为止,此仓库中有什么: ImageNet的代码,训练有素的模型和训练日志 PS: 如果您是我们提交的论文的审稿人,请注意,当前实现的准确性比本文中的准确性要高一些,...
  • MATLAB源码集锦-特征降维,特征融合,相关分析等多元数据分析的典型相关分析代码
  • 恶意代码的多维度特征融合与深度处理,是恶意代码分类研究的一种发展趋势,也是恶意代码分类研究的一个难点问题。提出了一种适用于恶意代码分类的高维特征融合方法,对恶意代码的静态二进制文件和反汇编特征等进行...
  • 标准VQA模型包括3个模块,分别是图像特征提取模块,文本特征提取模块,以及特征融合后的分类模块。标准VQA模型如下图所示: 1. 图像特征提取 一般我们用预训练好的CNN模型,这里常用的包括vgg16/19,resnet-152/...

    一、背景

    本教程用于记录自己学习视觉问答代码编写的学习过程。

    二、VQA关键部分代码

    标准VQA模型包括3个模块,分别是图像特征提取模块,文本特征提取模块,以及特征融合后的分类模块。标准VQA模型如下图所示:

    1. 图像特征提取

    一般我们用预训练好的CNN模型,这里常用的包括vgg16/19,resnet-152/101,faster rcnn。主要的是这三类,当然你也可以自己写cnn或者用其他模型。

    (1)使用预训练的vgg16/19来提取图像特征

    这里以vgg16为例。我们需要下载预训练好的vgg16和相应的python文件

    常用的预训练好的vgg16有两种格式:

    ①预训练的vgg16.tfmodel文件和vgg16.py文件:这里的tfmodel可以从这里下载:https://github.com/ry/tensorflow-vgg16,如果你没有安装caffe,那么就用种子下载训练好的文件吧:

    下载上面的几个文件,然后种子文件用迅雷就可以下载。

    ②vgg16.npy文件和vgg16.py文件:另外一种就是npy文件格式,我个人也是用这种格式比较多。文件我传到了自己的网盘上(链接:https://pan.baidu.com/s/1o2-h5Vq6Ff4mCAHWMV7e8w     提取码:3pcx)。

    ③vgg19.npy文件和vgg19.py文件:和vgg16类似,文件的下载地址可以参考我这一篇博客:对抗生成网络学习(八)——DeblurGAN实现运动图像的去模糊化(tensorflow实现)

    由于自己不太用tfmodel文件,所以这里先主要介绍npy文件如何提取图像特征。

    这里先声明一下,这个vgg16.py文件我简单修改过,初始化的时候需要传入一个config类,这个类里面定义了很多参数,需要用到config的地方包括:

    class vgg_16():
        def __init__(self, config):
            self.model_path = config.vgg_path
            self.image_height = config.image_height
            self.image_width = config.image_width
    
            self.data_dict = np.load(self.model_path, encoding='latin1').item()
            print("vgg16.npy file loaded")

    接下来加载vgg16,首先是vgg16初始化,然后用到一个占位符,传入vgg中建立模型。

    vgg = vgg_16(config)
    images = tf.placeholder("float", [None, image_height, image_width, dim_image])
    with tf.name_scope("content_vgg"):
        vgg.build(images)

    这时候如果我需要提取一张图中的特征,就可以用下面的方法,这里我取出了‘fc7’层的特征,最终的特征保存在img_vgg_faeture变量中:

    img = resize(img, (image_height, image_width))
    img = img.reshape((1, image_height, image_width, dim_image))
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())
    img_vgg_feature = self.sess.run(vgg.fc7, feed_dict={images: img})

    (2)使用预训练的resnet-152/101来提取图像特征

    非常幸运的是,tensorflow里面集成好了resnet-50/101/152,我们可以直接调用。调用需要用到的库包括:

    from tensorflow.contrib.slim.nets import resnet_v2
    from tensorflow.contrib.slim.python.slim.nets.resnet_utils import resnet_arg_scope

    调用方法:

    with slim.arg_scope(resnet_arg_scope(is_training=False)):
        net, end_points = resnet_v2.resnet_v2_152(data_set)

    resnet-50和101都是一样的调用思路,net是网络最终的返回,大小是(1,1,1,2048),endpoint里面保存了resnet各个网络层节点信息。加入我们要用resnet提取图片特征,抽出中间的一个层,那么可以用如下的方法:

    # 随机读取一张图片,将其变成448*448的
    image = io.imread('0.png')
    image = transform.resize(image, (448, 448))
    
    # 由于一张图像是一个三维立方体,我们要将其变为四维张量
    data_set = np.empty((1, 448, 448, 3), dtype="float32")
    data_set[0, :, :, :] = image
    
    # 构建resnet网络
    with slim.arg_scope(resnet_arg_scope):
        net, end_points = resnet_v2.resnet_v2_152(data_set)
    
    # 运行网络
    init = tf.global_variables_initializer()
    with tf.Session() as sess:
        sess.run(init)
        sess.run(net)
        
        # 随便记录其中中间的某一层
        show_img = end_points['resnet_v2_152/block1/unit_1/bottleneck_v2/conv1'][0].eval()
    
    # 输出一下这一层的大小,是(112,112,64)
    print(show_img.shape)
    
    # 随便拿一个feature map输出一下
    io.imshow(show_img[:, :, 0])
    io.show()

    这个feature map输出的结果和原图如下所示:

    最后还有resnet_arg_scope是可以修改的,比如可以修改成下面的这种方式:

    def resnet_arg_scope(is_training=True,                              # 训练标记
                         weight_decay=0.0001,                           # 权重衰减速率
                         batch_norm_decay=0.997,                        # BN的衰减速率
                         batch_norm_epsilon=1e-5,                       # BN的epsilon默认1e-5
                         batch_norm_scale=True):                        # BN的scale默认值
    
      batch_norm_params = {                                             # 定义batch normalization(标准化)的参数字典
          'is_training': is_training,
          'decay': batch_norm_decay,
          'epsilon': batch_norm_epsilon,
          'scale': batch_norm_scale,
          'updates_collections': tf.GraphKeys.UPDATE_OPS,
      }
    
      with slim.arg_scope(                                              # 通过slim.arg_scope将[slim.conv2d]的几个默认参数设置好
          [slim.conv2d],
          weights_regularizer=slim.l2_regularizer(weight_decay),        # 权重正则器设置为L2正则
          weights_initializer=slim.variance_scaling_initializer(),      # 权重初始化器
          activation_fn=tf.nn.relu,                                     # 激活函数
          normalizer_fn=slim.batch_norm,                                # 标准化器设置为BN
          normalizer_params=batch_norm_params):
        with slim.arg_scope([slim.batch_norm], **batch_norm_params):
          with slim.arg_scope([slim.max_pool2d], padding='SAME') as arg_sc: # ResNet原论文是VALID模式,SAME模式可让特征对齐更简单
            return arg_sc                                               # 最后将基层嵌套的arg_scope作为结果返回

    (3)使用预训练的faster rcnn来提取图像特征

    2. 文本特征提取

    文本特征常用的提取方法一般有两种,LSTM或者GRU(其实GRU是LSTM的一个变种),但是在做文本特征提取之前,我们需要先将文本转成向量。

    (1)embedding嵌入

    这一步的目的是将文本转化为向量,当然文本转向量的方法有很多种,一种最简单的API如下:

    embeddings = tf.Variable(
                tf.random_uniform([self.vocabulary_size, self.word_embedding_dim], -1.0, 1.0))
    

    也就是我从[-1 1]之间随机初始化,初始化的参数服从均匀分布,生成一个[vocabulary_size, word_embedding_size]的向量。这里的vocabulary_size是所有unique word的数量,word_embedding_size就是每个单词要嵌入为多少长度的向量,一般设置300的比较多,这样做的意思就是说,我现在将所有单词建议一个映射表,每一个单词对应的300维的向量,当然这个映射表是随机建立的。

    下面要考虑的就是对unique word建立id表了,也就是对每个单词建立一个编号,根据这个编号,我们才能找到他在映射表中对应的向量:

    ques_word_list = []
    ques_word_list.append(ques_list[q].split(' '))

    上面这个问题就是找到ques_list中第q个问题,然后根据" "将问题中的所有单词分开,添加到ques_word_list中。

    添加的ques_word_list一般情况是个二维的,就是[ques_num, word_in_each_question],需要将其变为一维的:

    unique_word_in_q = [i for item in ques_word_list for i in item]  # 二维变一维

    接下来就是统计这个数组中的唯一单词数量了:

    all_word = list(set(list(set(unique_word_in_q)))

    最后就可以根据这个all_word构建一个word和id的编号表了:

    word2id = {word: index+1 for index, word in enumerate(all_word)}

    (2)word2vec可以看:

    (3)word2glove可以看:https://nlp.stanford.edu/projects/glove/

    三、其他

    1. 注意力机制

    使用注意力的方式有很多种,下面介绍一些常用的

    (1)SAN中的注意力

    SAN中的注意力比较简单,就是将问题向量作为一个query,来找图像向量中的关键部分。算法也很简单,两个向量结合在做一个tanh,最后再加上权重和bias做一次softmax就行了,代码如下:

        def compute_attention(self, image_tensor, question_tensor, out_dim, dropout=True):
            # 先将嵌入拉伸为1维向量
            img = tf.nn.tanh(tf.layers.dense(image_tensor, out_dim))
            ques = tf.nn.tanh(tf.layers.dense(question_tensor, out_dim))
    
            # 连接问题和图像
            ques = tf.expand_dims(ques, axis=-2)
            IQ = tf.nn.tanh(img + ques)
    
            if dropout:
                IQ = tf.nn.dropout(IQ, self.drop_out_rate)
    
            # 再将连接好的拉伸为1维向量,再reshape
            temp = tf.layers.dense(IQ, 1)
            temp = tf.reshape(temp, [-1, temp.shape[1]])
    
            # softmax获得注意力
            p = tf.nn.softmax(temp)
            p_exp = tf.expand_dims(p, axis=-1)
            att_layer = tf.reduce_sum(p_exp * image_tensor, axis=1)
    
            # 最终的注意力结果
            final_out = att_layer + question_tensor
    
            return p, final_out

     

    展开全文
  • 数据融合matlab代码轻量级特征融合网络,可实现单图像超分辨率 该存储库是我们提议的LFFN的Tensorflow代码(但是,数据加载部分基于pytorch。) 该代码基于和,并在具有1080Ti GPU的Ubuntu 16.04环境(Python 3.6,...
  • 我们的论文“利用深特征融合网络进行高光谱图像分类”的代码实现,IEEE Trans。 Geosci。 遥感,2018。 如果您使用此代码,请引用我们的论文: @article {song2018hyperspectral,标题= {具有深特征融合网络的高光谱...
  • 2 改进特征融合 不同于以往的基于元素和或级联的多层次特征融合方法,核心思想是自适应地学习各尺度特征地图融合的空间权重。如图2所示,它由两个步骤组成:相同的重新缩放和自适应融合。 尺度调整 x1 x2 x3 具有...

    https://github.com/ruinmessi/ASFF

    文章:https://arxiv.org/pdf/1911.09516v2.pdf

    1070 416 50ms ( 20fps)

    1 增强的 baseline

    为了更好地证明我们提出的ASFF方法的有效性,我们基于这些先进技术建立了一个比origin yolov3强得多的基线。

    在高级训练技巧[43]( Bag of freebies for training object detection neural networks)之后,我们介绍了训练过程中的一些技巧,
    如混合算法[12]、余弦[26]学习速率调度和同步批处理规范化技术[30]。除了这些技巧之外,我们还像[45]一样添加了一个无锚分支来与基于锚的分支一起运行,并利用[38]提出的锚引导机制来改进结果。此外,为了更好地进行包围盒回归,在原光滑L1损失上使用了额外的交并(IoU)损失函数[41]。

    训练技巧

    [43]( Bag of freebies for training object detection neural networks)

    [12] Zhang Hongyi, Cisse Moustapha, N. Dauphin Yann, and David Lopez-Paz. mixup: Beyond empirical risk minimization. ICLR, 2018.

    [26] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983,2016.

    [30] Chao Peng, Tete Xiao, Zeming Li, Yuning Jiang, Xiangyu Zhang, Kai Jia, Gang Yu, and Jian Sun. Megdet: A large mini-batch object detector. In CVPR, 2018

    无锚点

    [38] Jiaqi Wang, Kai Chen, Shuo Yang, Chen Change Loy, and
    Dahua Lin. Region proposal by guided anchoring. In CVPR,
    2019.

    [45] Chenchen Zhu, Yihui He, and Marios Savvides. Feature selective anchor-free module for single-shot object detection.In CVPR, 2019.

    bbox损失函数

    Jiahui Yu, Yuning Jiang, Zhangyang Wang, Zhimin Cao, and Thomas Huang. Unitbox: An advanced object detection network. In ACMM, 2016.

    利用上述先进技术,在COCO[22]2017 val集合上以50 FPS的(在特斯拉V100上)获得38.8%的mAP,大大提高了原始的YOLOv3-608基线(33.0%的mAP,52 FPS[31]),而无需大量的计算成本。

    2 改进特征融合

    不同于以往的基于元素和或级联的多层次特征融合方法,核心思想是自适应地学习各尺度特征地图融合的空间权重。如图2所示,它由两个步骤组成:相同的重新缩放和自适应融合。
    在这里插入图片描述

    尺度调整

    x1 x2 x3 具有不同的分辨率和不同的通道数,去、为了融合要一致。
    在这里插入图片描述
    因此我们相应地修改了每个尺度的上采样和下采样策略。对于上采样,我们首先使用1×1卷积层将特征的通道数压缩到l级,然后分别使用插值来提高分辨率。对于1/2比例的下采样,我们简单地使用一个3×3的卷积层(步长为2)来同时修改通道数和分辨率。对于1/4的比例,我们在2步卷积之前添加了一个2步最大池层。

    特征融合

    在这里插入图片描述
    alpha beta gama是0~1权重,并和为一。用三者加权。
    在这里插入图片描述在这里插入图片描述
    为训练的参数

    各层三部分可视化和融合后结果

    在这里插入图片描述在这里插入图片描述

    梯度计算

    链式法则+近似
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    对应融合系数
    所以:
    在这里插入图片描述

    结果

    在这里插入图片描述

    class ASFF(nn.Module): 
         def __init__(self, level, rfb=False, vis=False): 
            super(ASFF, self).__init__() 
            self.level = level 
            self.dim = [512, 256, 256] 
            self.inter_dim = self.dim[self.level] 
            # 每个level融合前,需要先调整到一样的尺度
            if level==0: 
                self.stride_level_1 = add_conv(256, self.inter_dim, 3, 2) 
                self.stride_level_2 = add_conv(256, self.inter_dim, 3, 2) 
                self.expand = add_conv(self.inter_dim, 1024, 3, 1) 
            elif level==1: 
                self.compress_level_0 = add_conv(512, self.inter_dim, 1, 1) 
                self.stride_level_2 = add_conv(256, self.inter_dim, 3, 2) 
               self.expand = add_conv(self.inter_dim, 512, 3, 1) 
           elif level==2: 
               self.compress_level_0 = add_conv(512, self.inter_dim, 1, 1) 
               self.expand = add_conv(self.inter_dim, 256, 3, 1) 
           compress_c = 8 if rfb else 16  #when adding rfb, we use half number of channels to save memory 
    
           self.weight_level_0 = add_conv(self.inter_dim, compress_c, 1, 1) 
           self.weight_level_1 = add_conv(self.inter_dim, compress_c, 1, 1) 
           self.weight_level_2 = add_conv(self.inter_dim, compress_c, 1, 1) 
    
           self.weight_levels = nn.Conv2d(compress_c*3, 3, kernel_size=1, stride=1, padding=0) 
           self.vis= vis 
           
        def forward(self, x_level_0, x_level_1, x_level_2): 
            if self.level==0: 
               level_0_resized = x_level_0 
               level_1_resized = self.stride_level_1(x_level_1) 
     
               level_2_downsampled_inter =F.max_pool2d(x_level_2, 3, stride=2, padding=1) 
               level_2_resized = self.stride_level_2(level_2_downsampled_inter) 
     
           elif self.level==1: 
               level_0_compressed = self.compress_level_0(x_level_0) 
               level_0_resized =F.interpolate(level_0_compressed, scale_factor=2, mode='nearest') 
               level_1_resized =x_level_1 
               level_2_resized =self.stride_level_2(x_level_2) 
           elif self.level==2: 
               level_0_compressed = self.compress_level_0(x_level_0) 
               level_0_resized =F.interpolate(level_0_compressed, scale_factor=4, mode='nearest') 
               level_1_resized =F.interpolate(x_level_1, scale_factor=2, mode='nearest') 
              level_2_resized =x_level_2 
     
           level_0_weight_v = self.weight_level_0(level_0_resized) 
           level_1_weight_v = self.weight_level_1(level_1_resized) 
           level_2_weight_v = self.weight_level_2(level_2_resized) 
           levels_weight_v = torch.cat((level_0_weight_v, level_1_weight_v, level_2_weight_v),1) 
           # 学习的3个尺度权重
           levels_weight = self.weight_levels(levels_weight_v) 
           levels_weight = F.softmax(levels_weight, dim=1) 
           # 自适应权重融合
           fused_out_reduced = level_0_resized * levels_weight[:,0:1,:,:]+\ 
                               level_1_resized * levels_weight[:,1:2,:,:]+\ 
                               level_2_resized * levels_weight[:,2:,:,:] 
     
           out = self.expand(fused_out_reduced) 
     
           if self.vis: 
               return out, levels_weight, fused_out_reduced.sum(dim=1) 
           else: 
              return out 
    
    
    

    ubuntu环境

    安装apex

    https://github.com/NVIDIA/apex

    Compile the DCN layer
    ./make.sh

    更新torchvision
    torchvision’ has no attribute ‘ops’

    https://pypi.org/project/torchvision/#files
    下载whl文件安装

    展开全文
  • 请问哪位大神有‘粒子滤波视频目标跟踪’的完整实现代码啊?最近在研究这个,却一直束手无措,急求啊,感谢分享~
  • 针对运动想象脑电信号,基于时频域和空间域分别采用小波变换法和共空间模式(CSP)提取特征向量,使用支持向量 机(SVM)对单一特征融合特征进行识别并比较分类准确率
  • CV之Face Change:基于人工智能实现国内众多一线美女明星换脸(基于Face++输出4*106个特征点定位+融合代码、deepfake技术) 视频实时换脸明星动画—最新案例 1、演示视频案例一 下边为原主播 其次,进行实时变脸...
  • 灰度特征提取matlab代码耦合特征学习用于多模态医学图像融合 参考:FG Veshki,N Ouzir,SA Vorobyov,E Ollila,用于多模式医学图像融合的耦合特征学习,2021年,arxiv.org %运行脚本文件“ Demo_gray.m”,“ ...
  • 保守值法matlab代码统计与感知特征融合的无参考图像质量评估 无参考图像质量评估(NR-IQA)的目标是预测人类观察者感知的图像质量,而无需使用任何原始的参考图像。 在这项研究中,提出了一种NR-IQA算法,该算法由...
  • 将MD大神提出的CN特征融合到KCF中,采用的是简单的线性相加。里面的有的注释谷歌翻译的,可以无视
  • 光谱图像分类的多分辨率压缩特征融合 和 抽象的 压缩光谱成像(CSI)已经成为一种替代的采集框架,可以同时感测和压缩光谱图像。 在这种情况下,由于特征提取阶段通常需要重建光谱图像,因此从CSI压缩测量中进行光谱...
  • 图像融合代码.rar

    2020-07-03 22:25:11
    图像融合思路:首先对两幅图像进行灰度处理并进行Harris角点检测,然后根据检测的角点做特征匹配,接着通过homography变换将一幅图像拼接到另一幅图像上,最后将重叠的像素点进行融合得到一副图像。 文件包括:实验...
  • 图像特征融合基础知识

    千次阅读 2019-08-03 07:26:54
    特征融合时看到的不错的博客,就是有没有开源的代码供使用 https://blog.csdn.net/xys430381_1/article/details/88370733
  • 通过粗尺度特征融合和多级注意块进行弱监督图像检索 聂新尧,陆宏,王自建,刘景元,郭泽华 复旦大学 该存储库是ICMR 2019中进行的代码。如果您无法打开链接,则可以下载以pdf格式上传的论文。 要求 Python 3,...
  • CVPR 2020文件的源代码“多尺度提振除雾网络与密集特征融合”,由,,,项蕾,,王飞, 更新 (2020.12.28)发布培训脚本和改进的模型。 依存关系 Python 3.6 PyTorch> = 1.1.0 火炬视觉 麻木 skimage h5py 的...
  • 数据融合matlab代码 fce-data-fusion MATLAB code for aerial images feature extraction performing data fusion (old version: )
  • 人脸图像特征提取matlab代码

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 581
精华内容 232
关键字:

特征融合代码