基于OpenCV的行人识别-SVM+HOG

文章目录

• 前言
• 一、opencv是什么？
• 二、步骤
  • 1.环境搭建
  • 2.了解SVM和HOG
  • 3.代码实现

---

前言

本文适用于刚刚入门学习的小白进行的基础操作，可以了解机器学习和计算机视觉的基本知识，需要一定的python语言基础。使用opencv帮助实现行人检测，了解SVM和HOG在机器学习中的使用

---

推荐安装 pycharm 2021版本

一、OpenCV是什么？

OpenCV 是一个基于 BSD 许可（开源）发行的跨平台计算机视觉和机器学习软件库，可以运行在Linux 、 Windows 、 Android 和 Mac OS操作系统上 ，它轻量级而且高效，由一系列 C 函数和少量 C++ 类构成，同时提供了Python、Ruby、MATLAB等语言的接口， 实现了图像处理和计算机视觉方面的很多通用算法。

二、步骤

1.环境搭建

先在pycharm中找到python解释器，安装相关的插件。

首先点击设置，在左上角的文件里：

 然后找到解释器：

 先确定解释器版本，我这里用的是3.7版本，然后点击下面的加号，开始安装插件；

 搜索输入opencv-python，在列表里找到后选中；

点击在左下角的安装包，等待成功安装。

 

 2.了解SVM和HOG

SVM（Support Vector Machine）支持向量机，是常见的一种判别方法。在机器学习领域，是一个有监督的学习模型，通常用来进行模式识别、分类以及回归分析, 在行人检测中可以用作区分行人和非行人的分类器，并进行数据建模，实现行人识别，对结果进行评估。

训练SVM：相对于其他训练分类算法不需要过多样本，并且由于 SVM引入了核函数，所以SVM可以处理高维样本。SVM擅长应付样本数据线性不可分的情况，通过松弛变量（也叫惩罚变量）和核函数技术来实现非线性分类，不需要过多样本，结构风险比较小；

HOG(Histogram of Oriented Gradient)方向梯度直方图特征是一种在计算机视觉和图像处理中用来进行物体检测的特征描述子。HOG特征通过计算和统计图像局部区域的梯度方向直方图来构成特征，每一幅画面的特征都不同，而HOG就是用来描述这些特征的。

计算HOG特征：检测窗口，归一化图像，计算梯度。对于每一个cell块对梯度直方图进行规定权重的投影，对于每一个重叠 block块内的cell进行对比度归一化，把所有block内的直方图向量一起组合成一个大的HOG特征向量；

3.代码实现

首先用SVM，提前准备好一些行人的照片当做机器学习的材料， 代码如下；

在我上传的资源里面有大约900张收集好的行人照片，需要的朋友可以看一下(*^▽^*)

链接基于opencv的行人识别项目_opencv行人检测-机器学习文档类资源-CSDN下载

import cv2
import numpy as np
import random

def load_images(dirname, amout=999):
    img_list = []
    file = open(dirname)
    img_name = file.readline()
    while img_name != '':  # 文件尾
        img_name = dirname.rsplit(r'/', 1)[0] + '/' + img_name.split('/', 1)[1].strip('\n')
        img_list.append(cv2.imread(img_name))
        img_name = file.readline()
        amout -= 1
        if amout <= 0:  # 控制读取图片的数量
            break
    return img_list

# 从每一张没有人的原始图片中随机裁出10张64*128的图片作为负样本
def sample_neg(full_neg_lst, neg_list, size):
    random.seed(1)
    width, height = size[1], size[0]
    for i in range(len(full_neg_lst)):
        for j in range(10):
            y = int(random.random() * (len(full_neg_lst[i]) - height))
            x = int(random.random() * (len(full_neg_lst[i][0]) - width))
            neg_list.append(full_neg_lst[i][y:y + height, x:x + width])
    return neg_list


