python使用svm，hog进行图像分类时，需要使用sklearn，skimage，numpy，matplotlib等。这些包如果版本不对应很难成功运行代码。

python3.6，numpy，matplotlib，scipy，sklearn匹配版本安装_Vertira的博客-CSDN博客先安装numpy，再安装scipy，再安装matplotlib这三个都是python3.6对应的版本。比较唯一，sk-learn 官网没有展示与python3.6对应的版本，但是使用清华源安装，可以安装到对应的版本。https://blog.csdn.net/Vertira/article/details/122317251用清华源安装，熟读更快

python 安装numpy,matplotlib 清华源快速安装_Vertira的博客-CSDN博客pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simplepip install matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simplehttps://blog.csdn.net/Vertira/article/details/122171528

svm_hog python源码下载地址

https://download.csdn.net/download/Vertira/74005192https://download.csdn.net/download/Vertira/74005192

下载的压缩文件及其解压后的文件

配置好各种包后，直接运行hog_svm.py（注意：把raw_input (这个是python2.0版本的)改成 input（这个是python3的））

运行后程序输出

 文件夹中的变化：

 多了几个文件夹和一个输出测试结果 result.txt. 上面三个文件夹中都有训练产生的特征和参数。

result.txt里面是预测的结果

欢迎各位客官，点赞，收藏，加关注。

目录

一、训练数据准备：cifar转图像操作

二、训练和验证部分

三、hog梯度图可视化

案例训练数据：cifar 10

图像下载地址（后面我们要用这批数据作为训练数据）：CIFAR-10 and CIFAR-100 datasetshttp://www.cs.toronto.edu/~kriz/cifar.html本文参考链接：HOG + SVM 进行图片分类（python）_程序员的点滴-CSDN博客_svm图片二分类pythonhttps://blog.csdn.net/q1242027878/article/details/74271694HOG的描述：

图像处理——梯度直方图HOG_lanling1996的博客-CSDN博客_梯度直方图                          图像处理之特征提取：HOG特征简单梳理              HOG方向梯度直方图，这里分解为方向梯度与直方图。 一、方向梯度 梯度：在向量微积分中，标量...https://blog.csdn.net/lanling1996/article/details/112589519HOG主要应用于行人检测方面，以行人照片为例：

一、训练数据准备：cifar转图像操作

案例操作中使用的训练数据是cifar10的数据，这里我们需要先把原始数据，转为图像数据，进行本地化保存，下载好数据后，进行转图操作，转图代码如下：

import cv2
import numpy as np
import os


def unpickle(file):
    import _pickle as cPickle
    with open(file, 'rb') as f:
        dict = cPickle.load(f, encoding='iso-8859-1')
    return dict


def main(cifar10_data_dir):
    train_txt=[]
    test_txt=[]
    for i in range(1, 2):
        train_data_file = os.path.join(cifar10_data_dir, 'data_batch_' + str(i))
        print(train_data_file)
        data = unpickle(train_data_file)
        print('unpickle done', data)
        for j in range(10000):
            img = np.reshape(data['data'][j], (3, 32, 32))
            img = img.transpose(1, 2, 0)
            img_name = 'train/' + str(data['labels'][j]) + '_' + str(j + (i - 1) * 10000) + '.jpg'
            cv2.imwrite(os.path.join(cifar10_data_dir, img_name), img)
            train_txt.append(str(data['labels'][j]) + '_' + str(j + (i - 1) * 10000) + '.jpg' + ' ' + str(data['labels'][j]))
    np.savetxt(r"./train.txt", np.reshape(train_txt, -1), delimiter=',', fmt='%5s')

    test_data_file = os.path.join(cifar10_data_dir, 'test_batch')
    data = unpickle(test_data_file)
    for i in range(10000):
        img = np.reshape(data['data'][i], (3, 32, 32))
        img = img.transpose(1, 2, 0)
        img_name = 'test/' + str(data['labels'][i]) + '_' + str(i) + '.jpg'
        cv2.imwrite(os.path.join(cifar10_data_dir, img_name), img)
        test_txt.append(str(data['labels'][i]) + '_' + str(i) + '.jpg' + ' ' + str(data['labels'][i]))
    np.savetxt(r"./test.txt", np.reshape(test_txt, -1), delimiter=',', fmt='%5s')


