首页 > 其他分享 >特征点检测与匹配

特征点检测与匹配

时间：2023-04-06 17:33:51浏览次数：39  
标签：匹配 img 特征 检测 cv2 img2 img1 ###

特征点检测与匹配

应用场景

​	图像搜索，如以图搜图(不是对整个图片进行处理的而是检测特征点进行搜索)

​	拼图游戏

​		拼图方法

​			寻找特征

​			特征是唯一的



​			特征可追踪的

​			能进行比较的

​	图像拼接，将两张有关联的图拼接到一起

什么是特征

​	图像特征就是指有意义的图像区域，具有独特性，易于识别性，比如角点，斑点以及高密度区域

角点

​	在特征中最重要的是角点，灰度梯度的最大值对应的像素

​	两条线的交点，极值点(一阶导数最大值，单二阶导数为0)

Harris角点检测

tezheng-01

周围没有像素的变化就认为是平坦的
垂直运动没有变化左右运动有变化--边缘
无论怎样运动都产生变化--角点

总结
	光滑地区，无论向哪里移动，衡量系数不变
	边缘地址，垂直边缘移动时，衡量系数变化剧烈
	在交点处，往哪个方向移动，衡量系数都变化剧烈
	
角点检测api
cornerHarris(img,dst,blockSize,ksize,k)
	blockSize:检测窗口大小
	ksize：Sobel的卷积核
	k：权重系数，经验值，一般取0.02~0.04之间
	
import cv2
import numpy as np

blockSize = 2
ksize = 3
k = 0.04
img = cv2.imread('C:\\Users\dazhi\Desktop\jiaodian.png')


###灰度化
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
###Harris角点检测
dst = cv2.cornerHarris(gray,blockSize,ksize,k)

###角点展示
img[dst>0.01*dst.max()] = [0,0,255]

cv2.imshow('harris',img)

cv2.waitKey(0)

tezheng-02

Shi-Tomasi角点检测

Shi-Tomasi是Harris角点检测的改进（k值不用设）
Harris角点检测算的稳定性和k有关，而k是个经验值，不好设定最佳值

api
goodFeaturesToTrack(img,maxCorners...)
	maxCorners:角点的最大数，值为0表示无限制
	qualityLevel:角点的质量 小于1.0的正数，一般在0.01-0.1之间
	minDistance：角之间距离 角之间最小欧式距离，忽略小于此距离的点  
	mask 感兴趣的区域(若设置mask则只在指定区域检测)
	blockSize：检测窗口
	useHarrisDetector： 是否使用Harris算法(默认是不使用)
	k 默认是0.04
	
	
import cv2
import numpy as np

maxCorners = 1000
ql = 0.01
minDistance = 10

img = cv2.imread('C:\\Users\dazhi\Desktop\jiaodian.png')

###灰度化
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
###角点检测
dst = cv2.goodFeaturesToTrack(gray,maxCorners,ql,minDistance)

###转换为整型
dst = np.int0(dst)

###绘制角点
for i in dst:
    ###转为一维
    x,y = i.ravel()
    cv2.circle(img,(x,y),3,(255,0,0),-1)

cv2.imshow('harris',img)
cv2.waitKey(0)

tezheng-03

SIFI与缩放无关的特征转换

SIFI出现的原因
	Harris角点具有旋转不变的特征
	但缩放后，原来的角点有可能就不是角点了
	放大后原来能检测出是角的现在可能就检测出不是角
	SIFI解决的问题就是原来是角放大或缩小后依然把这个角检测出来
使用SIFI步揍
	创建SIFI对象
	进行检测，kp = sift.detect(img,...)
	绘制关键点，drawKrypoints(gray,kp,img)
	
import cv2
import numpy as np

img = cv2.imread('C:\\Users\dazhi\Desktop\jiaodian.png')

###灰度化
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

####创建sift对象
####xfeatures2d扩展包中(因为版权问题所有放在扩展库中)
# sift = cv2.xfeatures2d.SIFT_create()
sift = cv2.SIFT_create()
###进行检测
###None对整个图进行检测
kp = sift.detect(gray,None)

###绘制
cv2.drawKeypoints(gray,kp,img)

cv2.imshow('img',img)
cv2.waitKey(0)

tezheng-04

计算SIFT描述子

