基于 HOG 特征与 SVM 的目标检测实现及 Python 代码

注意：

1. HOG 参数：HOG 有多个参数，包括窗口大小、块（block）大小、单元格（cell）大小等。这些参数同时影响边界框的尺寸和宽高比。如果候选框的尺寸不同，可能需要进行尺寸调整。
2. 旋转敏感性：HOG 对图像旋转非常敏感，因此如果图像发生倾斜，提取的特征向量可能不适用于目标检测。
3. 同一对象的差异性：即便是同一个目标，不同的边界框也可能生成不同的 HOG 向量。因此，需要借助机器学习模型判断目标是否被正确检测到。

数据集-VOC

<!-- 典型 Pascal VOC 标注文件结构 -->
<annotation>
    <folder>VOC2012</folder>
    <filename>2007_000027.jpg</filename><!-- ← 从这里提取 -->
    <size>
        <width>486</width>
        <height>500</height>
        <depth>3</depth>
    </size>
    <object><!-- ← 每个 object 标签对应一个目标 -->
        <name>person</name><!-- ← 目标类别 -->
        <bndbox><!-- ← 边界框坐标（关键！） -->
            <xmin>174</xmin><!-- ← 提取 -->
            <ymin>101</ymin><!-- ← 提取 -->
            <xmax>349</xmax><!-- ← 提取 -->
            <ymax>351</ymax><!-- ← 提取 -->
        </bndbox>
    </object>
    <object><!-- 可以有多个 object --></object>
</annotation>

提取关键信息

import xml.etree.ElementTree as ET

def read_voc_xml(xmlfile):
    root = ET.parse(xmlfile).getroot()
    boxes = {"filename": root.find("filename").text, "objects": []}
    for box in root.iter('object'):
        bb = box.find('bndbox')
        obj = {
            "name": box.find('name').text,
            "xmin": int(bb.find("xmin").text),
            "ymin": int(bb.find("ymin").text),
            "xmax": int(bb.find("xmax").text),
            "ymax": int(bb.find("ymax").text),
        }
        boxes["objects"].append(obj)
    return boxes

Hog 特征提取与 SVM 训练

import xml.etree.ElementTree as ET
import glob
import cv2
import random
import sklearn.svm as svm
import pickle
import numpy as np
import time

def make_square(xmin, xmax, ymin, ymax):
    # 辅助函数示例，实际需根据需求实现确保正方形
    size = max(xmax - xmin, ymax - ymin)
    cx, cy = (xmin + xmax) // 2, (ymin + ymax) // 2
    return cx - size // 2, cx + size // 2, cy - size // 2, cy + size // 2

if __name__ == "__main__":
    data_path = 'F:\\ObjectDetection\\oxford-iiit-pet\\annotations\\xmls\\'
    data_xmls = glob.glob(data_path + '*.xml')
    img_path = 'F:\\ObjectDetection\\oxford-iiit-pet\\images\\'
    
    winSize = (64, 64)
    blockSize = (32, 32)
    blockStride = (16, 16)
    cellSize = (16, 16)
    nbins = 9
    num_samples = 10000
    positive = []  # 猫
    negative = []  # 其他动物

    for xml in data_xmls:
        result = read_voc_xml(xml)
        if not result['objects'] or result['objects'][0]['name'] != 'cat':
            continue
        object_data = result['objects'][0]
        img = cv2.imread(img_path + result['filename'])
        xmin, xmax, ymin, ymax = object_data["xmin"], object_data["xmax"], object_data["ymin"], object_data["ymax"]
        xmin, xmax, ymin, ymax = make_square(xmin, xmax, ymin, ymax)
        sample = img[ymin:ymax, xmin:xmax]
        sample = cv2.resize(sample, winSize)
        positive.append(sample)
        if len(positive) >= num_samples:
            print('--------- positive success ---------')
            break

    for xmlfile in data_xmls:
        result = read_voc_xml(xmlfile)
        if not result['objects'] or result["objects"][0]["name"] == "cat":
            continue
        object_data = result['objects'][0]
        img = cv2.imread(img_path + result['filename'])
        height, width = img.shape[:2]
        boxsize = random.randint(winSize[0], min(height, width))
        x = random.randint(0, width - boxsize)
        y = random.randint(0, height - boxsize)
        sample = img[y:y + boxsize, x:x + boxsize]
        sample = cv2.resize(sample, winSize)
        negative.append(sample)
        if len(negative) >= num_samples:
            print('--------- negative success ---------')
            break

    images = positive + negative
    labels = ([1] * len(positive) + [0] * len(negative))
    
    hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins)
    data = []
    for img in images:
        features = hog.compute(img)
        data.append(features.flatten())
    data = np.array(data, dtype=np.float32)
    labels = np.array(labels, dtype=np.int32)
    
    print('--------- svm start ---------')
    ts = time.time()
    svm_model = cv2.ml.SVM_create()
    svm_model.setType(cv2.ml.SVM_C_SVC)  # 用于设置 SVM 的模型类型，决定 SVM 适用的任务场景，引入惩罚参数 C（后续可额外配置），允许少量样本违反间隔约束，用于解决线性不可分问题，提升模型的泛化能力。
    svm_model.setKernel(cv2.ml.SVM_RBF)  # 核函数的作用是将低维线性不可分的数据映射到高维空间，使其在高维空间中线性可分；径向基函数（Radial Basis Function），也称为高斯核，是最常用的非线性核函数
    svm_model.setTermCriteria((cv2.TERM_CRITERIA_MAX_ITER + cv2.TERM_CRITERIA_EPS, 100000, 1e-8))  # 设置 SVM 训练过程的终止条件；「最大迭代次数」或「精度收敛」任一条件即终止
    svm_model.train(data, cv2.ml.ROW_SAMPLE,  # 指定样本数据的组织格式，表示每一行对应一个训练样本，每一列对应一个特征（这是最常用的数据组织方式，符合大多数人的数据预处理习惯
                    labels)
    te = time.time() - ts
    
    # 保存模型
    svm_model.save('F:\\ObjectDetection\\save_model\\svm_model.yml')
    print(svm_model.getSupportVectors().shape)
    print('--------- svm end ---------')
    print('fit time: {}s'.format(te))