if __name__ == "__main__":
    main('cifar-10-batches-py')

如果遇到这个问题：

python 3以上版本使用pickle.load读取文件报UnicodeDecodeError: 'ascii' codec can't decode byte 0x8b in position 6

 可参考这里解决：python 3以上版本使用pickle.load读取文件报UnicodeDecodeError: 'ascii' codec can't decode byte 0x8b in position 6_IT人生-CSDN博客https://blog.csdn.net/qq_33144323/article/details/80042273

二、训练和验证部分

直接方代码，边训练边学习这段代码的含义，主要思路就是一下几点：

1. 原图转hog梯度图
2. 加载特征和标签进行训练
3. 测试评估

# -*- coding=utf-8 -*-
import glob
import platform
import time
from PIL import Image
from skimage.feature import hog
import numpy as np
import os
import joblib
from sklearn.svm import LinearSVC
import shutil
import sys

# 第一个是你的类别   第二个是类别对应的名称   输出结果的时候方便查看
label_map = {0: 'airplane',
             1: 'automobile',
             2: 'bird',
             3: 'cat',
             4: 'deer',
             5: 'dog',
             6: 'frog',
             7: 'horse',
             8: 'ship',
             9: 'truck,'
             }
# 训练集图片的位置
train_image_path = './database/train'
# 测试集图片的位置
test_image_path = './database/test'

# 训练集标签的位置
train_label_path = os.path.join('./labels', 'train.txt')
# 测试集标签的位置
test_label_path = os.path.join('./labels', 'test.txt')

image_height = 32
image_width = 32

train_feat_path = './feature/train/'
test_feat_path = './feature/test/'
model_path = 'model/'


# 获得图片列表
def get_image_list(filePath, nameList):
    print('read image from ', filePath)
    img_list = []
    for name in nameList:
        temp = Image.open(os.path.join(filePath, name))
        img_list.append(temp.copy())
        temp.close()
    return img_list


# 提取特征并保存
def get_feat(image_list, name_list, label_list, savePath):
    i = 0
    for image in image_list:
        try:
            # 如果是灰度图片  把3改为-1
            image = np.reshape(image, (image_height, image_width, -1))
        except:
            print('发送了异常，图片大小size不满足要求：', name_list[i])
            continue
        #gray = rgb2gray(image) / 255.0
        # 如果直接就是灰度图
        gray = image
        # 这句话根据你的尺寸改改
        fd = hog(gray, orientations=12, block_norm='L1', pixels_per_cell=[8, 8], cells_per_block=[4, 4], visualize=False,
                 transform_sqrt=True)
        fd = np.concatenate((fd, [label_list[i]]))
        fd_name = name_list[i] + '.feat'
        fd_path = os.path.join(savePath, fd_name)
        joblib.dump(fd, fd_path)
        i += 1
    print("Test features are extracted and saved.")


# 变成灰度图片
def rgb2gray(im):
    gray = im[:, :, 0] * 0.2989 + im[:, :, 1] * 0.5870 + im[:, :, 2] * 0.1140
    return gray


# 获得图片名称与对应的类别
def get_name_label(file_path):
    print("read label from ", file_path)
    name_list = []
    label_list = []
    with open(file_path) as f:
        for line in f.readlines():
            #一般是name label  三部分，所以至少长度为3  所以可以通过这个忽略空白行
            if len(line) >= 3:
                name_list.append(line.split(' ')[0])
                label_list.append(line.split(' ')[1].replace('\n','').replace('\r',''))
                if not str(label_list[-1]).isdigit():
                    print("label必须为数字，得到的是：",label_list[-1], "程序终止，请检查文件")
                    exit(1)
    return name_list, label_list