关键点和描述子
	关键点：位置，大小和方向
	关键点描述子：记录了关键点周围对其有贡献的像素点的一组向量值，其不受仿射变换，光照变换等影响
	
计算描述子
	kp,des = sift.compute(img,kp)
	作用是进行特征匹配
同时计算关键点和描述
	kp,des = sift.detectAndCompute(img...)
		mask:指明对img中哪个区域进行计算
		
import cv2
import numpy as np

img = cv2.imread('C:\\Users\dazhi\Desktop\jiaodian.png')

###灰度化
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

####创建sift对象
####xfeatures2d扩展包中
# sift = cv2.xfeatures2d.SIFT_create()
sift = cv2.SIFT_create()
###进行检测
###None对整个图进行检测
kp,des = sift.detectAndCompute(gray,None)

print(des)

###绘制
cv2.drawKeypoints(gray,kp,img)

cv2.imshow('img',img)
cv2.waitKey(0)

----
打印的描述子结果
[[  5.   0.   0. ...   0.   0.   0.]
 [  0.   0.   0. ...   0.   0.   0.]
 [  0.   0.   0. ...   0.   0.   0.]
 ...
 [ 14.   5.  49. ...   0.   0.   5.]
 [  0.  47. 153. ...   0.   0.   0.]
 [  0.  23. 153. ...   0.   0.   0.]]

SURF

优点
	SIFT最大的问题是速度慢，因此才有SURF
	
使用步揍
	surf = cv2.xfeatures2d.SURF_create()
	kp,des = surf.detectAndCompute(img,mask)


import cv2
import numpy as np

img = cv2.imread('C:\\Users\dazhi\Desktop\jiaodian.png')

###灰度化
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

####创建sift对象
####xfeatures2d扩展包中
# sift = cv2.xfeatures2d.SIFT_create()
# sift = cv2.SIFT_create()
surf = cv2.xfeatures2d.SURF_create()
# surf = cv2.SURF_create()



###进行检测
###None对整个图进行检测
kp,des = surf.detectAndCompute(gray,None)

# print(des)

###绘制
cv2.drawKeypoints(gray,kp,img)

cv2.imshow('img',img)
cv2.waitKey(0)


###目前因为版权问题不可使用

ORB

两种技术组合而成：特征点检测 和 描述子的计算

优势
	可以做到实时检测(做到实时性就要对数据量的缩减)
	ORB = FAST + BRIEF
		FAST:可以做到特征点的实时检测
		BRIEF:对已检测到的特征点进行描述，他加快了特征描述符建立的速度，同时也极大的降低了特征匹配的时间
		
使用步揍
	orb = cv2.ORB_create()
	kp,des = orb.detectAndCompute(img,mask)
	
	
import cv2
import numpy as np

img = cv2.imread('C:\\Users\dazhi\Desktop\jiaodian.png')

###灰度化
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

###创建ORB对象
orb = cv2.ORB_create()

###进行检测
###None对整个图进行检测
kp,des = orb.detectAndCompute(gray,None)

###绘制
cv2.drawKeypoints(gray,kp,img)

cv2.imshow('img',img)
cv2.waitKey(0)

tezheng-05

特征匹配

特征匹配方法
	BF：暴力特征匹配方法(通过枚举)
	FLANN：最快邻近区特征匹配方法
	
暴力特征匹配原理
	它使用第一组中的每个特征的描述子(第一组指第一幅图的)与第二组中的所有特征描述子进行匹配计算他们之间的差距，然后将最接近一个(相似度最高的)匹配返回
	
匹配步骤
	创建匹配器：BFMatcher(normType,crossCheck)
		crossCheck:是否进行交叉匹配 默认为false
	进行特征匹配 bf.match(des1,des2)
		对两幅图的描述子进行计算
	绘制匹配点 cv2.drawMatches(img1,kp1,img2,k2...)
		搜索img，kp： 搜索的图和特征点
		匹配图img,kp
	
import cv2
import numpy as np

###打开两个图片(要有交叉点)
img1 = cv2.imread('C:\\Users\dazhi\Desktop\opencv_01.png')
img2 = cv2.imread('C:\\Users\dazhi\Desktop\opencv_02.png')

###灰度化
g1 = cv2.cvtColor(img1,cv2.COLOR_BGR2GRAY)
g2 = cv2.cvtColor(img2,cv2.COLOR_BGR2GRAY)

