精华内容
下载资源
问答
  • OpenCV-Python实战(番外篇)——利用 SVM 算法识别手写数字
    千次阅读 多人点赞
    2021-09-22 13:52:55

    OpenCV-Python实战(番外篇)——利用 SVM 算法识别手写数字

    前言

    支持向量机 (Support Vector Machine, SVM) 是一种监督学习技术,它通过根据指定的类对训练数据进行最佳分离,从而在高维空间中构建一个或一组超平面。在博文《OpenCV-Python实战(13)——OpenCV与机器学习的碰撞》中,我们已经学习了如何在 OpenCV 中实现和训练 SVM 算法,同时通过简单的示例了解了如何使用 SVM 算法。在本文中,我们将学习如何使用 SVM 分类器执行手写数字识别,同时也将探索不同的参数对于模型性能的影响,以获取具有最佳性能的 SVM 分类器。

    使用 SVM 进行手写数字识别

    我们已经在

    更多相关内容
  • 本程序有三个cpp文件,main.cpp为测试文件;prepare.cpp为预处理文件;train_SVMSVM的训练文件。详情可参考博客:https://blog.csdn.net/didi_ya/article/details/114362904
  • SVM 实现MNIST手写数字图像识别的数据集 来源于网络,大家可以自行下载
  • 今晚加班到快通宵了,困得快睁不开眼了,女上司很关心,问我要不要吃宵夜。我没好气地说,宵夜就算了,能让我睡...from sklearn import datasets, svm, metrics ## 设置属性防止中文乱码 mpl.rcParams['font.sans-ser

    今晚加班到快通宵了,困得快睁不开眼了,女上司很关心,问我要不要吃宵夜。我没好气地说,宵夜就算了,能让我睡一觉就行了。女上司红着脸说了句讨厌啊,然后坐在我身边不动,好像距离我很近,搞得我很紧张,难道她发现我的程序出了bug?
    在这里插入图片描述

    import matplotlib as mpl
    import matplotlib.pyplot as plt
    
    from sklearn import datasets, svm, metrics
    
    ## 设置属性防止中文乱码
    mpl.rcParams['font.sans-serif'] = [u'SimHei']
    mpl.rcParams['axes.unicode_minus'] = False
    
    ## 加载数字图片数据
    digits = datasets.load_digits()
    digits
    
    
    ## 设置属性防止中文乱码
    mpl.rcParams['font.sans-serif'] = [u'SimHei']
    mpl.rcParams['axes.unicode_minus'] = False
    ## 设置属性防止中文乱码
    mpl.rcParams['font.sans-serif'] = [u'SimHei']
    mpl.rcParams['axes.unicode_minus'] = False
    ## 加载数字图片数据
    digits = datasets.load_digits()
    digits
    ## 加载数字图片数据
    digits = datasets.load_digits()
    digits
    

    {‘DESCR’: “Optical Recognition of Handwritten Digits Data Set\n===================================================\n\nNotes\n-----\nData Set Characteristics:\n :Number of Instances: 5620\n :Number of Attributes: 64\n :Attribute Information: 8x8 image of integer pixels in the range 0…16.\n :Missing Attribute Values: None\n :Creator: E. Alpaydin (alpaydin ‘@’ boun.edu.tr)\n :Date: July; 1998\n\nThis is a copy of the test set of the UCI ML hand-written digits datasets\nhttp://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits\n\nThe data set contains images of hand-written digits: 10 classes where\neach class refers to a digit.\n\nPreprocessing programs made available by NIST were used to extract\nnormalized bitmaps of handwritten digits from a preprinted form. From a\ntotal of 43 people, 30 contributed to the training set and different 13\nto the test set. 32x32 bitmaps are divided into nonoverlapping blocks of\n4x4 and the number of on pixels are counted in each block. This generates\nan input matrix of 8x8 where each element is an integer in the range\n0…16. This reduces dimensionality and gives invariance to small\ndistortions.\n\nFor info on NIST preprocessing routines, see M. D. Garris, J. L. Blue, G.\nT. Candela, D. L. Dimmick, J. Geist, P. J. Grother, S. A. Janet, and C.\nL. Wilson, NIST Form-Based Handprint Recognition System, NISTIR 5469,\n1994.\n\nReferences\n----------\n - C. Kaynak (1995) Methods of Combining Multiple Classifiers and Their\n Applications to Handwritten Digit Recognition, MSc Thesis, Institute of\n Graduate Studies in Science and Engineering, Bogazici University.\n - E. Alpaydin, C. Kaynak (1998) Cascading Classifiers, Kybernetika.\n - Ken Tang and Ponnuthurai N. Suganthan and Xi Yao and A. Kai Qin.\n Linear dimensionalityreduction using relevance weighted LDA. School of\n Electrical and Electronic Engineering Nanyang Technological University.\n 2005.\n - Claudio Gentile. A New Approximate Maximal Margin Classification\n Algorithm. NIPS. 2000.\n”,
    ‘data’: array([[ 0., 0., 5., …, 0., 0., 0.],
    [ 0., 0., 0., …, 10., 0., 0.],
    [ 0., 0., 0., …, 16., 9., 0.],
    …,
    [ 0., 0., 1., …, 6., 0., 0.],
    [ 0., 0., 2., …, 12., 0., 0.],
    [ 0., 0., 10., …, 12., 1., 0.]]),
    ‘images’: array([[[ 0., 0., 5., …, 1., 0., 0.],
    [ 0., 0., 13., …, 15., 5., 0.],
    [ 0., 3., 15., …, 11., 8., 0.],
    …,
    [ 0., 4., 11., …, 12., 7., 0.],
    [ 0., 2., 14., …, 12., 0., 0.],
    [ 0., 0., 6., …, 0., 0., 0.]],

        [[ 0.,  0.,  0., ...,  5.,  0.,  0.],
         [ 0.,  0.,  0., ...,  9.,  0.,  0.],
         [ 0.,  0.,  3., ...,  6.,  0.,  0.],
         ...,
         [ 0.,  0.,  1., ...,  6.,  0.,  0.],
         [ 0.,  0.,  1., ...,  6.,  0.,  0.],
         [ 0.,  0.,  0., ..., 10.,  0.,  0.]],
    
        [[ 0.,  0.,  0., ..., 12.,  0.,  0.],
         [ 0.,  0.,  3., ..., 14.,  0.,  0.],
         [ 0.,  0.,  8., ..., 16.,  0.,  0.],
         ...,
         [ 0.,  9., 16., ...,  0.,  0.,  0.],
         [ 0.,  3., 13., ..., 11.,  5.,  0.],
         [ 0.,  0.,  0., ..., 16.,  9.,  0.]],
    
        ...,
    
        [[ 0.,  0.,  1., ...,  1.,  0.,  0.],
         [ 0.,  0., 13., ...,  2.,  1.,  0.],
         [ 0.,  0., 16., ..., 16.,  5.,  0.],
         ...,
         [ 0.,  0., 16., ..., 15.,  0.,  0.],
         [ 0.,  0., 15., ..., 16.,  0.,  0.],
         [ 0.,  0.,  2., ...,  6.,  0.,  0.]],
    
        [[ 0.,  0.,  2., ...,  0.,  0.,  0.],
         [ 0.,  0., 14., ..., 15.,  1.,  0.],
         [ 0.,  4., 16., ..., 16.,  7.,  0.],
         ...,
         [ 0.,  0.,  0., ..., 16.,  2.,  0.],
         [ 0.,  0.,  4., ..., 16.,  2.,  0.],
         [ 0.,  0.,  5., ..., 12.,  0.,  0.]],
    
        [[ 0.,  0., 10., ...,  1.,  0.,  0.],
         [ 0.,  2., 16., ...,  1.,  0.,  0.],
         [ 0.,  0., 15., ..., 15.,  0.,  0.],
         ...,
         [ 0.,  4., 16., ..., 16.,  6.,  0.],
         [ 0.,  8., 16., ..., 16.,  8.,  0.],
         [ 0.,  1.,  8., ..., 12.,  1.,  0.]]]),
    

    ‘target’: array([0, 1, 2, …, 8, 9, 8]),
    ‘target_names’: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])}

    ## 获取样本数量,并将图片数据格式化(要求所有图片的大小、像素点都是一致的 => 转换成为的向量大小是一致的)
    n_samples = len(digits.images)
    data = digits.images.reshape((n_samples, -1))
    data.shape
    

    (1797, 64)

    ## 模型构建
    classifier = svm.SVC(gamma=0.001)#默认是rbf
    # from sklearn.neighbors import KNeighborsClassifier
    # classifier = KNeighborsClassifier(n_neighbors=9, weights='distance')
    ## 使用二分之一的数据进行模型训练
    ##取前一半数据训练,后一半数据测试
    classifier.fit(data[:int(n_samples / 2)], digits.target[:int(n_samples / 2)])
    

    SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape=None, degree=3, gamma=0.001, kernel=‘rbf’,
    max_iter=-1, probability=False, random_state=None, shrinking=True,
    tol=0.001, verbose=False)

    ## 测试数据部分实际值和预测值获取
    ##后一半数据作为测试集
    expected = digits.target[int(n_samples/2):] ##y_test
    predicted = classifier.predict(data[int(n_samples / 2):])##y_predicted
    ## 计算准确率
    print("分类器%s的分类效果:\n%s\n"
          % (classifier, metrics.classification_report(expected, predicted)))
    ##生成一个分类报告classification_report
    print("混淆矩阵为:\n%s" % metrics.confusion_matrix(expected, predicted))
    ##生成混淆矩阵
    print("score_svm:\n%f" %classifier.score(data[int(n_samples / 2):], digits.target[int(n_samples / 2):]))
    

    分类器SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape=None, degree=3, gamma=0.001, kernel=‘rbf’,
    max_iter=-1, probability=False, random_state=None, shrinking=True,
    tol=0.001, verbose=False)的分类效果:
    precision recall f1-score support

          0       1.00      0.99      0.99        88
          1       0.99      0.97      0.98        91
          2       0.99      0.99      0.99        86
          3       0.98      0.87      0.92        91
          4       0.99      0.96      0.97        92
          5       0.95      0.97      0.96        91
          6       0.99      0.99      0.99        91
          7       0.96      0.99      0.97        89
          8       0.94      1.00      0.97        88
          9       0.93      0.98      0.95        92
    

    avg / total 0.97 0.97 0.97 899

    混淆矩阵为:
    [[87 0 0 0 1 0 0 0 0 0]
    [ 0 88 1 0 0 0 0 0 1 1]
    [ 0 0 85 1 0 0 0 0 0 0]
    [ 0 0 0 79 0 3 0 4 5 0]
    [ 0 0 0 0 88 0 0 0 0 4]
    [ 0 0 0 0 0 88 1 0 0 2]
    [ 0 1 0 0 0 0 90 0 0 0]
    [ 0 0 0 0 0 1 0 88 0 0]
    [ 0 0 0 0 0 0 0 0 88 0]
    [ 0 0 0 1 0 1 0 0 0 90]]
    score_svm:
    0.968854

    ## 进行图片展示
    plt.figure(facecolor='gray', figsize=(12,5))
    ## 先画出5个预测失败的
    ##把预测错的值的 x值 y值 和y的预测值取出
    images_and_predictions = list(zip(digits.images[int(n_samples / 2):][expected != predicted], expected[expected != predicted], predicted[expected != predicted]))
    ##通过enumerate,分别拿出x值 y值 和y的预测值的前五个,并画图
    for index,(image,expection, prediction) in enumerate(images_and_predictions[:5]):
        plt.subplot(2, 5, index + 1)
        plt.axis('off')                          
        plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')#把cmap中的灰度值与image矩阵对应,并填充
        plt.title(u'预测值/实际值:%i/%i' % (prediction, expection))
    ## 再画出5个预测成功的
    images_and_predictions = list(zip(digits.images[int(n_samples / 2):][expected == predicted], expected[expected == predicted], predicted[expected == predicted]))
    for index, (image,expection, prediction) in enumerate(images_and_predictions[:5]):
        plt.subplot(2, 5, index + 6)
    #     plt.axis('off')
        plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
        plt.title(u'预测值/实际值:%i/%i' % (prediction, expection))
    
    plt.subplots_adjust(.04, .02, .97, .94, .09, .2)
    plt.show()
    

    在这里插入图片描述

    展开全文
  • 我看很多博主都是很老的MATLAB版本了,这里用了高版本的函数fitcecoc进行SVM多分类 下载链接https://download.csdn.net/download/qq_45047246/63960845?spm=1001.2014.3001.5503 clc; clear all; % load data x_...

    我看很多博主都是很老的MATLAB版本了,这里用了高版本的函数fitcecoc进行SVM多分类

    下载链接https://download.csdn.net/download/qq_45047246/63960845?spm=1001.2014.3001.5503

    clc;
    clear all;
    
    % load data
    x_train=LoadMNISTImages('train-images-idx3-ubyte');
    x_test=LoadMNISTImages('t10k-images-idx3-ubyte');
    y_train=LoadMNISTLabels('train-labels-idx1-ubyte');
    y_test=LoadMNISTLabels('t10k-labels-idx1-ubyte');
     
    % After transposing, each image becomes a number * pixel matrix
    x_train=x_train';
    x_test=x_test';
    %% SVM
    t = templateSVM('Standardize',true)
    SVMMdl = fitcecoc(x_train,y_train,'Learners',t,...
        'ClassNames',{'0','1','2','3','4','5','6','7','8','9'});
    predict_label = predict(SVMMdl,x_test);
    
    s=0;
    for i=1:length(predict_label)
        if str2double(predict_label(i))==y_test(i)
            s=s+1;
        end
    end
    acc=s/length(predict_label)
    figure
    plot(str2double(predict_label),'b*')
    hold on;
    plot(y_test,'ro')
    hold on;
    legend('predict_label','real_label')
    title('SVM Model')
    figure
    confusionchart(str2double(predict_label)',y_test')
    title('SVM Model Confusion matrix')
    

    参考其他博主的加载数据的函数

    function labels = LoadMNISTLabels(filename)
    % read label
    
    fp = fopen(filename,'rb');% Read files in binary mode
    assert(fp~=-1,['Could not open',filename,'']); 
    magic = fread(fp,1,'int32',0,'ieee-be');% Read data from binary file
    assert(magic==2049,['Bad magic number in',filename,'']);
    
     
    numlabels = fread(fp,1,'int32',0,'ieee-be');% Number of labels obtained
     
    labels = fread(fp,inf,'unsigned char');
     
    assert(size(labels,1)==numlabels,'Mismatch in label count');
    
    fclose(fp);% Close file
     
    end
     
    
    function images = LoadMNISTImages(filename)
    % Read image data in data
    
     
    fp = fopen(filename,'rb');% Read files in binary mode
    assert(fp~=-1,['Could not open',filename,'']);
    % assertFunction to determine whether the conditions are met. If the conditions are not 
    % met, an error message is reported
     
    magic = fread(fp,1,'int32',0,'ieee-be');% Read data from binary file
    
    assert(magic==2051,['Bad magic number in',filename,'']);
    %In MNIST image dataset, if the magic value is 2051, an error will be reported if it is 
    % not 2051
     
    numimages = fread(fp,1,'int32',0,'ieee-be');% Number of images obtained
    numrows = fread(fp,1,'int32',0,'ieee-be');% row
    numcols = fread(fp,1,'int32',0,'ieee-be');% column
     
    images = fread(fp,inf,'unsigned char');
    % Read all the remaining pixel data with the precision of "unsigned char" and store it in % the column vector images
    images = reshape(images,numcols,numrows, numimages);
    
    images = permute(images,[2 1 3]);
    % Rearrange the dimensions of the previous three-dimensional array to obtain a three-
    % dimensional matrix composed of all image data with 28 * 28 * number of images
     
    fclose(fp);% Close file
     
    images = reshape(images,size(images,1)*size(images,2),size(images,3));
    % Convert to two-dimensional vector
    images = double(images/255);
    % convert to double and rescale to [0,1] 
    end
     
    
    展开全文
  • 前言 支持向量机 (Support Vector Machine, SVM) 是一种监督学习技术,它通过...在本文中,我们将学习如何使用 SVM 分类器执行手写数字识别,同时也将探索不同的参数对于模型性能的影响,以获取具有最佳性能的 SVM 分类

    前言
    支持向量机 (Support Vector Machine, SVM) 是一种监督学习技术,它通过根据指定的类对训练数据进行最佳分离,从而在高维空间中构建一个或一组超平面。在博文《OpenCV-Python实战(13)——OpenCV与机器学习的碰撞》中,我们已经学习了如何在 OpenCV 中实现和训练 SVM 算法,同时通过简单的示例了解了如何使用 SVM 算法。在本文中,我们将学习如何使用 SVM 分类器执行手写数字识别,同时也将探索不同的参数对于模型性能的影响,以获取具有最佳性能的 SVM 分类器。


    使用 SVM 进行手写数字识别
    我们已经在《利用 KNN 算法识别手写数字》中介绍了 MNIST 手写数字数据集,以及如何利用 KNN 算法识别手写数字。并通过对数字图像进行预处理( desew() 函数)并使用高级描述符( HOG 描述符)作为用于描述每个数字的特征向量来获得最佳分类准确率。因此,对于相同的内容不再赘述,接下来将直接使用在《利用 KNN 算法识别手写数字》中介绍预处理和 HOG 特征,利用 SVM 算法对数字图像进行分类。

    首先加载数据,并将其划分为训练集和测试集:

    # 加载数据
    (train_dataset, train_labels), (test_dataset, test_labels) = keras.datasets.mnist.load_data()
    SIZE_IMAGE = train_dataset.shape[1]
    train_labels = np.array(train_labels, dtype=np.int32)
    # 预处理函数
    def deskew(img):
        m = cv2.moments(img)
        if abs(m['mu02']) < 1e-2:
            return img.copy()
        skew = m['mu11'] / m['mu02']
        M = np.float32([[1, skew, -0.5 * SIZE_IMAGE * skew], [0, 1, 0]])
        img = cv2.warpAffine(img, M, (SIZE_IMAGE, SIZE_IMAGE), flags=cv2.WARP_INVERSE_MAP | cv2.INTER_LINEAR)
     
        return img
    # HOG 高级描述符
    def get_hog():
        hog = cv2.HOGDescriptor((SIZE_IMAGE, SIZE_IMAGE), (8, 8), (4, 4), (8, 8), 9, 1, -1, 0, 0.2, 1, 64, True)
     
        print("hog descriptor size: {}".format(hog.getDescriptorSize()))
     
        return hog
    # 数据打散
    shuffle = np.random.permutation(len(train_dataset))
    train_dataset, train_labels = train_dataset[shuffle], train_labels[shuffle]
     
    hog = get_hog()
     
    hog_descriptors = []
    for img in train_dataset:
        hog_descriptors.append(hog.compute(deskew(img)))
    hog_descriptors = np.squeeze(hog_descriptors)
     
    results = defaultdict(list)
    # 数据划分
    split_values = np.arange(0.1, 1, 0.1)
    接下来,初始化 SVM,并进行训练:

    # 模型初始化函数
    def svm_init(C=12.5, gamma=0.50625):
        model = cv2.ml.SVM_create()
        model.setGamma(gamma)
        model.setC(C)
        model.setKernel(cv2.ml.SVM_RBF)
        model.setType(cv2.ml.SVM_C_SVC)
        model.setTermCriteria((cv2.TERM_CRITERIA_MAX_ITER, 100, 1e-6))
     
        return model
    # 模型训练函数
    def svm_train(model, samples, responses):
        model.train(samples, cv2.ml.ROW_SAMPLE, responses)
        return model
    # 模型预测函数
    def svm_predict(model, samples):
        return model.predict(samples)[1].ravel()
    # 模型评估函数
    def svm_evaluate(model, samples, labels):
        predictions = svm_predict(model, samples)
        acc = (labels == predictions).mean()
        print('Percentage Accuracy: %.2f %%' % (acc * 100))
        return acc *100
    # 使用不同训练集、测试集划分方法进行训练和测试
    for split_value in split_values:
        partition = int(split_value * len(hog_descriptors))
        hog_descriptors_train, hog_descriptors_test = np.split(hog_descriptors, [partition])
        labels_train, labels_test = np.split(train_labels, [partition])
     
        print('Training SVM model ...')
        model = svm_init(C=12.5, gamma=0.50625)
        svm_train(model, hog_descriptors_train, labels_train)
     
        print('Evaluating model ... ')
        acc = svm_evaluate(model, hog_descriptors_test, labels_test)
        results['svm'].append(acc)


    从上图所示,使用默认参数的 SVM 模型在使用 70% 的数字图像训练算法时准确率可以达到 98.60%,接下来我们通过修改 SVM 模型的参数 C 和 γ 来测试模型是否还有提升空间。


    Python客栈送红包、纸质书

    参数 C 和 γ 对识别手写数字精确度的影响
    SVM 模型在使用 RBF 核时,有两个重要参数——C 和 γ,上例中我们使用 C=12.5 和 γ=0.50625 作为参数值,C 和 γ 的设定依赖于特定的数据集。因此,必须使用某种方法进行参数搜索,本例中使用网格搜索合适的参数 C 和 γ。

    for C in [1, 10, 100, 1000]:
        for gamma in [0.1, 0.15, 0.25, 0.3, 0.35, 0.45, 0.5, 0.65]:
            model = svm_init(C, gamma)
            svm_train(model, hog_descriptors_train, labels_train)
            acc = svm_evaluate(model, hog_descriptors_test, labels_test)
            print(" {}".format("%.2f" % acc))
            results[C].append(acc)
    最后,可视化结果:

    fig = plt.figure(figsize=(10, 6))
    plt.suptitle("SVM handwritten digits recognition", fontsize=14, fontweight='bold')
    ax = plt.subplot(1, 1, 1)
    ax.set_xlim(0, 0.65)
    dim = [0.1, 0.15, 0.25, 0.3, 0.35, 0.45, 0.5, 0.65]
     
    for key in results:
        ax.plot(dim, results[key], linestyle='--', marker='o', label=str(key))
     
    plt.legend(loc='upper left', title="C")
    plt.title('Accuracy of the SVM model varying both C and gamma')
    plt.xlabel("gamma")
    plt.ylabel("accuracy")
    plt.show()
    程序的运行结果如下所示:

    如图所示,通过使用不同参数,准确率可以达到 99.25% 左右。通过比较 KNN 分类器和 SVM 分类器在手写数字识别任务中的表现,我们可以得出在手写数字识别任务中 SVM 优于 KNN 分类器的结论。


    完整代码
    程序的完整代码如下所示:

    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    from collections import defaultdict
    import keras
     
    (train_dataset, train_labels), (test_dataset, test_labels) = keras.datasets.mnist.load_data()
    SIZE_IMAGE = train_dataset.shape[1]
    train_labels = np.array(train_labels, dtype=np.int32)
     
    def deskew(img):
        m = cv2.moments(img)
        if abs(m['mu02']) < 1e-2:
            return img.copy()
        skew = m['mu11'] / m['mu02']
        M = np.float32([[1, skew, -0.5 * SIZE_IMAGE * skew], [0, 1, 0]])
        img = cv2.warpAffine(img, M, (SIZE_IMAGE, SIZE_IMAGE), flags=cv2.WARP_INVERSE_MAP | cv2.INTER_LINEAR)
     
        return img
     
    def get_hog():
        hog = cv2.HOGDescriptor((SIZE_IMAGE, SIZE_IMAGE), (8, 8), (4, 4), (8, 8), 9, 1, -1, 0, 0.2, 1, 64, True)
     
        print("hog descriptor size: {}".format(hog.getDescriptorSize()))
     
        return hog
     
    def svm_init(C=12.5, gamma=0.50625):
        model = cv2.ml.SVM_create()
        model.setGamma(gamma)
        model.setC(C)
        model.setKernel(cv2.ml.SVM_RBF)
        model.setType(cv2.ml.SVM_C_SVC)
        model.setTermCriteria((cv2.TERM_CRITERIA_MAX_ITER, 100, 1e-6))
     
        return model
     
    def svm_train(model, samples, responses):
        model.train(samples, cv2.ml.ROW_SAMPLE, responses)
        return model
     
    def svm_predict(model, samples):
        return model.predict(samples)[1].ravel()
     
    def svm_evaluate(model, samples, labels):
        predictions = svm_predict(model, samples)
        acc = (labels == predictions).mean()
        return acc * 100
    # 数据打散
    shuffle = np.random.permutation(len(train_dataset))
    train_dataset, train_labels = train_dataset[shuffle], train_labels[shuffle]
    # 使用 HOG 描述符
    hog = get_hog()
    hog_descriptors = []
    for img in train_dataset:
        hog_descriptors.append(hog.compute(deskew(img)))
    hog_descriptors = np.squeeze(hog_descriptors)
     
    # 训练数据与测试数据划分
    partition = int(0.9 * len(hog_descriptors))
    hog_descriptors_train, hog_descriptors_test = np.split(hog_descriptors, [partition])
    labels_train, labels_test = np.split(train_labels, [partition])
     
    print('Training SVM model ...')
    results = defaultdict(list)
     
    for C in [1, 10, 100, 1000]:
        for gamma in [0.1, 0.15, 0.25, 0.3, 0.35, 0.45, 0.5, 0.65]:
            model = svm_init(C, gamma)
            svm_train(model, hog_descriptors_train, labels_train)
            acc = svm_evaluate(model, hog_descriptors_test, labels_test)
            print(" {}".format("%.2f" % acc))
            results[C].append(acc)
     
    fig = plt.figure(figsize=(10, 6))
    plt.suptitle("SVM handwritten digits recognition", fontsize=14, fontweight='bold')
    ax = plt.subplot(1, 1, 1)
    ax.set_xlim(0, 0.65)
    dim = [0.1, 0.15, 0.25, 0.3, 0.35, 0.45, 0.5, 0.65]
    for key in results:
        ax.plot(dim, results[key], linestyle='--', marker='o', label=str(key))
    plt.legend(loc='upper left', title="C")
    plt.title('Accuracy of the SVM model varying both C and gamma')
    plt.xlabel("gamma")
    plt.ylabel("accuracy")
    plt.show()<font face="Arial, Verdana, sans-serif"><span style="white-space: normal;"> </span></font>
    以上就是Python利用 SVM 算法实现识别手写数字的详细内容

    展开全文
  • 基于SVM技术的手写数字识别

    万次阅读 多人点赞 2019-07-29 22:51:39
    最近研究了一下基于SVM技术的手写数字识别。你没有看错,又是手写数字识别,就是喜欢这个手写数字识别,没办法(¬∀¬)σ 一、背景 1.手写数字识别技术的含义 2.手写数字识别技术的理论价值 3.数字识别技术的...
  • 本文是对手写数字识别(二)----SVM 实现Mnist-image 手写数字图像识别_Sanger1990的博客-CSDN博客_mnist svm 文章中程序的小修改,使代码正常完成预定工作(原代码不能正常完成运行)。 from PIL import Image ...
  • SVM进行手写数字识别

    2020-08-18 14:05:17
    from sklearn import svm import numpy as np from sklearn.metrics import classification_report from tensorflow.keras.datasets.mnist import load_data (x_train, y_train), (x_test, y_test) = load_data() x...
  • 在这项工作中,正在提出一种新的多像元大小(MCS)方法,以利用定向梯度直方图(HOG)特征和基于支持向量机(SVM)的分类器对手写数字进行有效分类。 基于HOG的技术对在相关特征提取计算中使用的像元大小选择很敏感...
  • SVM手写数字识别

    2020-11-23 20:59:59
    SVM手写数字识别实验总结实验环境案例背景图像预处理建立SVM模型对测试样本进行识别 实验环境 (1) Windows7,MatlabR 2016b; (2) LIBSVM工具箱; 遇到的问题及解决方法: 起初安装的MATLABr2014b,配置libsvm工具包...
  • ,看到这个名字就知道这篇文章不会讲太多原理的了网上有各种关于大侠拍桌救其爱人的故事解释了SVM原理,这里我就不过多阐述了还是给个链接:两个链接相辅相成一个解释直观原理(几何图形层面),一个解释抽象原理(数学...
  • 基于Hog特征+SVM分类器,利用Opencv3.0进行手写数字识别的源代码及所需资源文件(训练图片、测试图片)
  • SVM实现手写数字识别

    千次阅读 2018-03-30 18:48:01
    SVM简介 知乎上的一个回答我认为是史上...开发环境 Windows10 + VS2013 + Qt580 + OpenCV300主要代码 利用opencv-SVM算法和Mnist数据集封装成一个单例模式的数字识别检测器。DigitsDetector.h#ifndef DIGITSDETEC...
  • 在OpenCV的安装路径下,搜索digits.png,可以得到一张图片,图片大小为1000* 2000,有0-9的10个数字,每5行为一个数字,总共50行,共有5000个手写数字,每个数字块大小为20* 20。 如下图所示: 下面将把这些数字中的...
  • total 0.98 0.98 0.98 49000 """ 高斯核的准确率明显提升了,但对9和4 与 3和5 的识别还是不是十分精确 2. 模型预测 if __name__ == '__main__' : y_test_prd = ova_svm_clf_fix.predict(x_test) print("整体准确...
  • 可爱聪明善良的你关注有惊喜哦 ...支持向量机(Support Vector Machine, SVM)是一类按监督学习(supervised learning)方式对数据进行二元分类(binary classification)的广义线性分类器(generalized l...
  • 文章目录最大间隔与分类对偶问题等式约束不等式约束的KKT条件二次规划SMO核函数软间隔与正则化支持向量回归实现SMO算法处理小规模数据集简化版SMO算法利用完整Platt SMO算法加速优化在复杂数据上应用核函数基于SVM的...
  • SVM 实现mnist 手写数字图像识别

    千次阅读 2020-07-24 13:57:14
    (3)手写数字识别中,各种数字写法复杂,这明显是线性不可分的情景,所以线性核函数的准确率较低。 2.1 模型训练 所有训练集在同一个文件夹类 from PIL import Image import os import numpy as np import time ...
  • 1、Sklearn.svm学习 数据集下载:trainingDigits... 详细数据介绍参看:KNN算法实现手写数字识别 2、代码实现 # -*- coding: UTF-8 -*- import numpy as np from os import listdir from sklearn.svm import SV...
  • 这篇博客是之前那篇在win7上用OpenCV的SVM分类器做[MNIST手写数字识别](https://blog.csdn.net/wblgers1234/article/details/73477860)的后续。用MNIST数据集做SVM训练和测试的细节可以移步那篇博客进行了解。
  • 基于SVM手写数字识别

    千次阅读 2017-05-30 21:54:25
    代码链接:http://download.csdn.net/detail/edwards_june/9856050 from numpy import * def loadDataSet(fileName): dataMat = [] labelMat = [] fr = open(fileName) for line in fr.readlines
  • svm 手写数字识别 MNIST数据集

    千次阅读 2018-05-08 20:49:48
    利用SVM(支持向量机)和MNIST库在OpenCV环境下实现手写数字0~9的识别https://blog.csdn.net/wenhao_ir/article/details/52160225
  • 前言前两天利用kNN实现了手写数字识别...这两天把Mnist-image的手写数字数据down了下来,利用SVM进行识别一下。Mnist-image的手写数字数据有7万的图像数据(6万训练数据+1万测试数据),每个图像数据为 20px * 20px。
  • 基于SVM手写字体识别

    千次阅读 2020-06-15 19:42:56
    基于SVM手写字体识别 1.案例背景 (1)手写数字识别在社会经济中的许多方面都有着广泛的应用,其识别方法也有许多种,如神经网络,Bayes判别法等。由于手写体人为因素随意性大,手写字体识别的难度远高于印刷体...
  • 目录一、 题目内容和要求: ...基本任务:对MNIST手写数据集进行识别,并给出算法精度等指标。 延伸:该问题还可以使用哪些算法进行求解?请实现不同的对比算法,并通过实验结果分析各算法的区别。 ...
  • 勒存这网络是由Yann和已经成功地使用在许多实际应用,如手写数字识别、人脸检测、机器人导航等更多信息。由于卷积网络的一些建筑的特性,如重量共享实现它是不现实的利用Matlab神经网络工具箱没有它的源代码的修改。这...
  • SVM是一种有机监督的机器学习方式,什么叫有监督?就是机器在学习时,有先验知识~SVM的理论细节很复杂,因为现在还不需要,所以博主也没有去深入研究,以后需要的时候再去学习吧。简单地说,SVM就是把一幅图进行各种...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,822
精华内容 1,528
关键字:

利用svm识别手写数字