# 提取特征
def extra_feat():
    train_name, train_label = get_name_label(train_label_path)
    test_name, test_label = get_name_label(test_label_path)

    train_image = get_image_list(train_image_path, train_name)
    test_image = get_image_list(test_image_path, test_name)
    get_feat(train_image, train_name, train_label, train_feat_path)
    get_feat(test_image, test_name, test_label, test_feat_path)


# 创建存放特征的文件夹
def mkdir():
    if not os.path.exists(train_feat_path):
        os.mkdir(train_feat_path)
    if not os.path.exists(test_feat_path):
        os.mkdir(test_feat_path)


# 训练和测试
def train_and_test():
    t0 = time.time()
    features = []
    labels = []
    correct_number = 0
    total = 0
    for feat_path in glob.glob(os.path.join(train_feat_path, '*.feat')):
        data = joblib.load(feat_path)
        features.append(data[:-1])
        labels.append(data[-1])
    
    ############ 训练部分 ############
    """
    print("Training a Linear LinearSVM Classifier.")
    clf = LinearSVC()
    clf.fit(features, labels)
    # 下面的代码是保存模型的
    if not os.path.exists(model_path):
        os.makedirs(model_path)
    joblib.dump(clf, model_path + 'model')
    """

    ############ 训练完验证部分 ############
    # 下面的代码是加载模型  可以注释上面的代码   直接进行加载模型  不进行训练
    clf = joblib.load(model_path+'model')
    print("训练之后的模型存放在model文件夹中")
    # exit()
    result_list = []
    for feat_path in glob.glob(os.path.join(test_feat_path, '*.feat')):
        total += 1
        if platform.system() == 'Windows':
            symbol = '\\'
        else:
            symbol = '/'
        image_name = feat_path.split(symbol)[1].split('.feat')[0]
        data_test = joblib.load(feat_path)
        data_test_feat = data_test[:-1].reshape((1, -1)).astype(np.float64)
        result = clf.predict(data_test_feat)
        print(result)
        result_list.append(image_name + ' ' + str(result[0]) + '\n')
        if int(result[0]) == int(data_test[-1]):
            correct_number += 1
    write_to_txt(result_list)
    rate = float(correct_number) / total
    t1 = time.time()
    print('准确率是： %f' % rate)
    print('耗时是 : %f' % (t1 - t0))


def write_to_txt(list):
    with open('result.txt', 'w') as f:
        f.writelines(list)
    print('每张图片的识别结果存放在result.txt里面')


if __name__ == '__main__':

    mkdir()  # 不存在文件夹就创建
    # need_input = input('是否手动输入各个信息？y/n\n')

    if sys.version_info < (3,):
        need_extra_feat = input('是否需要重新获取特征？y/n\n')
    else:
        need_extra_feat = input('是否需要重新获取特征？y/n\n')

    if need_extra_feat == 'y':
        shutil.rmtree(train_feat_path)
        shutil.rmtree(test_feat_path)
        mkdir()
        extra_feat()

    train_and_test()

cifar10的训练和测试结果，如下：

是否需要重新获取特征？y/n
y
read label from  ./labels\train.txt
read label from  ./labels\test.txt
read image from  ./database/train
read image from  ./database/test
Test features are extracted and saved.
Test features are extracted and saved.
Training a Linear LinearSVM Classifier.
训练之后的模型存放在model文件夹中
每张图片的识别结果存放在result.txt里面
准确率是： 0.460400
耗时是 : 12.241030

三、hog梯度图可视化

直观的查看下hog梯度方向直方图的样式，以一张其它图像为例进行展示，你也可以替换为你自己的图像，如下：

from skimage.feature import hog
from skimage import io
from PIL import Image
import cv2