####创建sift对象
sift = cv2.SIFT_create()

###进行检测
###None对整个图进行检测
###通过对象创建特征点和描述子
kp1,des1 = sift.detectAndCompute(g1,None)
kp2,des2 = sift.detectAndCompute(g2,None)

###创建匹配器
bf = cv2.BFMatcher(cv2.NORM_L1)
###调用匹配器的match方法，获得两幅图的匹配的点
match = bf.match(des1,des2)

###绘制
img3 = cv2.drawMatches(img1,kp1,img2,kp2,match,None)

cv2.imshow('img3',img3)
cv2.waitKey(0)

tezheng-06

特征匹配

FLANN
	在进行批量特征匹配时，FLANN速度更快
	由于使用邻近近似值，所有精度较差
    
使用步揍
	创建FLANN匹配器 FlannBasedMatcher()
		index_parems字典：匹配算法KDTREE,LSH
		search_params字典：指定KDTREE算法中遍历树的次数
		KDTREE： index_params=dict(algorithm=FLANN_INDEX_KDTREE,trees=5)
		
	进行特征匹配 flann.match/knnMatch()
		参数为SIFT,SURF,ORB等计算的描述子
		k，表示取欧式距离最近的前k个关键点
		返回的是匹配的结果DMatch对象
			distance 描述子之间的距离，值越低越好
			queryIdx 第一个图像的描述子索引值
			trainIdx 第二个图的描述子索引值
			imgIdx 第二个图索引值
	绘制匹配点 cv2.drawMatches/drawMatchesKnn()
		
import cv2
import numpy as np

###打开两个图片(要有交叉点)
img1 = cv2.imread('C:\\Users\dazhi\Desktop\opencv_01.png')
img2 = cv2.imread('C:\\Users\dazhi\Desktop\opencv_02.png')

###灰度化
g1 = cv2.cvtColor(img1,cv2.COLOR_BGR2GRAY)
g2 = cv2.cvtColor(img2,cv2.COLOR_BGR2GRAY)

###创建SIFT特征检测器
sift = cv2.SIFT_create()

###计算描述子与特征点
kp1,des1 = sift.detectAndCompute(g1,None)
kp2,des2 = sift.detectAndCompute(g2,None)

###创建匹配器
index_params = dict(algorithm = 1,trees=5)
search_params = dict(checks = 50)
flann = cv2.FlannBasedMatcher(index_params,search_params)

###对描述子进行匹配计算
matchs = flann.knnMatch(des1,des2,k=2)


good = []
for i,(m,n) in enumerate(matchs):
    if m.distance < 0.7 * n.distance:
        good.append(m)


###绘制
###上面使用knnMatch下面必须使用对应的
ret = cv2.drawMatchesKnn(img1,kp1,img2,kp2,[good],None)

cv2.imshow('result',ret)
cv2.waitKey(0)

tezheng-07

图像查找

应用到 特征匹配+单应性矩阵

单应性矩阵
	获取一个矩阵与图像1运算就可以得到图像2的位置，图像2通过运算可以得到原始的位置
	opencv中只要将原始图片和目的图片将参数传入进去就可以获得单应性矩阵
	
import cv2
import numpy as np

###打开两个图片(要有交叉点)
img1 = cv2.imread('C:\\Users\dazhi\Desktop\opencv_01.png')
img2 = cv2.imread('C:\\Users\dazhi\Desktop\opencv_02.png')

###灰度化
g1 = cv2.cvtColor(img1,cv2.COLOR_BGR2GRAY)
g2 = cv2.cvtColor(img2,cv2.COLOR_BGR2GRAY)

###创建SIFT特征检测器
sift = cv2.SIFT_create()

###计算描述子与特征点
kp1,des1 = sift.detectAndCompute(g1,None)
kp2,des2 = sift.detectAndCompute(g2,None)

###创建匹配器
index_params = dict(algorithm = 1,trees=5)
search_params = dict(checks = 50)
flann = cv2.FlannBasedMatcher(index_params,search_params)

###对描述子进行匹配计算
matchs = flann.knnMatch(des1,des2,k=2)


good = []
for i,(m,n) in enumerate(matchs):
    if m.distance < 0.7 * n.distance:
        good.append(m)