测试代码

import glob
import cv2
import xml.etree.ElementTree as ET

def read_voc_xml(xmlfile):
    root = ET.parse(xmlfile).getroot()
    boxes = {"filename": root.find("filename").text, "objects": []}
    for box in root.iter('object'):
        bb = box.find('bndbox')
        obj = {
            "name": box.find('name').text,
            "xmin": int(bb.find("xmin").text),
            "ymin": int(bb.find("ymin").text),
            "xmax": int(bb.find("xmax").text),
            "ymax": int(bb.find("ymax").text),
        }
        boxes["objects"].append(obj)
    return boxes

if __name__ == "__main__":
    data_path = 'F:\\ObjectDetection\\oxford-iiit-pet\\annotations\\xmls\\'
    data_xmls = glob.glob(data_path + '*.xml')
    img_path = 'F:\\ObjectDetection\\oxford-iiit-pet\\images\\'
    model_path = 'F:\\ObjectDetection\\save_model\\svm_model.yml'
    
    winSize = (64, 64)  # 检测从窗口大小，即每次提取 HOG 特征的图像块大小，训练的时候是将图像按照标注提取出目标区域 resize 到 winSize
    blockSize = (32, 32)  # 块大小，HOG 特征以块为单位进行归一化，减少光照等因素影响
    blockStride = (16, 16)  # 快步长，相邻块之间的偏移量，决定了块的覆盖密度
    cellSize = (16, 16)  # 细胞单元大小，每个细胞单元内计算梯度方向直方图
    nbins = 9  # 梯度方向直方图的分箱树，即把 0~180°（或 0~360°）梯度方向划分为 9 个区间，统计每个区间的梯度幅值
    
    svm_model = cv2.ml.SVM_load(model_path)
    hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins)
    
    # 创建 HOG 特征描述符实例
    hog.setSVMDetector(svm_model.getSupportVectors()[0])  # SVM 模型的支持向量设置为 HOG 检测器的分类器，让 HOG 提取特征后可直接用该 SVM 进行目标分类/检测
    
    for data_xml in data_xmls[:5]:
        result = read_voc_xml(data_xml)
        img = cv2.imread(img_path + result['filename'])
        bbox = result['objects'][0]
        start_point = (bbox['xmin'], bbox['ymin'])  # 真实框左上角坐标
        end_point = (bbox['xmax'], bbox['ymax'])  # 真实框右下角坐标
        annotated_img = cv2.rectangle(img, start_point, end_point, (0, 0, 255))  # 绘制矩形框，参数依次是「图片」「左上角坐标」「右下角坐标」「颜色（BGR 格式，(0,0,255) 对应红色）」，默认线宽为 1
        
        locations, scores = hog.detectMultiScale(img)  # 用 HOG+SVM 对图片进行多尺度目标检测，自动缩放图片；locations：所有检测到的目标边界框坐标 (x, y, w, h) 左上坐标 + 宽高，scores：对应每个检测框的置信度得分，得分越高，检测结果越可靠。
        
        # ------------ 选择置信度最高的------------
        # x, y, w, h = locations[np.argmax(scores.flatten())]  # 选取检测得分最高的边界框（取 scores 最大值对应的位置）
        # cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 5)
        # cv2.imshow(f"{result['filename']}: {result['objects'][0]['name']}", annotated_img)
        # key = cv2.waitKey(0)
        # cv2.destroyAllWindows()
        # if key == ord('q'):
        #     break
        
        # ------------ 使用 NMS ------------
        boxes = locations.tolist()
        confidences = scores.flatten().tolist()
        indices = cv2.dnn.NMSBoxes(boxes, confidences, score_threshold=0.5,  # 信度阈值：过滤掉得分低于 0.5 的低质量框
                                   nms_threshold=0.3)  # IOU 阈值：重叠度超过 0.3 的框，保留得分最高的，去除其他
        
        if len(indices) > 0:
            # 兼容 OpenCV 返回格式，提取有效索引
            indices = indices.flatten()
            # 取第一个最优框（也可遍历所有筛选后的框）
            best_idx = indices[0]
            x, y, w, h = boxes[best_idx]
            # 绘制筛选后的检测框
            cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 5)
            cv2.imshow(f"{result['filename']}: {result['objects'][0]['name']}", annotated_img)
            key = cv2.waitKey(0)
            cv2.destroyAllWindows()
            if key == ord('q'):
                break