精华内容
下载资源
问答
  • 一般的学校都是在30%左右,当然这些政策要求,学校是可以变更的,有些的要求松差不多40%也有可能,有些学校要求的复制比要求很高10%以下的也有,所以同学在论文检测之前,需要先咨询下自己所在的学校的要求,然后

    很多人很疑惑我检测完了,也看到了结果,到底能不能通过学校的检测呢?具体有什么样的指标或者结果?
    问:每个学校对论文检测后的结果值是否一样?
    答:能说大部分的学校可能对结果值的要求都是差不多的,一般的学校都是在30%左右,当然这些政策要求,学校是可以变更的,有些的要求松差不多40%也有可能,有些学校要求的复制比要求很高10%以下的也有,所以同学在论文检测之前,需要先咨询下自己所在的学校的要求,然后再检测文章,这样心里就有底了,一般学校在检测之前都会发通知告知老师或者学生。如果不放心可有自己提前在网上Cncnki查重网检测,结果和学校一致!

    展开全文
  • 睿智的目标检测20——利用mAP计算目标检测精确度

    万次阅读 多人点赞 2020-03-06 17:12:48
    睿智的目标检测20——利用mAP计算目标检测精确度学习前言GITHUB代码下载知识储备1、IOU的概念2、TP TN FP FN的概念3、precision(精确度)和recall(召回率)4、概念举例5、单个指标的局限性什么是AP绘制mAP ...

    学习前言

    好多人都想算一下目标检测的精确度,mAP的概念虽然不好理解,但是理解了就很懂。
    在这里插入图片描述

    GITHUB代码下载

    这个是用来绘制mAP曲线的。
    https://github.com/Cartucho/mAP
    这个是用来获取绘制mAP曲线所需的txt的
    https://github.com/bubbliiiing/count-mAP-txt

    知识储备

    1、IOU的概念

    IOU的概念应该比较简单,就是衡量预测框和真实框的重合程度。
    下图是一个示例:图中绿色框为实际框(好像不是很绿……),红色框为预测框,当我们需要判断两个框之间的关系时,主要就是判断两个框的重合程度。
    在这里插入图片描述
    计算IOU的公式为:
    在这里插入图片描述
    可以看到IOU是一个比值,即交并比。
    在分子部分,值为预测框和实际框之间的重叠区域;
    在分母部分,值为预测框和实际框所占有的总区域。
    在这里插入图片描述
    在这里插入图片描述
    交区域和并区域的比值,就是IOU。

    2、TP TN FP FN的概念

    TP TN FP FN里面一共出现了4个字母,分别是T F P N。
    T是True;
    F是False;
    P是Positive;
    N是Negative。

    T或者F代表的是该样本 是否被正确分类。
    P或者N代表的是该样本 被预测成了正样本还是负样本。

    TP(True Positives)意思就是被分为了正样本,而且分对了。
    TN(True Negatives)意思就是被分为了负样本,而且分对了,
    FP(False Positives)意思就是被分为了正样本,但是分错了(事实上这个样本是负样本)。
    FN(False Negatives)意思就是被分为了负样本,但是分错了(事实上这个样本是这样本)。

    在mAP计算的过程中主要用到了,TP、FP、FN这三个概念。

    3、precision(精确度)和recall(召回率)

    Precision=TPTP+FP Precision= \frac{TP}{TP+FP}
    TP是分类器认为是正样本而且确实是正样本的例子,FP是分类器认为是正样本但实际上不是正样本的例子,Precision翻译成中文就是“分类器认为是正类并且确实是正类的部分占所有分类器认为是正类的比例”。

    Recall=TPTP+FN Recall= \frac{TP}{TP+FN}
    TP是分类器认为是正样本而且确实是正样本的例子,FN是分类器认为是负样本但实际上不是负样本的例子,Recall翻译成中文就是“分类器认为是正类并且确实是正类的部分占所有确实是正类的比例”。

    4、概念举例

    在这里插入图片描述
    如图所示,蓝色的框是 真实框绿色和红色的框是 预测框,绿色的框是正样本,红色的框是负样本。一般来讲,当预测框和真实框IOU>=0.5时,被认为是正样本。
    因此对于这幅图来讲。
    真实框一共有3个,正样本一共有2个,负样本一共有2个。
    此时
    Precision=22+2=1/2 Precision= \frac{2}{2+2} = 1/2
    Recall=22+1=2/3 Recall= \frac{2}{2+1} = 2/3

    5、单个指标的局限性

    在目标检测算法里面有一个非常重要的概念是置信度,如果置信度设置的高的话,预测的结果和实际情况就很符合,如果置信度低的话,就会有很多误检测。

    假设一幅图里面总共有3个正样本,目标检测对这幅图的预测结果有10个,其中3个实际上是正样本,7个实际上是负样本。对应置信度如下。
    在这里插入图片描述
    如果我们将可以接受的置信度设置为0.95的话,那么目标检测算法就会将序号为1的样本作为正样本,其它的都是负样本。此时TP = 1,FP = 0,FN = 2。
    Precision=11+0=1 Precision= \frac{1}{1+0} = 1
    Recall=11+2=1/3 Recall= \frac{1}{1+2} = 1/3
    此时Precision非常高,但是事实上我们只检测出一个正样本,还有两个没有检测出来,因此只用Precision就不合适。

    这个时候如果我们将可以接受的置信度设置为0.35的话,那么目标检测算法就会将序号为1的样本作为正样本,其它的都是负样本。此时TP = 3,FP = 3,FN = 0。
    Precision=33+3=1/2 Precision= \frac{3}{3+3} = 1/2
    Recall=33+0=1 Recall= \frac{3}{3+0} = 1
    此时Recall非常高,但是事实上目标检测算法认为是正样本的样本里面,有3个样本确实是正样本,但有三个是负样本,存在非常严重的误检测,因此只用Recall就不合适。

    二者进行结合才是评价的正确方法。

    什么是AP

    AP事实上指的是,利用不同的Precision和Recall的点的组合,画出来的曲线下面的面积。
    如下面这幅图所示。
    在这里插入图片描述
    当我们取不同的置信度,可以获得不同的Precision和不同的Recall,当我们取得置信度够密集的时候,就可以获得非常多的Precision和Recall。

    此时Precision和Recall可以在图片上画出一条线,这条线下部分的面积就是某个类的AP值。

    mAP就是所有的类的AP值求平均。

    绘制mAP

    我们首先在这个github上下载绘制mAP所需的代码。
    https://github.com/Cartucho/mAP
    在这个代码中,如果想要绘制mAP则需要三个内容。分别是:
    detection-results:指的是预测结果的txt。
    在这里插入图片描述
    ground-truth:指的是真实框的txt。
    在这里插入图片描述
    image-optional:指的是图片,有这个可以可视化,但是这个可以没有。
    在这里插入图片描述
    我们需要生成这三个内容,此时下载第二个库,这个是我拿我制作的ssd代码写的一个可以生成对应txt的例子。
    https://github.com/bubbliiiing/count-mAP-txt
    我们首先将整个VOC的数据集放到VOCdevikit中
    在这里插入图片描述
    然后修改voc2ssd.py里面的trainval_percent,一般用数据集的10%或者更少用于测试。如果大家放进VOCdevikit的数据集不是全部数据,而是已经筛选好的测试数据集的话,那么就把trainval_percent设置成0,表示全部的数据都用于测试。
    在这里插入图片描述
    然后运行voc2ssd.py。
    此时会生成test.txt,存放用于测试的图片的名字。
    在这里插入图片描述
    然后依次运行主目录下的get_dr_txt.py和get_gt_txt.py获得预测框对应的txt和真实框对应的txt。
    get_dr_txt.py是用来检测测试集里面的图片的,然后会生成每一个图片的检测结果,我重写了detect_image代码,用于生成预测框的txt。
    利用for循环检测所有的图片。
    在这里插入图片描述
    get_dr_txt.py是用来获取测试集中的xml,然后根据每个xml的结果生成真实框的txt。
    利用for循环检测所有的xml。
    在这里插入图片描述
    完成后我们会在input获得三个文件夹。
    在这里插入图片描述
    此时把input内部的文件夹复制到mAP的代码中的input文件夹内部就可以了,然后我们运行mAP的代码中的main.py,运行结束后,会生成mAP相关的文件。
    在这里插入图片描述
    结果生成在Result里面。
    在这里插入图片描述

    展开全文
  • 论文检测软件Rost,学位论文撰写好帮手

    千次下载 热门讨论 2009-12-16 18:33:48
    自己写的东西,知道是主要是哪几篇里复制的,把它转化为文本先一下,一样的就会红色标出,然后修改一下。挺好用的,用了它,过学术不端行为检测系统肯定没问题啦!注意调整相似度在40%以下,我的硕士论文用了它之后...
  • python+OpenCV 特征点检测

    万次阅读 2016-06-11 23:39:16
    1.Harris角点检测Harris角点检测算法是一个极为简单的角点检测算法,该算法在1988年就被发明了,算法的主要思想是如果像素周围显示存在多于一个方向的边,我们认为该点为兴趣点。基本原理是根据公式: 化简为求解...

    1.Harris角点检测

    Harris角点检测算法是一个极为简单的角点检测算法,该算法在1988年就被发明了,算法的主要思想是如果像素周围显示存在多于一个方向的边,我们认为该点为兴趣点。基本原理是根据公式:
    这里写图片描述
    化简为求解矩阵,最后根据矩阵的特征值判断是否为角点
    这里写图片描述
    这里写图片描述
    实现效果:
    这里写图片描述
    代码(不用OpenCV):

    
    # -*- coding: utf-8 -*-
    from pylab import *
    from PIL import Image
    from numpy import *
    from scipy.ndimage import filters
    
    print 'hello'
    
    def compute_harris_response(im,sigma=3):
        """ Compute the Harris corner detector response function 
            for each pixel in a graylevel image. """
    
        # derivatives
        imx = zeros(im.shape)
        filters.gaussian_filter(im, (sigma,sigma), (0,1), imx)
        imy = zeros(im.shape)
        filters.gaussian_filter(im, (sigma,sigma), (1,0), imy)
    
        # compute components of the Harris matrix
        Wxx = filters.gaussian_filter(imx*imx,sigma)
        Wxy = filters.gaussian_filter(imx*imy,sigma)
        Wyy = filters.gaussian_filter(imy*imy,sigma)
    
        # determinant and trace
        Wdet = Wxx*Wyy - Wxy**2
        Wtr = Wxx + Wyy
    
        return Wdet / Wtr
    
    
    def get_harris_points(harrisim,min_dist=10,threshold=0.1):
        """ Return corners from a Harris response image
            min_dist is the minimum number of pixels separating 
            corners and image boundary. """
    
        # find top corner candidates above a threshold
        corner_threshold = harrisim.max() * threshold
        harrisim_t = (harrisim > corner_threshold) * 1
    
        # get coordinates of candidates
        coords = array(harrisim_t.nonzero()).T
    
        # ...and their values
        candidate_values = [harrisim[c[0],c[1]] for c in coords]
    
        # sort candidates (reverse to get descending order)
        index = argsort(candidate_values)[::-1]
    
        # store allowed point locations in array
        allowed_locations = zeros(harrisim.shape)
        allowed_locations[min_dist:-min_dist,min_dist:-min_dist] = 1
    
        # select the best points taking min_distance into account
        filtered_coords = []
        for i in index:
            if allowed_locations[coords[i,0],coords[i,1]] == 1:
                filtered_coords.append(coords[i])
                allowed_locations[(coords[i,0]-min_dist):(coords[i,0]+min_dist), 
                            (coords[i,1]-min_dist):(coords[i,1]+min_dist)] = 0
    
        return filtered_coords
    
    
    def plot_harris_points(image,filtered_coords):
        """ Plots corners found in image. """
    
        figure()
        gray()
        imshow(image)
        plot([p[1] for p in filtered_coords],
                    [p[0] for p in filtered_coords],'*')
        axis('off')
        show()
    
    
    def get_descriptors(image,filtered_coords,wid=5):
        """ For each point return pixel values around the point
            using a neighbourhood of width 2*wid+1. (Assume points are 
            extracted with min_distance > wid). """
    
        desc = []
        for coords in filtered_coords:
            patch = image[coords[0]-wid:coords[0]+wid+1,
                                coords[1]-wid:coords[1]+wid+1].flatten()
            desc.append(patch)
    
        return desc
    
    
    def match(desc1,desc2,threshold=0.5):
        """ For each corner point descriptor in the first image, 
            select its match to second image using
            normalized cross correlation. """
    
        n = len(desc1[0])
    
        # pair-wise distances
        d = -ones((len(desc1),len(desc2)))
        for i in range(len(desc1)):
            for j in range(len(desc2)):
                d1 = (desc1[i] - mean(desc1[i])) / std(desc1[i])
                d2 = (desc2[j] - mean(desc2[j])) / std(desc2[j])
                ncc_value = sum(d1 * d2) / (n-1) 
                if ncc_value > threshold:
                    d[i,j] = ncc_value
    
        ndx = argsort(-d)
        matchscores = ndx[:,0]
    
        return matchscores
    
    
    def match_twosided(desc1,desc2,threshold=0.5):
        """ Two-sided symmetric version of match(). """
    
        matches_12 = match(desc1,desc2,threshold)
        matches_21 = match(desc2,desc1,threshold)
    
        ndx_12 = where(matches_12 >= 0)[0]
    
        # remove matches that are not symmetric
        for n in ndx_12:
            if matches_21[matches_12[n]] != n:
                matches_12[n] = -1
    
        return matches_12
    
    
    def appendimages(im1,im2):
        """ Return a new image that appends the two images side-by-side. """
    
        # select the image with the fewest rows and fill in enough empty rows
        rows1 = im1.shape[0]    
        rows2 = im2.shape[0]
    
        if rows1 < rows2:
            im1 = concatenate((im1,zeros((rows2-rows1,im1.shape[1]))),axis=0)
        elif rows1 > rows2:
            im2 = concatenate((im2,zeros((rows1-rows2,im2.shape[1]))),axis=0)
        # if none of these cases they are equal, no filling needed.
    
        return concatenate((im1,im2), axis=1)
    
    
    def plot_matches(im1,im2,locs1,locs2,matchscores,show_below=True):
        """ Show a figure with lines joining the accepted matches 
            input: im1,im2 (images as arrays), locs1,locs2 (feature locations), 
            matchscores (as output from 'match()'), 
            show_below (if images should be shown below matches). """
    
        im3 = appendimages(im1,im2)
        if show_below:
            im3 = vstack((im3,im3))
    
        imshow(im3)
    
        cols1 = im1.shape[1]
        for i,m in enumerate(matchscores):
            if m>0:
                plot([locs1[i][1],locs2[m][1]+cols1],[locs1[i][0],locs2[m][0]],'c')
        axis('off')
    
    def imresize(im,sz):
        """    Resize an image array using PIL. """
        pil_im = Image.fromarray(uint8(im))
    
        return array(pil_im.resize(sz))
    """
    Example of detecting Harris corner points (Figure 2-1 in the book).
    """
    
    # 读入图像
    im = array(Image.open('swan.jpg').convert('L'))
    
    # 检测harris角点
    harrisim = compute_harris_response(im)
    
    # Harris响应函数
    harrisim1 = 255 - harrisim
    
    figure()
    gray()
    
    #画出Harris响应图
    subplot(141)
    imshow(harrisim1)
    print harrisim1.shape
    axis('off')
    axis('equal')
    
    
    threshold = [0.01, 0.05, 0.1]
    for i, thres in enumerate(threshold):
        filtered_coords = get_harris_points(harrisim, 6, thres)
        subplot(1, 4, i+2)
        imshow(im)
        print im.shape
        plot([p[1] for p in filtered_coords], [p[0] for p in filtered_coords], '*')
        axis('off')
    
    #原书采用的PCV中PCV harris模块
    #harris.plot_harris_points(im, filtered_coords)
    
    # plot only 200 strongest
    # harris.plot_harris_points(im, filtered_coords[:200])
    
    
    # Figure 2-2下面的图
    im1 = array(Image.open("swan.jpg").convert("L"))
    im2 = array(Image.open("swan.jpg").convert("L"))
    # resize to make matching faster
    im1 = imresize(im1, (im1.shape[1]/2, im1.shape[0]/2))
    im2 = imresize(im2, (im2.shape[1]/2, im2.shape[0]/2))
    
    wid = 5
    harrisim = compute_harris_response(im1, 5)
    filtered_coords1 = get_harris_points(harrisim, wid+1)
    d1 = get_descriptors(im1, filtered_coords1, wid)
    
    harrisim = compute_harris_response(im2, 5)
    filtered_coords2 = get_harris_points(harrisim, wid+1)
    d2 = get_descriptors(im2, filtered_coords2, wid)
    
    print 'starting matching'
    matches = match_twosided(d1, d2)
    
    figure()
    gray() 
    plot_matches(im1, im2, filtered_coords1, filtered_coords2, matches)
    show()
    
    

    OpenCV函数cv2.cornerHarris() 有四个参数 其作用分别为 :

    img - Input image, it should be grayscale and float32 type.
    blockSize - It is the size of neighbourhood considered for corner detection
    ksize - Aperture parameter of Sobel derivative used.
    k - Harris detector free parameter in the equation.

    当然可以使用OpenCV在亚像素上提高算法的精度,使用函数cv2.cornerSubPix(),不过应该使用最新版的OpenCV 我电脑上是2.4.9版本,好像文档[2]中的代码没有调试通过,
    下面是OpenCV代码的效果:
    这里写图片描述

    代码:

    # -*- coding: utf-8 -*-
    """
    Created on Sat Jun 11 23:21:18 2016
    
    @author: season
    """
    
    import cv2
    import numpy as np
    
    
    filename = 'swan.jpg'
    img = cv2.imread(filename)
    gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    
    gray = np.float32(gray)
    dst = cv2.cornerHarris(gray,2,3,0.04)
    
    #result is dilated for marking the corners, not important
    dst = cv2.dilate(dst,None)
    
    # Threshold for an optimal value, it may vary depending on the image.
    img[dst>0.01*dst.max()]=[0,0,255]
    
    cv2.imshow('dst',img)
    if cv2.waitKey(0) & 0xff == 27:
        cv2.destroyAllWindows()

    测试OpenCV,numpy模块的代码:

    #test cv2 and numpy package
    print cv2.__version__
    a = np.arange(10)
    print(a)

    2.sift特征

    在Harris角点中对于下图所示的特征,小窗口中可能认为是角点,当窗口尺寸变化,则可能检测不到角点。
    这里写图片描述
    2004年提出的Scale Invariant Feature Transform (SIFT) 是改进的基于尺度不变的特征检测器。

    SIFT特征包括兴趣点检测器和描述子,它对于尺度,旋转和亮度都具有不变性。

    有下面四个步骤
    1. Scale-space Extrema Detection
    2. Keypoint Localization
    3. Orientation Assignment
    4. Keypoint Descriptor
    5. Keypoint Matching

    sift特征点检测效果:
    这里写图片描述
    sift的OpenCV代码比较简单:

    # -*- coding: utf-8 -*-
    """
    Created on Sat Jun 11 20:22:51 2016
    
    @author: season
    """
    
    import cv2
    
    import numpy as np
    #import pdb
    #pdb.set_trace()#turn on the pdb prompt
    
    #test cv2 and numpy package
    print cv2.__version__
    a = np.arange(10)
    print(a)
    
    img = cv2.imread('swan.jpg')
    gray= cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    
    sift = cv2.SIFT()
    kp = sift.detect(gray,None)
    
    img=cv2.drawKeypoints(gray,kp)
    
    cv2.imwrite('sift_keypoints.jpg',img)
    cv2.imshow("sift_keypoint",img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

    3.SURF特征点

    In 2006, three people, Bay, H., Tuytelaars, T. and Van Gool, L, published another paper, “SURF: Speeded Up Robust Features” which introduced a new algorithm called SURF. As name suggests, it is a speeded-up version of SIFT.
    在SURF算法中,特征点的判据为某像素亮度的Hessian矩阵的行列式(Dxx*Dyy-Dxy*Dxy)为一个极值。由于Hessian矩阵的计算需要用到偏导数的计算,这一般通过像素点亮度值与高斯核的某一方向偏导数卷积而成;在SURF算法里,为提高算法运行速度,在精度影响很小的情况下,用近似的盒状滤波器(0,1,1组成的box filter)代替高斯核。因为滤波器仅有0,-1,1,因此卷积的计算可以用积分图像(Integral image)来优化(O(1)的时间复杂度),大大提高了效率。
    Surf在速度上比sift要快许多,这主要得益于它的积分图技术,已经Hessian矩阵的利用减少了降采样过程,另外它得到的特征向量维数也比较少,有利于更快的进行特征点匹配。

    基于surf的人脸识别:

    # -*- coding: utf-8 -*-
    """
    Created on Wed Jun 15 22:05:44 2016
    
    @author: Administrator
    """
    import cv2
    
    
    import numpy
    
    opencv_haystack =cv2.imread('woman.jpg')
    opencv_needle =cv2.imread('face.jpg')
    
    ngrey = cv2.cvtColor(opencv_needle, cv2.COLOR_BGR2GRAY)
    hgrey = cv2.cvtColor(opencv_haystack, cv2.COLOR_BGR2GRAY)
    
    # build feature detector and descriptor extractor
    hessian_threshold = 85
    detector = cv2.SURF(hessian_threshold)
    (hkeypoints, hdescriptors) = detector.detect(hgrey, None, useProvidedKeypoints = False)
    (nkeypoints, ndescriptors) = detector.detect(ngrey, None, useProvidedKeypoints = False)
    
    # extract vectors of size 64 from raw descriptors numpy arrays
    rowsize = len(hdescriptors) / len(hkeypoints)
    if rowsize > 1:
        hrows = numpy.array(hdescriptors, dtype = numpy.float32).reshape((-1, rowsize))
        nrows = numpy.array(ndescriptors, dtype = numpy.float32).reshape((-1, rowsize))
        #print hrows.shape, nrows.shape
    else:
        hrows = numpy.array(hdescriptors, dtype = numpy.float32)
        nrows = numpy.array(ndescriptors, dtype = numpy.float32)
        rowsize = len(hrows[0])
    
    # kNN training - learn mapping from hrow to hkeypoints index
    samples = hrows
    responses = numpy.arange(len(hkeypoints), dtype = numpy.float32)
    #print len(samples), len(responses)
    knn = cv2.KNearest()
    knn.train(samples,responses)
    
    # retrieve index and value through enumeration
    count = 1
    
    for i, descriptor in enumerate(nrows):
        descriptor = numpy.array(descriptor, dtype = numpy.float32).reshape((1, rowsize))
        #print i, descriptor.shape, samples[0].shape
        retval, results, neigh_resp, dists = knn.find_nearest(descriptor, 1)
        res, dist =  int(results[0][0]), dists[0][0]
        #print res, dist
    
        if dist < 0.1:
            count = count+1
            # draw matched keypoints in red color
            color = (0, 0, 255)
    #    else:
    #        # draw unmatched in blue color
    #        color = (255, 0, 0)
        # draw matched key points on haystack image
            x,y = hkeypoints[res].pt
            center = (int(x),int(y))
            cv2.circle(opencv_haystack,center,2,color,-1)
            # draw matched key points on needle image
            x,y = nkeypoints[i].pt
            center = (int(x),int(y))
            cv2.circle(opencv_needle,center,2,color,-1)
    
    
    cv2.imshow("Input Image", opencv_haystack)
    cv2.waitKey(0)
    cv2.imshow("The match Result", opencv_needle)
    cv2.waitKey(0)
    
    print count
    if count>40:
        print "Yes Success!"
    else:
        print "False Face!"
    #cv2.waitKey(0)
    #cv2.destroyAllWindows()

    4.ORB特征

    一种新的具有局部不变性的特征 —— ORB特征,从它的名字中可以看出它是对FAST特征点与BREIF特征描述子的一种结合与改进,这个算法是由Ethan Rublee,Vincent Rabaud,Kurt Konolige以及Gary R.Bradski在2011年一篇名为“ORB:An Efficient Alternative to SIFT or SURF”的文章中提出。就像文章题目所写一样,ORB是除了SIFT与SURF外一个很好的选择,而且它有很高的效率,最重要的一点是它是免费的,SIFT与SURF都是有专利的,你如果在商业软件中使用,需要购买许可。

    实现效果:
    这里写图片描述

    代码:

    # -*- coding: utf-8 -*-
    """
    Created on Thu Jun 16 11:11:18 2016
    
    @author: Administrator
    """
    
    import numpy as np
    import cv2
    #from matplotlib import pyplot as plt
    print cv2.__version__
    
    
    img1 = cv2.imread('woman.jpg',0)          # queryImage
    img2 = cv2.imread('face.jpg',0) # trainImage
    def drawMatches(img1, kp1, img2, kp2, matches):
        """
        My own implementation of cv2.drawMatches as OpenCV 2.4.9
        does not have this function available but it's supported in
        OpenCV 3.0.0
    
        This function takes in two images with their associated 
        keypoints, as well as a list of DMatch data structure (matches) 
        that contains which keypoints matched in which images.
    
        An image will be produced where a montage is shown with
        the first image followed by the second image beside it.
    
        Keypoints are delineated with circles, while lines are connected
        between matching keypoints.
    
        img1,img2 - Grayscale images
        kp1,kp2 - Detected list of keypoints through any of the OpenCV keypoint 
                  detection algorithms
        matches - A list of matches of corresponding keypoints through any
                  OpenCV keypoint matching algorithm
        """
    
        # Create a new output image that concatenates the two images together
        # (a.k.a) a montage
        rows1 = img1.shape[0]
        cols1 = img1.shape[1]
        rows2 = img2.shape[0]
        cols2 = img2.shape[1]
    
        out = np.zeros((max([rows1,rows2]),cols1+cols2,3), dtype='uint8')
    
        # Place the first image to the left
        out[:rows1,:cols1] = np.dstack([img1, img1, img1])
    
        # Place the next image to the right of it
        out[:rows2,cols1:] = np.dstack([img2, img2, img2])
    
        # For each pair of points we have between both images
        # draw circles, then connect a line between them
        for mat in matches:
    
            # Get the matching keypoints for each of the images
            img1_idx = mat.queryIdx
            img2_idx = mat.trainIdx
    
            # x - columns
            # y - rows
            (x1,y1) = kp1[img1_idx].pt
            (x2,y2) = kp2[img2_idx].pt
    
            # Draw a small circle at both co-ordinates
            # radius 4
            # colour blue
            # thickness = 1
            cv2.circle(out, (int(x1),int(y1)), 4, (255, 0, 0), 1)   
            cv2.circle(out, (int(x2)+cols1,int(y2)), 4, (255, 0, 0), 1)
    
            # Draw a line in between the two points
            # thickness = 1
            # colour blue
            cv2.line(out, (int(x1),int(y1)), (int(x2)+cols1,int(y2)), (255, 0, 0), 1)
    
    
        # Show the image
        cv2.imshow('Matched Features', out)
        cv2.waitKey(0)
        cv2.destroyWindow('Matched Features')
    
        # Also return the image if you'd like a copy
        return out
    
    # Initiate SIFT detector
    orb = cv2.ORB()
    
    # find the keypoints and descriptors with SIFT
    kp1, des1 = orb.detectAndCompute(img1,None)
    kp2, des2 = orb.detectAndCompute(img2,None)
    # create BFMatcher object
    bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
    
    # Match descriptors.
    matches = bf.match(des1,des2)
    
    # Sort them in the order of their distance.
    matches = sorted(matches, key = lambda x:x.distance)
    
    # Draw first 10 matches.
    img3 = drawMatches(img1,kp1,img2,kp2,matches[:10])
    
    cv2.imshow('dst',img3)
    if cv2.waitKey(0) & 0xff == 27:
        cv2.destroyAllWindows()
    #plt.imshow(img3),plt.show()
    
    
    '''
    draw match 函数在下面的链接中有自己的实现,我直接复制过来了
    
    http://stackoverflow.com/questions/20259025/module-object-has-no-attribute-drawmatches-opencv-python
    '''

    未完待续

    参考文献

    [1]http://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_feature2d/py_table_of_contents_feature2d/py_table_of_contents_feature2d.html
    [2]http://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_feature2d/py_features_harris/py_features_harris.html#exercises

    展开全文
  • EfficientDet训练自己的数据集实现抽烟检测

    千次阅读 热门讨论 2020-07-11 16:49:39
    本次用efficientdet来对抽烟检测检测出是否抽烟。那么,老规矩,先上结果图!!! 那么,接下来,还是原先一套流程。走起!!! 一、环境配置 python==3.7.4 tensorflow-gpu==1.14.0 keras==2.2.4 numpy==...

    哈哈,我又来了!!! 再次立下flag,开学之后还是要保持更新频率!!!

    本次用efficientdet来对抽烟检测,检测出是否抽烟。那么,老规矩,先上结果图!!!

    那么,接下来,还是原先一套流程。走起!!!

    一、环境配置

    • python==3.7.4
    • tensorflow-gpu==1.14.0
    • keras==2.2.4
    • numpy==1.17.4

    本次,在租的gpu的机器上的。没办法,efficientnet这个网络占据显存太大了。本次机器带不动呀。

    二、抽烟数据集

    本次数据集是用labelme标注的,提供的json格式的数据集,但本次我们的voc格式的xml数据集,所以需要对json格式的数据进行转换。

    图片:

    标注的json格式数据:

    转换后的xml格式

    本次json转xml的源码如下:

    # -*- coding: utf-8 -*-
    """
    Created on Sun May 31 10:19:23 2020
    @author: ywx
    """
    import os
    from typing import List, Any
    import numpy as np
    import codecs
    import json
    from glob import glob
    import cv2
    import shutil
    from sklearn.model_selection import train_test_split
     
    # 1.标签路径
    labelme_path = "annotations/"
    #原始labelme标注数据路径
    saved_path = "VOC2007/"
    # 保存路径
    isUseTest=True#是否创建test集
    # 2.创建要求文件夹
    if not os.path.exists(saved_path + "Annotations"):
        os.makedirs(saved_path + "Annotations")
    if not os.path.exists(saved_path + "JPEGImages/"):
        os.makedirs(saved_path + "JPEGImages/")
    if not os.path.exists(saved_path + "ImageSets/Main/"):
        os.makedirs(saved_path + "ImageSets/Main/")
    # 3.获取待处理文件
    files = glob(labelme_path + "*.json")
    files = [i.replace("\\","/").split("/")[-1].split(".json")[0] for i in files]
    print(files)
    # 4.读取标注信息并写入 xml
    for json_file_ in files:
        json_filename = labelme_path + json_file_ + ".json"
        json_file = json.load(open(json_filename, "r", encoding="utf-8"))
        height, width, channels = cv2.imread('jpeg/' + json_file_ + ".jpg").shape
        with codecs.open(saved_path + "Annotations/" + json_file_ + ".xml", "w", "utf-8") as xml:
     
            xml.write('<annotation>\n')
            xml.write('\t<folder>' + 'WH_data' + '</folder>\n')
            xml.write('\t<filename>' + json_file_ + ".jpg" + '</filename>\n')
            xml.write('\t<source>\n')
            xml.write('\t\t<database>WH Data</database>\n')
            xml.write('\t\t<annotation>WH</annotation>\n')
            xml.write('\t\t<image>flickr</image>\n')
            xml.write('\t\t<flickrid>NULL</flickrid>\n')
            xml.write('\t</source>\n')
            xml.write('\t<owner>\n')
            xml.write('\t\t<flickrid>NULL</flickrid>\n')
            xml.write('\t\t<name>WH</name>\n')
            xml.write('\t</owner>\n')
            xml.write('\t<size>\n')
            xml.write('\t\t<width>' + str(width) + '</width>\n')
            xml.write('\t\t<height>' + str(height) + '</height>\n')
            xml.write('\t\t<depth>' + str(channels) + '</depth>\n')
            xml.write('\t</size>\n')
            xml.write('\t\t<segmented>0</segmented>\n')
            for multi in json_file["shapes"]:
                points = np.array(multi["points"])
                labelName=multi["label"]
                xmin = min(points[:, 0])
                xmax = max(points[:, 0])
                ymin = min(points[:, 1])
                ymax = max(points[:, 1])
                label = multi["label"]
                if xmax <= xmin:
                    pass
                elif ymax <= ymin:
                    pass
                else:
                    xml.write('\t<object>\n')
                    xml.write('\t\t<name>' + labelName+ '</name>\n')
                    xml.write('\t\t<pose>Unspecified</pose>\n')
                    xml.write('\t\t<truncated>1</truncated>\n')
                    xml.write('\t\t<difficult>0</difficult>\n')
                    xml.write('\t\t<bndbox>\n')
                    xml.write('\t\t\t<xmin>' + str(int(xmin)) + '</xmin>\n')
                    xml.write('\t\t\t<ymin>' + str(int(ymin)) + '</ymin>\n')
                    xml.write('\t\t\t<xmax>' + str(int(xmax)) + '</xmax>\n')
                    xml.write('\t\t\t<ymax>' + str(int(ymax)) + '</ymax>\n')
                    xml.write('\t\t</bndbox>\n')
                    xml.write('\t</object>\n')
                    print(json_filename, xmin, ymin, xmax, ymax, label)
            xml.write('</annotation>')
    # 5.复制图片到 VOC2007/JPEGImages/下
    image_files = glob("jpeg/" + "*.jpg")
    print("copy image files to VOC007/JPEGImages/")
    for image in image_files:
        shutil.copy(image, saved_path + "JPEGImages/")
    # 6.split files for txt
    txtsavepath = saved_path + "ImageSets/Main/"
    ftrainval = open(txtsavepath + '/trainval.txt', 'w')
    ftest = open(txtsavepath + '/test.txt', 'w')
    ftrain = open(txtsavepath + '/train.txt', 'w')
    fval = open(txtsavepath + '/val.txt', 'w')
    total_files = glob("./VOC2007/Annotations/*.xml")
    total_files = [i.replace("\\","/").split("/")[-1].split(".xml")[0] for i in total_files]
    trainval_files=[]
    test_files=[] 
    if isUseTest:
        trainval_files, test_files = train_test_split(total_files, test_size=0.15, random_state=55) 
    else: 
        trainval_files=total_files 
    for file in trainval_files: 
        ftrainval.write(file + "\n") 
    # split 
    train_files, val_files = train_test_split(trainval_files, test_size=0.15, random_state=55) 
    # train
    for file in train_files: 
        ftrain.write(file + "\n") 
    # val 
    for file in val_files: 
        fval.write(file + "\n")
    for file in test_files:
        print(file)
        ftest.write(file + "\n")
    ftrainval.close()
    ftrain.close()
    fval.close()
    ftest.close()
    

    三、EfficientDet理论介绍

    EfficientDet是基于Efficientnet的目标检测网络,所以需要先读懂Efficientnet,这里可以先去看我之前写的卷积神经网络发展史中有关于Efficientnet的介绍。

    简短来说,EfficientNet是将图片的分辨率,网络的宽度,网络的深度这三者结合起来,通过α实现缩放模型,不同的α有不同的模型精度。

    总的来说,efficientdet目标检测网络,是以efficientnet为主干网络,之后经过bifpn特征特征网络,之后再输出检测结果。

    1.EfficientNet

    EfficientNet主要由Efficient Blocks构成,在其中小残差边以及大残差边构成,并在其中添加了注意力模块。

    def mb_conv_block(inputs, block_args, activation, drop_rate=None, prefix='', ):
        """Mobile Inverted Residual Bottleneck."""
    
        has_se = (block_args.se_ratio is not None) and (0 < block_args.se_ratio <= 1)
        bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
    
        # workaround over non working dropout with None in noise_shape in tf.keras
        Dropout = get_dropout(
            backend=backend,
            layers=layers,
            models=models,
            utils=keras_utils
        )
    
        # Expansion phase
        filters = block_args.input_filters * block_args.expand_ratio
        if block_args.expand_ratio != 1:
            x = layers.Conv2D(filters, 1,
                              padding='same',
                              use_bias=False,
                              kernel_initializer=CONV_KERNEL_INITIALIZER,
                              name=prefix + 'expand_conv')(inputs)
            x = layers.BatchNormalization(axis=bn_axis, name=prefix + 'expand_bn')(x)
            x = layers.Activation(activation, name=prefix + 'expand_activation')(x)
        else:
            x = inputs
    
        # Depthwise Convolution
        x = layers.DepthwiseConv2D(block_args.kernel_size,
                                   strides=block_args.strides,
                                   padding='same',
                                   use_bias=False,
                                   depthwise_initializer=CONV_KERNEL_INITIALIZER,
                                   name=prefix + 'dwconv')(x)
        x = layers.BatchNormalization(axis=bn_axis, name=prefix + 'bn')(x)
        x = layers.Activation(activation, name=prefix + 'activation')(x)
    
        # Squeeze and Excitation phase
        if has_se:
            num_reduced_filters = max(1, int(
                block_args.input_filters * block_args.se_ratio
            ))
            se_tensor = layers.GlobalAveragePooling2D(name=prefix + 'se_squeeze')(x)
    
            target_shape = (1, 1, filters) if backend.image_data_format() == 'channels_last' else (filters, 1, 1)
            se_tensor = layers.Reshape(target_shape, name=prefix + 'se_reshape')(se_tensor)
            se_tensor = layers.Conv2D(num_reduced_filters, 1,
                                      activation=activation,
                                      padding='same',
                                      use_bias=True,
                                      kernel_initializer=CONV_KERNEL_INITIALIZER,
                                      name=prefix + 'se_reduce')(se_tensor)
            se_tensor = layers.Conv2D(filters, 1,
                                      activation='sigmoid',
                                      padding='same',
                                      use_bias=True,
                                      kernel_initializer=CONV_KERNEL_INITIALIZER,
                                      name=prefix + 'se_expand')(se_tensor)
            if backend.backend() == 'theano':
                # For the Theano backend, we have to explicitly make
                # the excitation weights broadcastable.
                pattern = ([True, True, True, False] if backend.image_data_format() == 'channels_last'
                           else [True, False, True, True])
                se_tensor = layers.Lambda(
                    lambda x: backend.pattern_broadcast(x, pattern),
                    name=prefix + 'se_broadcast')(se_tensor)
            x = layers.multiply([x, se_tensor], name=prefix + 'se_excite')
    
        # Output phase
        x = layers.Conv2D(block_args.output_filters, 1,
                          padding='same',
                          use_bias=False,
                          kernel_initializer=CONV_KERNEL_INITIALIZER,
                          name=prefix + 'project_conv')(x)
        x = layers.BatchNormalization(axis=bn_axis, name=prefix + 'project_bn')(x)
        if block_args.id_skip and all(
                s == 1 for s in block_args.strides
        ) and block_args.input_filters == block_args.output_filters:
            if drop_rate and (drop_rate > 0):
                x = Dropout(drop_rate,
                            noise_shape=(None, 1, 1, 1),
                            name=prefix + 'drop')(x)
            x = layers.add([x, inputs], name=prefix + 'add')
    
        return x
    

    2.BiFPN

    改进了FPN中的多尺度特征融合方式,提出了加权双向特征金字塔网络BiFPN。BiFPN 引入了一种自顶向下的路径,融合P3~P7的多尺度特征

    BiFPN模块类似于FPN网络(特征金字塔网络),不过比FPN更复杂些。其主要是为了增强特征,提取更有代表性的特征。

    下图展示一下FPN网络:

    而这是BiFPN的网络图:

    其中的一个BiFPN模块为:

    四、训练过程

    1.准备数据集

    准备抽烟数据,使用VOC格式的数据进行训练

    • 训练前将标签文件放在VOCdevkit文件夹下的VOC2007文件夹下的Annotation中。
    • 训练前将图片文件放在VOCdevkit文件夹下的VOC2007文件夹下的JPEGImages中。
    • 在训练前利用voc2efficientdet.py文件生成对应的txt。
    VOCdevkit
       -VOC2007
       	├─ImageSets    # 存放数据集列表文件,由voc2yolo3.py文件生成
       	├─Annotations  # 存放数据集中图片文件
       	├─JPEGImages   # 存放图片标签,xml 格式
       	└─voc2yolo4.py # 用来生成数据集列表文件
    

    2.运行生成EfficientDet所需的数据

    再运行根目录voc_annotation.py,运行前需要将voc_annotation文件中classes改成你自己的classes。
    每一行对应其图片位置及其真实框的位置

    3.修改voc_classes.txt

    在训练前需要修改model_data里面的voc_classes.txt文件,需要将classes改成你自己的classes。

    4.修改yolo_anchors.txt

    运行kmeans_for_anchors.py生成yolo_anchors.txt

    5.运行

    运行train.py

    • 在main函数下:phi来控制efficient的版本
    • 在main函数下:model_path参数用于控制预训练权重

    6.测试图片

    需修改efficientdet.py文件中模型的位置,替换成你训练好的模型并修改phi为efficientdet的版本。然后在根目录下,运行python predict.py进行测试。

    好了,本次就到此结束了!!!

    哦,突然想起,我还保存了logs,在展示一波的训练过程吧!!!

    好了,下次看情况,更新点别的东西,更新点有关bert文本的吧!!!

    展开全文
  • 程序性能检测及优化

    千次阅读 2020-10-23 08:09:28
    1.使用OpenCV检测程序效率 cv2.getTickCount函数返回从参考点到这个函数被执行的时钟数。在一个函数执行前后都调用它,可以得到这个函数的执行时间。 cv2.getTickFrequency返回时钟频率,或者说每秒钟的时钟数 例,...
  • 这是作者新开的一个专栏,主要...前文分享了Linux系统下针对性的APT攻击及技术要点,这篇文章将介绍钓鱼邮件网址混淆URL逃避检测,钓鱼是APT攻击中常用的手段,它究竟怎么实现混淆呢?基础性文章,希望对您有所帮助。
  • 小目标检测中的数据扩展

    千次阅读 2019-06-24 17:41:09
    论文:Augmentation for small object detection Abstract 这些年来目标检测领域经历了令人...除了这些改进,在小目标检测与大目标检测领域还是有不小的差距。我们在MS COCO上分析了当前SOTA的模型Mask-RCNN。...
  • 入侵检测

    千次阅读 2018-12-20 00:42:00
    入侵检测 对于通过网络连接的系统来说,一个重要的安全问题是由用户或软件引起的恶意或者至少是不期望发生的非法入侵。用户非法入侵可能采用的方式是在未经授权的情况下登录到计算机,也可能是已授权用户非法获取更...
  • 对抗网络之目标检测应用:A-Fast-RCNN

    千次阅读 2017-08-05 00:21:16
    对抗网络之目标检测应用:A-Fast-RCNN 论文:A-Fast-RCNN: Hard Positive Generation via Adversary for Object Detection 【点击下载】 Caffe代码:【Github】一. 深度学习正确的打开方式 深度学习的根基在于...
  • 深度学习(十八)基于R-CNN的物体检测

    万次阅读 多人点赞 2015-12-05 16:58:12
    本篇博文主要讲解2014年CVPR上的经典paper:《Region-based Convolutional Networks for Accurate Object Detection and Segmentation》,这篇文章的算法又被称之为:R-CNN,是物体检测领域曾经获得state-of-art的...
  • 极小人脸检测

    千次阅读 2017-06-09 15:07:56
    尽管目标识别技术已经取得了巨大的进步,但检测小目标仍是一项开放性的挑战。针对微小人脸检测的问题,我们主要从三个方面做了研究:尺度不变,图像分辨率和上下文推理的作用。虽然大多数识别方法基于尺度不变,但...
  • 1.1 复制黏贴篡改检测方法 1.2 拼接组合篡改检测方法 2 基于卷积神经网络的篡改检测 3 未来发展趋势 面向互联网共享环境下的数字图像篡改检测研究 面向大规模图像数据集的数字图像篡改检测研究 0前言 随着...
  • 为大家介绍一篇图森的工作(Scale-Aware Trident Networks for Object Detection),这篇文章主要要解决的问题便是目标检测中最为棘手的s...
  • iOS安全保护:【1、数据加密2、代码混淆3、反调试、注入检测、hook检测、越狱检测、签名检测
  • postgresql流复制

    万次阅读 2016-04-15 11:18:41
    简介  从PostgreSQL 9.0开始,基于预写日志(Write Ahead Log, WAL)的可读复制(PITR)更是成为了官方提供的异步主从复制(Master-Slave Replication)解决方案,该方案拥有如下优点: a.使用预写日志记录数据库的改动...
  • haar+adaboost人脸检测

    千次阅读 2016-09-13 11:24:30
    利用opencv自带的haar-cascade分类器检测,从已经训练好的xml文件加载模型,读入待检测图片,多尺度检测 #include "opencv2/core/core.hpp" #include "opencv2/objdetect/objdetect.hpp" #include "opencv2/...
  • tiny YOLO v3做缺陷检测实战

    万次阅读 多人点赞 2018-12-14 21:28:01
    前言:接触yolo网络是在七月份,当时把yolo检测的论文以及R-CNN系列,SSD等一些论文看了一下,感觉内容很丰富,也尝试了darknet版本的实现,和yolo v3的实现,在网上也有很多关于上面两种的实现,这里就不讲了。...
  • 提供一个人脸检测的训练工程,其里面包括原始的训练样本、制作好的训练样本、训练指令等,感觉其样本分类特别麻烦其下载地址为: opencv使用cascade分类器训练人脸检测的样本与相关文件 1 、opencv里的分类器大概...
  • 基于深度学习的目标检测及场景文字检测研究 转载自:https://blog.csdn.net/u013250416/article/details/79591263 一.目标检测与场景文字检测定义目标检测:给定一张图片或者视频帧,找出其中所有目标的...
  • 一、主从复制搭建方法参考1、MySQL5.6 数据库主从(Master/Slave)同步安装与配置详解请参考: http://blog.csdn.net/xlgen157387/article/details/51331244#comments2、使用mysqlreplicate命令快速搭建 Mysql 主从...
  • 目标检测之四,使用multinet的KittiBox部分进行车辆检测(demo,train,evalute)    使用KittiBox进行车辆检测,训练环境和配置:Ubuntu16.04,python3.5,TensorFlow1.4,i76700K+双GTX Titan X。由于不能直接...
  • 基于深度学习的目标检测及场景文字检测研究进展

    万次阅读 多人点赞 2018-03-17 21:19:02
    目标检测与场景文字检测定义目标检测:给定一张图片或者视频帧,找出其中所有目标的位置,并给出每个目标的具体类别。场景文字检测:文字检测(Text Detection):对照片中存在文字的区域进行定位,即找到单词或者...
  • 本原创项目长期更新,旨在完成校园异常行为实时精检测,做到集成+N次开发+优化(不止局限于调包)为止,近期将不断更新以下模型+数据+标注文件+教程。关注博主,Star 一下github,一起开始美妙的目标检测之路吧~~ ...
  • 一、组复制性能 1. 概述 2. 测试规划 3. 消息压缩 4. 组通信线程循环 5. 写入集 6. 流控 7. 其它配置 8. 主从、半同步、组复制性能对比测试 二、组复制要求与限制 1. 组复制要求 2. 组复制限制 一、组...
  • 人脸关键点检测总结

    万次阅读 多人点赞 2018-05-31 10:38:21
    人脸关键点检测也称为人脸关键点检测、定位或者人脸对齐,是指给定人脸图像,定位出人脸面部的关键区域位置,包括眉毛、眼睛、鼻子、嘴巴、脸部轮廓等。 人脸关键点检测方法大致分为三种: - 基于模型的ASM(Active...
  • 点击上方“3D视觉工坊”,选择“星标”干货第一时间送达【导语】本文将介绍BBuf、小武和笔者一起在过年期间完成的一个目标检测项目,将描述我们模型改进的思路、实验思路、结果汇总和经验性总结...
  • 这里分享一篇文献中椭圆检测的方法(代码使用方法)。圆的物体,在实际拍摄中由于种种原因可能会变成椭圆,用圆拟合就不够准确。
  • 关于视频拷贝检测数据分析

    千次阅读 2014-10-04 10:33:36
    由于最近参加视频拷贝检测竞赛
  • HOG+SVM行人检测

    千次阅读 2016-10-11 19:25:25
    负样本是从不包含人体的图片中随机裁取的,大小同样是64*128(从完全不包含人体的图片中随机剪裁出64*128大小的用于人体检测的负样本)。 SVM使用的是OpenCV自带的CvSVM类。 首先计算正负样本图像的HOG描述子,组成一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 143,344
精华内容 57,337
关键字:

复制比怎么检测