if len(good) >= 4:
    ###查找单应性矩阵
    #源,转换成浮点形，遍历获取匹配点，变换成无数行，每一行有一个元素，这个元素是由2个子元素组成
    srcPts = np.float32([kp1[m.queryIdx].pt for m in good]).reshape(-1,1,2)
    #目的
    dstPts = np.float32([kp2[m.trainIdx].pt for m in good]).reshape(-1,1,2)
    ###cv2.RANSAC匹配点进行过滤 5.0阈值，返回值 掩码不需要使用 _表示
    H ,_ = cv2.findHomography(srcPts,dstPts,cv2.RANSAC,5.0)

    ###透视变换
    ###要搜索图的四个角点 .reshape():结构化
    h,w = img1.shape[:2]
    pts = np.float32([[0,0],[0,h-1],[w-1,h-1],[w-1,0]]).reshape(-1,1,2)
    dst = cv2.perspectiveTransform(pts,H)
    cv2.polylines(img2,[np.int32(dst)],True,(0,0,255))
else:
    print("the number of good is less than 4.")
    exit()


###绘制
###上面使用knnMatch下面必须使用对应的
ret = cv2.drawMatchesKnn(img1,kp1,img2,kp2,[good],None)
cv2.imshow('result',ret)
cv2.waitKey(0)

tezheng-08

图像拼接

基础知识
步揍
	读取文件并重置尺寸
	根据特征点和计算描述子，得到单应性矩阵
	图像变换
	图像拼接并输出图像

超过(0,0)点不显示

image-20230406153022330

import cv2
import numpy as np
 
#1读取文件，将图片设置成一样大小
#2找特征点，描述子，计算单应性矩阵
#3根据单应性矩阵对图象进行变换，然后平移
#4 拼接并输出最终结果

img1 = cv2.imread('C:\\Users\dazhi\Desktop\pinjie_01.png')
img2 = cv2.imread('C:\\Users\dazhi\Desktop\pinjie_02.png')
###将两张图片设置成同样大小
img1 = cv2.resize(img1,(640,480))
img2 = cv2.resize(img2,(640,480))

inputs = np.hstack((img1,img2))


cv2.imshow('inputs',inputs)
cv2.waitKey(0)



import cv2
import numpy as np
 
#1读取文件，将图片设置成一样大小
#2找特征点，描述子，计算单应性矩阵
#3根据单应性矩阵对图象进行变换，然后平移
#4 拼接并输出最终结果

##定义获取单向性矩阵接口
def get_homo(img1,img2):
    #1创建特征转换对象
    #2通过特征转换对象获得特征点和描述子
    #3创建特征匹配器
    #4进行特征匹配
    #5过滤特征，找出有效的特征匹配点

    sift =cv2.SIFT_create()

    k1,d1 = sift.detectAndCompute(img1,None)
    k2,d2 = sift.detectAndCompute(img2,None)

    #创建特征匹配器
    bf = cv2.BFMatcher()
    matches = bf.knnMatch(d1,d2,k=2)
    
    #过滤特征，找出有效的特征匹配点
    verify_ratio = 0.8
    for m1,m2 in matches:
        if m1.distance < 0.8 * m2.distance:
            verify_matches.append(m1)
    
    ###设置最小匹配数
    min_matches = 8
    if len(verify_matches) > min_matches:

        img1_pts = []
        img2_pts = []

        for m in verify_matches:
            img1_pts.append(k1[m.queryIdx].pt)
            img2_pts.append(k2[m.trainIdx].pt)


        img1_pts = np.float(img1_pts).reshape(-1,1,2)
        img2_pts = np.float(img2_pts).reshape(-1,1,2)

        H,mask = cv2.findHomography(img1_pts,img2_pts,cv2.RANSAC,5.0)
        return H
    else:
        print('error')
        exit()





img1 = cv2.imread('C:\\Users\dazhi\Desktop\pinjie_01.png')
img2 = cv2.imread('C:\\Users\dazhi\Desktop\pinjie_02.png')
###将两张图片设置成同样大小
img1 = cv2.resize(img1,(640,480))
img2 = cv2.resize(img2,(640,480))

inputs = np.hstack((img1,img2))

H = get_homo(img1,img2)
cv2.imshow('inputs',inputs)
cv2.waitKey(0)