img = cv2.cvtColor(cv2.imread('./database/train_medical/DRCrop_3.png'), cv2.COLOR_BGR2GRAY)
print(img.shape)
normalised_blocks, hog_image = hog(img, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(8, 8),
                                   block_norm='L2-Hys', visualize=True)
io.imshow(hog_image)
io.show()

 参考文档：使用skimage提取图像hog特征_人工智能讲师团-CSDN博客_skimage.feature.hoghttps://blog.csdn.net/mago2015/article/details/85320347

网上看到关于用opencv对图像进行分类的不少，这次用MATLAB做了些尝试，图像数据集为:链接: https://pan.baidu.com/s/1i5OhC7z 密码: utn7，其他MATLAB版本http://blog.csdn.net/libin88211/article/details/19968205 ，点击打开链接，http://blog.csdn.net/jcy1009015337/article/details/53763484 另外opencv版本的为：点击打开链接，http://blog.csdn.net/always2015/article/details/47107129

废话就不说，直接上代码（适合MATLAB 2016b版本及以上），代码有相应注释。

我训练的图像在磁盘上位置如下，包含5个类别，省去了前人制作txt存储图像路径的过程：

测试图像分布为：

%% 用hog特征对图像进行多分类，svm训练，1 VS 1  
%% 1 数据集，包括训练的和测试的 (注意自己图片存放路径，附录我给出示例下载图片链接) 
imdsTrain = imageDatastore('F:\svm_images\train_images',...  
    'IncludeSubfolders',true,...  
    'LabelSource','foldernames');  
imdsTest = imageDatastore('F:\svm_images\test_image');  


%% 显示训练的图片种类Labels和数量Count
Train_disp = countEachLabel(imdsTrain);
disp(Train_disp);
  
%%   2 对训练集中的每张图像进行hog特征提取，测试图像一样  
% 预处理图像,主要是得到features特征大小，此大小与图像大小和Hog特征参数相关  
imageSize = [256,256];% 对所有图像进行此尺寸的缩放  
image1 = readimage(imdsTrain,1);  
scaleImage = imresize(image1,imageSize);  
[features, visualization] = extractHOGFeatures(scaleImage);  
imshow(scaleImage);hold on; plot(visualization)  
  
% 对所有训练图像进行特征提取  
numImages = length(imdsTrain.Files);  
featuresTrain = zeros(numImages,size(features,2),'single'); % featuresTrain为单精度  
for i = 1:numImages  
    imageTrain = readimage(imdsTrain,i);  
    imageTrain = imresize(imageTrain,imageSize);  
    featuresTrain(i,:) = extractHOGFeatures(imageTrain);  
end  
  
% 所有训练图像标签  
trainLabels = imdsTrain.Labels;  
  
% 开始svm多分类训练，注意：fitcsvm用于二分类，fitcecoc用于多分类,1 VS 1方法  
classifer = fitcecoc(featuresTrain,trainLabels);  
  
%% 预测并显示预测效果图  
numTest = length(imdsTest.Files);  
for i = 1:numTest  
    testImage = readimage(imdsTest,i);  
    scaleTestImage = imresize(testImage,imageSize);  
    featureTest = extractHOGFeatures(scaleTestImage);  
    [predictIndex,score] = predict(classifer,featureTest);  
    figure;imshow(testImage);  
    title(['predictImage: ',char(predictIndex)]);  
end  
  
    

命令行对训练集imdsTrain
统计输出结果如下：

第一张图像显示的是提取到的HOG特征，这个主要可以初步了解下特征是否选择的合适，不合适可以调节extractHOGFeatures里面的参数，如cellsize,blocksize,bins等，具体可以参考这个点击打开链接 http://cn.mathworks.com/help/vision/ref/extracthogfeatures.html?searchHighlight=extractHOGFeatures&s_tid=doc_srchtitle。本程序选择的默认参数，从图1可以预览到特征分别合适。