opencv实现KNN手写数字的识别

　　人工智能是当下很热门的话题，手写识别是一个典型的应用。为了进一步了解这个领域，我阅读了大量的论文，并借助opencv完成了对28x28的数字图片（预处理后的二值图像）的识别任务。

　　预处理一张图片：

　　首先采用opencv读取图片的构造函数读取灰度的图片，再采用大津法求出图片的二值化的阈值，并且将图片二值化。

int otsu(const IplImage* src_image) {
    double sum = 0.0;
    double w0 = 0.0;
    double w1 = 0.0;
    double u0_temp = 0.0;
    double u1_temp = 0.0;
    double u0 = 0.0;
    double u1 = 0.0;
    double delta_temp = 0.0;
    double delta_max = 0.0;

    int pixel_count[256] = { 0 };
    float pixel_pro[256] = { 0 };
    int threshold = 0;
    uchar* data = (uchar*)src_image->imageData;
    for (int i = 0; i < src_image->height; i++) {
        for (int j = 0; j < src_image->width; j++) {
            pixel_count[(int)data[i * src_image->width + j]]++;
            sum += (int)data[i * src_image->width + j];
        }
    }
    for (int i = 0; i < 256; i++) {
        pixel_pro[i] = (float)pixel_count[i] / (src_image->height * src_image->width);
    }
    for (int i = 0; i < 256; i++) {
        w0 = w1 = u0_temp = u1_temp = u0 = u1 = delta_temp = 0;
        for (int j = 0; j < 256; j++) {
            if (j <= i) {
                w0 += pixel_pro[j];
                u0_temp += j * pixel_pro[j];
            }
            else {
                w1 += pixel_pro[j];
                u1_temp += j * pixel_pro[j];
            }
        }
        u0 = u0_temp / w0;
        u1 = u1_temp / w1;
        delta_temp = (float)(w0 *w1* pow((u0 - u1), 2));
        if (delta_temp > delta_max) {
            delta_max = delta_temp;
            threshold = i;
        }
    }
    return threshold;
}

void imageBinarization(IplImage* src_image) {
    IplImage* binImg = cvCreateImage(cvGetSize(src_image), src_image->depth, src_image->nChannels);
    CvScalar s;
    int ave = 0;
    int binThreshold = otsu(src_image);

    for (int i = 0; i < src_image->height; i++) {
        for (int j = 0; j < src_image->width; j++) {
            s = cvGet2D(src_image, i, j);
            ave = (s.val[0] + s.val[1] + s.val[2]) / 3;
            if (ave < binThreshold) {
                s.val[0] = s.val[1] = s.val[2] = 0xff;
                cvSet2D(src_image, i, j, s);
            }
            else {
                s.val[0] = s.val[1] = s.val[2] = 0x00;
                cvSet2D(src_image, i, j, s);
            }
        }
    }
    cvCopy(src_image, binImg);
    cvSaveImage(bined, binImg);
    //cvShowImage("binarization", binImg);
    //waitKey(0);
}

　　由于是只进行简单的识别模拟，因此没有做像素断点的处理。获取minst提供的数据集，提取每个图片的hog特征，参数如下：

HOGDescriptor *hog = new HOGDescriptor(
            cvSize(ImgWidht, ImgHeight), cvSize(14, 14), cvSize(7, 7), cvSize(7, 7), 9);

　　（9个方向换成18个可能会取得更准确的结果，这取决于对图片本身的复杂程度的分析

　　之后即可训练knn分类器，进行分类了。

void knnTrain() {
#ifdef SAVETRAINED
    //knn training;
    samples.clear();
    dat_mat = Mat::zeros(10 * nImgNum, 324, CV_32FC1);
    res_mat = Mat::zeros(10 * nImgNum, 1, CV_32FC1);
    for (int i = 0; i != 10; i++) {
        getFile(dirNames[i], i);
    }
    preTrain();
    cout << "------ Training finished. -----" << endl << endl;
    knn.train(dat_mat, res_mat, Mat(), false, 2);

#ifdef SAVEASXML
    knn.save("./trained/knnTrained.xml");
#endif

#else
    knn.load("./trained/knnTrained.xml");
#endif

    //knn test
    cout << endl << "--- KNN test mode : ---" << endl;
    int tCnt = 10000;
    int tAc = 0;
    selfknnTest(tCnt, tAc);

    cout << endl << endl << "Total number of test samples : " << tCnt << endl;

    cout << "Accuracy : " << float(float(tAc) / float(tCnt)) * 100 << "%" << endl;
}

 　训练结果如下，准确率还是很令人满意的。