import cv2
import numpy as np
 
#1读取文件，将图片设置成一样大小
#2找特征点，描述子，计算单应性矩阵
#3根据单应性矩阵对图象进行变换，然后平移
#4 拼接并输出最终结果

def stitch_image(img1,img2,H):
    #1获得每张图的四个角点
    #2对图片进行变换(但应性矩阵使图进行旋转，平移)
    #3创建一张大图，将两张图拼接到一起
    #4 将结果输出

    #1获得每张图的四个角点
    ###获得原始图的高宽
    h1,w1 = img1.shape[:2]
    h2,w2 = img2.shape[:2]

    img1_dims = np.float32([[0,0],[0,h1],[w1,h1],[w1,0]]).reshape(-1,1,2)
    img2_dims = np.float32([[0,0],[0,h2],[w2,h2],[w2,0]]).reshape(-1,1,2)

    ###进行图像变换
    img1_transform = cv2.perspectiveTransform(img1_dims,H)

    print(img1_dims)
    print(img2_dims)
    print(img1_transform)

    ###图像最大x值减去最小x值就是宽度，最大y值减去最小y值就是高度

    ###axis=0横向拼接
    result_dims = np.concatenate((img2_dims,img1_transform),axis=0)

    print(result_dims) ###混合后结果

    ###求最大值和最小值
    ###所有值中的最小值,加上axis是按哪个轴进行获取数据会获得二维数组(x,y)最小值
    ####，ravel()转为一维  整形变换四舍五入原则最小值-0.5 最大值+0.5
    [x_min,y_min] = np.int32(result_dims.min(axis=0).ravel()-0.5)
    [x_max,y_max] = np.int32(result_dims.max(axis=0).ravel()+0.5)

    ###平移的距离
    transform_dist = [-x_min,-y_min] 

    #[1,0,dx]
    #[0,1,dy]
    #[0,0,1]

    transform_array = np.array([[1,0,transform_dist[0]],
                                [0,1,transform_dist[1]],
                                [0,0,1]])


    ###由于是负值 减去等于加上
    result_img = cv2.warpPerspective(img1,transform_array.dot(H),(x_max-x_min,y_max-y_min))

    ###拼接
    result_img[transform_dist[1]:transform_dist[1]+h2,
               transform_dist[0]:transform_dist[0]+w2] = img2
    return result_img


##定义获取单向性矩阵接口
def get_homo(img1,img2):
    #1创建特征转换对象
    #2通过特征转换对象获得特征点和描述子
    #3创建特征匹配器
    #4进行特征匹配
    #5过滤特征，找出有效的特征匹配点

    sift =cv2.SIFT_create()

    k1,d1 = sift.detectAndCompute(img1,None)
    k2,d2 = sift.detectAndCompute(img2,None)

    #创建特征匹配器
    bf = cv2.BFMatcher()
    matches = bf.knnMatch(d1,d2,k=2)
    
    #过滤特征，找出有效的特征匹配点
    verify_ratio = 0.8
    verify_matches=[]
    for m1,m2 in matches:
        if m1.distance < 0.8 * m2.distance:
            verify_matches.append(m1)
    
    ###设置最小匹配数
    min_matches = 8
    if len(verify_matches) > min_matches:

        img1_pts = []
        img2_pts = []

        for m in verify_matches:
            img1_pts.append(k1[m.queryIdx].pt)
            img2_pts.append(k2[m.trainIdx].pt)


        img1_pts = np.float32(img1_pts).reshape(-1,1,2)
        img2_pts = np.float32(img2_pts).reshape(-1,1,2)

        H,mask = cv2.findHomography(img1_pts,img2_pts,cv2.RANSAC,5.0)
        return H
    else:
        print('error')
        exit()

img1 = cv2.imread('C:\\Users\dazhi\Desktop\pinjie_01.png')
img2 = cv2.imread('C:\\Users\dazhi\Desktop\pinjie_02.png')
###将两张图片设置成同样大小
img1 = cv2.resize(img1,(640,480))
img2 = cv2.resize(img2,(640,480))

inputs = np.hstack((img1,img2))

###获得单向性矩阵
H = get_homo(img1,img2)
###进行图像拼接
result_image = stitch_image(img1,img2,H)

cv2.imshow('inputs',result_image)
cv2.waitKey(0)