# wsize: 处理图片大小，通常64*128; 输入图片尺寸>= wsize
def computeHOGs(img_lst, gradient_lst, wsize=(128, 64)):
    hog = cv2.HOGDescriptor()
    # hog.winSize = wsize
    for i in range(len(img_lst)):
        if img_lst[i].shape[1] >= wsize[1] and img_lst[i].shape[0] >= wsize[0]:
            roi = img_lst[i][(img_lst[i].shape[0] - wsize[0]) // 2: (img_lst[i].shape[0] - wsize[0]) // 2 + wsize[0], \
                  (img_lst[i].shape[1] - wsize[1]) // 2: (img_lst[i].shape[1] - wsize[1]) // 2 + wsize[1]]
            gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
            gradient_lst.append(hog.compute(gray))


def get_svm_detector(svm):
    sv = svm.getSupportVectors()
    rho, _, _ = svm.getDecisionFunction(0)
    sv = np.transpose(sv)
    return np.append(sv, [[-rho]], 0)


# 主程序
# 第一步：计算HOG特征
neg_list = []
pos_list = []
gradient_lst = []
labels = []
hard_neg_list = []
svm = cv2.ml.SVM_create() #创建SVM model
pos_list = load_images('D:/Desktop/INRIAPerson/96X160H96/Train/pos2.lst') # 文件的路径不同
full_neg_lst = load_images('D:/Desktop/INRIAPerson/train/neg.lst')
sample_neg(full_neg_lst, neg_list, [128, 64])
# 从每一张没有人的原始图片中随机裁出10张64*128的图片作为负样本
print(len(pos_list))
print(len(neg_list))
computeHOGs(pos_list, gradient_lst) # wsize: 处理图片大小，通常64*128; 输入图片尺寸>= wsize
[labels.append(+1) for _ in range(len(pos_list))]
computeHOGs(neg_list, gradient_lst)
[labels.append(-1) for _ in range(len(neg_list))]

# 第二步：训练SVM
svm.setType(cv2.ml.SVM_EPS_SVR) #支持向量回归机
svm.setDegree(3)
svm.setKernel(cv2.ml.SVM_LINEAR)
svm.setGamma(0)
svm.setCoef0(0.0)
#迭代终止条件
criteria = (cv2.TERM_CRITERIA_MAX_ITER + cv2.TERM_CRITERIA_EPS, 1000, 1e-3)
svm.setTermCriteria(criteria)

svm.setNu(0.5)
svm.setP(0.1)  # for EPSILON_SVR, epsilon in loss function?
#优化参数 惩罚系数
svm.setC(0.1)  # From paper, soft classifier

svm.train(np.array(gradient_lst), cv2.ml.ROW_SAMPLE, np.array(labels))

# 第三步：加入识别错误的样本，进行第二轮训练
hog = cv2.HOGDescriptor()
hard_neg_list.clear()
hog.setSVMDetector(get_svm_detector(svm))
for i in range(len(full_neg_lst)):
    rects, wei = hog.detectMultiScale(full_neg_lst[i], winStride=(4, 4), padding=(8, 8), scale=1.05)
    for (x, y, w, h) in rects:
        hardExample = full_neg_lst[i][y:y + h, x:x + w]
        hard_neg_list.append(cv2.resize(hardExample, (64, 128)))
computeHOGs(hard_neg_list, gradient_lst)
[labels.append(-1) for _ in range(len(hard_neg_list))]
svm.train(np.array(gradient_lst), cv2.ml.ROW_SAMPLE, np.array(labels))

# 第四步：保存训练结果
hog.setSVMDetector(get_svm_detector(svm))
hog.save('myHogDector.bin')
print('success')

注意文件的获取路径，成功获取到训练集照片；

运行成功后得到myHogDector.bin文件，可在pycharm里面打开查看，如下只截取一部分：

---

 第二段程序是用已生成的myHogDector.bin文件，测试一段视频，注意文件的路径

import cv2
import numpy as np


def load_images(dirname, laber, amout=999):
    img_list = []
    laber_list = []
    file = open(dirname)
    img_name = file.readline()
    while img_name != '':  # 文件尾
        img_name = dirname.rsplit(r'/', 1)[0] + r'/' + img_name.split('/', 1)[1].strip('\n')
        img_list.append(cv2.imread(img_name))
        laber_list.append(laber)
        img_name = file.readline()
        amout -= 1
        if amout <= 0:  # 控制读取图片的数量
            break
    return img_list, laber_list


hog = cv2.HOGDescriptor() # 初始化
hog.load('myHogDector.bin')
# 定义对象hog，同时输入定义的参数
# 测试数据图片
pos_list, pos_laber = load_images(r'D:/Desktop/INRIAPerson/Test/pos.lst', +1) #注意文件路径
neg_list, neg_laber = load_images('D:/Desktop/INRIAPerson/Test/neg.lst', -1)
predic = 0
for i in range(len(pos_list)):
    grey = cv2.cvtColor(pos_list[i], cv2.COLOR_BGR2GRAY)
    (body, weights) = hog.detectMultiScale(grey)
    if len(body) > 0:
        predic += 1
for i in range(len(neg_list)):
    grey = cv2.cvtColor(neg_list[i], cv2.COLOR_BGR2GRAY)
    (body, weights) = hog.detectMultiScale(grey)
    if len(body) == 0:
        predic += 1
print('Percentage Accuracy: %.2f %%' % (predic / (len(pos_list) + len(neg_list)) * 100))

# 测试avi视频
cap = cv2.VideoCapture('D:/Desktop/walking.avi')
while cap.isOpened():
    ret, frame = cap.read()
    if ret == False:
        break
    grey = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # 图像灰度化
    # body = body_classifier.detectMultiScale(grey, 1.1, 1)
    (body, weights) = hog.detectMultiScale(grey)
    for (x, y, w, h) in body:
        frame = cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 10), 2)
    cv2.imshow('body', frame)
    if cv2.waitKey(5) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

 最后输出结果如下：