image-20230406172419518

标签：匹配,img,特征,检测,cv2,img2,img1,###
From： https://www.cnblogs.com/idazhi/p/17293535.html

相关文章

  • prescan检测不到MATLAB软件
    salute:LJK1、打开设置  2、更新matlab安装目录即可 ......
  • opencv-python 4.12. 模板匹配
    理论模板匹配是一种在较大图像中搜索和查找模板图像位置的方法。为此，OpenCV附带了一个函数cv.matchTemplate()。它只是在输入图像上滑动模板图像（如在2D卷积中），并比较模板图像下的输入图像的模板和补丁。在OpenCV中实现了几种比较方法。它返回一个灰度图像，其中每个像素表示该像素的......
  • 目标图像的HOG特征提取matlab仿真
    1.算法描述HOG特征提取方法就是将一个image（你要检测的目标或者扫描窗口）：1）灰度化（将图像看做一个x,y,z（灰度）的三维图像）；2）采用Gamma校正法对输入图像进行颜色空间的标准化（归一化）；目的是调节图像的对比度，降低图像局部的阴影和光照变化所造成的影响，同时可以抑制噪音的干扰；3）计算图像每个......
  • 基于模板和形态学处理的车牌检测分割和识别matlab仿真,可以识别其中的一个英文字母和
    1.算法描述       车牌识别系统(VehicleLicensePlateRecognition，VLPR)是计算机视频图像识别技术在车辆牌照识别中的一种应用。车牌识别在高速公路车辆管理中得到广泛应用，电子收费（ETC）系统中，也是结合DSRC技术识别车辆身份的主要手段。        车牌识别技术要......
  • 目标图像的HOG特征提取matlab仿真
    1.算法描述HOG特征提取方法就是将一个image（你要检测的目标或者扫描窗口）： 1）灰度化（将图像看做一个x,y,z（灰度）的三维图像）； 2）采用Gamma校正法对输入图像进行颜色空间的标准化（归一化）；目的是调节图像的对比度，降低图像局部的阴影和光照变化所造成的影响，同时可以抑制噪音的干扰； 3）计......
  • m基于简化后的轻量级yolov4深度学习网络农作物检测算法matlab仿真
    1.算法描述        YOLOv4的深层网络包括SPP模块、PANet模块、YOLOHead模块和部分卷积，其主要作用是加强目标特征提取并获取预测结果。SPP模块的输入端和输出端各连接一个三次卷积块，每个三次卷积块包含2个1×1卷积和1个3×3卷积。PANet模块包含特征层堆......
  • Linux内存管理 (22)内存检测技术(slub_debug/kmemleak/kasan)【转】
    转自：https://www.cnblogs.com/arnoldlu/p/8568090.htmlLinux常见的内存访问错误有：越界访问(outofbounds)访问已经释放的内存(useafterfree)重复释放内存泄露(memoryleak)栈溢出(stackoverflow)不同的工具有不同的侧重点，本章主要从slub_debug、kmemleak、kasan三......
  • 华为OD机试 统计匹配的二元组个数
    本期题目：统计匹配的二元组个数题目给定两个数组A和B，若数组A的某个元素A[i]与数组B中的某个元素B[j]满足A[i]==B[j]，则寻找到一个匹配的二元组(i,j)，请统计再这两个数组A和B中，一共存在多少个这样的二元组。输入第一行输入数组A的长度M；第一行输入数组B的......
  • 深度学习经典网络模型汇总——LeNet、AlexNet、ZFNet、VGGNet、GoogleNet、ResNet【对
    文章目录LeNetAlexNetZFNetVGGNetGoogleNetResNet先来看一下我们要讲述哪些经典的网络模型，如下：LeNet：最早用于手写数字识别的CNN网络AlexNet：2012年ILSVRC比赛冠军，比LeNet层数更深，这是一个历史性突破。ZFNet：2013年ILSVRC比赛效果较好，和AlexNet类似。VGGNet：2014年ILSVRC比赛分类......
  • 匹配矩阵
    a<-matrix(c(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15),nrow=3,ncol=5)c<-matrix(c(2,3,3,3,3,4,4,4,4,8,8,8),nrow=3,ncol=4)rownames(a)<-c("aa","cc","kk")rownames(c)<-c("dd","cc","ee")&......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99