C++识别MNIST数据集（二分类）

最新推荐文章于 2023-10-12 20:34:07 发布
最新推荐文章于 2023-10-12 20:34:07 发布
阅读量920 收藏 18
点赞数 2
分类专栏： C++ 文章标签： c++ 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44263726/article/details/109892252
版权

C++识别MNIST数据集

#include <vector> 
#include <string> 
#include <fstream> 
#include <iostream>
#include <Eigen/Eigen/Dense> 
#include <ctime>
#include <windows.h>

using namespace std;
using namespace Eigen;

// 大端转小端
int ReverseInt(int i)
{
	unsigned char ch1, ch2, ch3, ch4;
	ch1 = i & 255;
	ch2 = (i >> 8) & 255;
	ch3 = (i >> 16) & 255;
	ch4 = (i >> 24) & 255;
	return((int)ch1 << 24) + ((int)ch2 << 16) + ((int)ch3 << 8) + ch4;
}

// 建立读取标签的函数
void read_Mnist_Label(string filename, vector<float>&labels)
{
	ifstream file(filename, ios::binary);
	if (file.is_open())
	{
		int magic_number = 0;
		int number_of_images = 0;
		file.read((char*)&magic_number, sizeof(magic_number));
		file.read((char*)&number_of_images, sizeof(number_of_images));
		magic_number = ReverseInt(magic_number);
		number_of_images = ReverseInt(number_of_images);
		cout << endl;
		cout << "\t" << "magic number = " << magic_number << endl;
		cout << "\t" << "number of images = " << number_of_images << endl;
		for (int i = 0;
			i < number_of_images; i++)
		{
			unsigned char label = 0;
			file.read((char*)&label, sizeof(label));
			labels.push_back((float)label);
		}
	}
}

// 建立读取图像的函数
void read_Mnist_Images(string filename, vector<vector<float>>&images)
{
	ifstream file(filename, ios::binary);
	if (file.is_open())
	{
		int magic_number = 0;
		int number_of_images = 0;
		int n_rows = 0;
		int n_cols = 0;
		// unsigned char label;
		file.read((char*)&magic_number, sizeof(magic_number));
		file.read((char*)&number_of_images, sizeof(number_of_images));
		file.read((char*)&n_rows, sizeof(n_rows));
		file.read((char*)&n_cols, sizeof(n_cols));
		magic_number = ReverseInt(magic_number);
		number_of_images = ReverseInt(number_of_images);
		n_rows = ReverseInt(n_rows);
		n_cols = ReverseInt(n_cols);
		cout << endl;
		cout << "\t" << "magic number = " << magic_number << endl;
		cout << "\t" << "number of images = " << number_of_images << endl;
		cout << "\t" << "rows = " << n_rows << endl;
		cout << "\t" << "cols = " << n_cols << endl;
		for (int i = 0; i < number_of_images; i++)
		{
			vector<float>tp;
			for (int r = 0; r < n_rows; r++)
			{
				for (int c = 0; c < n_cols; c++)
				{
					unsigned char image = 0;
					file.read((char*)&image, sizeof(image));
					tp.push_back(image);
				}
			}
			images.push_back(tp);
		}
	}
}

int main(int argc,char *argv[])
{
	SetConsoleTitle(L"Handwritten digit classification");
	clock_t tStart = clock();
	Eigen::initParallel();

	vector<vector<float>>images;           // 声明训练集样本矩阵
	vector<float>labels;                   // 声明训练集标签向量
	vector<int> effective_col;             // 声明有效特征向量所在列

	cout << endl << "训练集图片信息：" << endl;
	read_Mnist_Images("train-images.idx3-ubyte", images);          // 读取训练集样本数据
	cout << endl << "训练集标签信息：" << endl;
	read_Mnist_Label("train-labels.idx1-ubyte", labels);           // 读取训练集标签数据

	auto m = images.size();      // 训练集矩阵行数
	auto n = images[0].size();   // 训练集矩阵列数
	auto b = labels.size();      // 训练集标签个数

	// 统计训练集样本中有效特征所在列
	for (unsigned j = 0; j < n; j++)
	{
		int num_of_nonzero = 0;
		for (unsigned i = 0; i < m; i++)
		{
			if (images[i][j] != 0)
				num_of_nonzero += 1;
		}
		if (num_of_nonzero >= 600)
			effective_col.push_back(j);

	}

	auto num_key = effective_col.size();      // 有效特征个数

	// cout << endl << "训练集有效特征列数 = " << num_key << endl;

	// 建立训练集60000*494的特征矩阵
	MatrixXf Characteristic_matrix(m, num_key + 1);
	for (unsigned i = 0; i < m; i++)
	{
		for (unsigned j = 0; j < num_key; j++)
		{
			Characteristic_matrix(i, j) = images[i][effective_col[j]];
		}
		Characteristic_matrix(i, num_key) = 1;
	}

	images.~vector<vector<float>>();        // 析构函数，释放内存

	auto m_cm = Characteristic_matrix.rows();        // 训练集特征矩阵行数
	auto n_cm = Characteristic_matrix.cols();        // 训练集特征矩阵列数

	cout << endl;
	cout << "训练集特征矩阵的行数 = " << m_cm << endl
		 << "训练集特征矩阵的列数 = " << n_cm << endl;

	VectorXf actual_Y(b);                   // 初始化训练集实际值

	// 将训练集标签分类，0 = 1，非0 = -1
	for (unsigned i = 0; i < b; i++)
		labels[i] == 0 ? actual_Y(i) = 1 : actual_Y(i) = -1;

	labels.~vector<float>();      // 析构函数，释放内存

	// 用QR分解求取拟合系数向量
	VectorXf fit_coefficient = Characteristic_matrix.householderQr().solve(actual_Y);

	// 利用模型对训练集进行预测，并计算错误率
	VectorXf prediction_Y = Characteristic_matrix * fit_coefficient;

	int tp = 0, fn = 0, fp = 0, tn = 0;       // tp:正确的正值  fn:错误的负值  fp:错误的正值  tn:正确的负值

	for (unsigned j = 0; j < prediction_Y.size(); j++)
	{
		if (prediction_Y[j] >= 0 && actual_Y[j] == 1)
			tp += 1;
		if (prediction_Y[j] >= 0 && actual_Y[j] == -1)
			fn += 1;
		if (prediction_Y[j] < 0 && actual_Y[j] == 1)
			fp += 1;
		if (prediction_Y[j] < 0 && actual_Y[j] == -1)
			tn += 1;
	}

	cout << endl;
	cout << "训练集预测结果：" << endl;
	cout << "\t" << "tp = " << tp << "\t" << "fn = " << fn << endl
		 << "\t" << "fp = " << fp << "\t" << "tn = " << tn << endl;
	cout << "\t" << "错误率 = " << 1.0*(fn + fp) / 60000 << endl;

	vector<vector<float>>test_images;      // 声明测试集样本矩阵
	vector<float>test_labels;              // 声明测试集标签向量

	cout << endl << "测试集图片信息：" << endl;
	read_Mnist_Images("t10k-images.idx3-ubyte", test_images);         // 读取测试集样本数据
	cout << endl << "测试集标签信息：" << endl;
	read_Mnist_Label("t10k-labels.idx1-ubyte", test_labels);          // 读取测试集标签数据

	auto m_test = test_images.size();      // 测试集矩阵行数
	auto b_test = test_labels.size();      // 测试集标签个数

	//建立测试集10000*494的特征矩阵
	MatrixXf t_Characteristic_matrix(m_test, num_key + 1);
	for (unsigned i = 0; i < m_test; i++)
	{
		for (unsigned j = 0; j < num_key; j++)
		{
			t_Characteristic_matrix(i, j) = test_images[i][effective_col[j]];
		}
		t_Characteristic_matrix(i, num_key) = 1;
	}

	auto m_tcm = t_Characteristic_matrix.rows();        // 测试集特征矩阵行数
	auto n_tcm = t_Characteristic_matrix.cols();        // 测试集特征矩阵列数

	cout << "测试集特征矩阵的行数 = " << m_tcm << endl
		 << "测试集特征矩阵的列数 = " << n_tcm << endl;


	VectorXf t_actual_Y(b_test);            // 初始化测试集实际值

	// 将测试集标签分类，0 = 1，非0 = -1
	for (unsigned i = 0; i < b_test; i++)
		test_labels[i] == 0 ? t_actual_Y(i) = 1 : t_actual_Y(i) = -1;

	test_labels.~vector<float>();     // 析构函数，释放内存

	// 利用模型对测试集进行预测，并计算错误率
	VectorXf t_prediction_Y = t_Characteristic_matrix * fit_coefficient;

	tp = fn = fp = tn = 0;
	for (unsigned j = 0; j < t_prediction_Y.size(); j++)
	{
		if (t_prediction_Y[j] >= 0 && t_actual_Y[j] == 1)
			tp += 1;
		if (t_prediction_Y[j] >= 0 && t_actual_Y[j] == -1)
			fn += 1;
		if (t_prediction_Y[j] < 0 && t_actual_Y[j] == 1)
			fp += 1;
		if (t_prediction_Y[j] < 0 && t_actual_Y[j] == -1)
			tn += 1;
	}
	cout << endl;
	cout << "测试集预测结果：" << endl;
	cout << "\t" << "tp = " << tp << "\t" << "fn = " << fn << endl
		 << "\t" << "fp = " << fp << "\t" << "tn = " << tn << endl;
	cout << "\t" << "错误率 = " << 1.0*(fn + fp) / 10000 << endl;

	cout << endl << "---------------------添加随机特征---------------------------" << endl;

	unsigned random_character = 5000;        // 设置随机特征个数

	// 构建随机矩阵R(494,5000)  矩阵元素取 ±1
	MatrixXf R = MatrixXf::Random(n_cm, random_character);
	for (unsigned j = 0; j < random_character; j++)
	{
		for (unsigned i = 0; i <n_cm; i++)
		{
			R(i, j)>0 ? R(i, j) = 1 : R(i, j) = -1;
		}
	}

	// 用随机矩阵构建新特征
	MatrixXf R_Characteristic_matrix = Characteristic_matrix * R;   // 60000*5000
	for (unsigned i = 0; i < m_cm; i++)
	{
		for (unsigned j = 0; j < random_character; j++)
		{
			if (R_Characteristic_matrix(i, j) < 0)
				R_Characteristic_matrix(i, j) = 0;
		}
	}
	//cout << "训练集随机矩阵的行数 = " << R_Characteristic_matrix.rows() << endl
	//	 << "训练集随机矩阵的列数 = " << R_Characteristic_matrix.cols() << endl;

	// 构建新的特征矩阵
	MatrixXf new_Characteristic_matrix(m, n_cm + random_character);
	new_Characteristic_matrix << Characteristic_matrix, R_Characteristic_matrix;

	Characteristic_matrix.resize(0, 0);
	R_Characteristic_matrix.resize(0, 0);

	cout << endl;
	cout << "训练集新特征矩阵的行数 = " << new_Characteristic_matrix.rows() << endl
		 << "训练集新特征矩阵的列数 = " << new_Characteristic_matrix.cols() << endl;

	// 求新的拟合系数
	VectorXf new_fit_coefficient = new_Characteristic_matrix.householderQr().solve(actual_Y);

	VectorXf new_prediction_Y = new_Characteristic_matrix * new_fit_coefficient;

	tp = fn = fp = tn = 0;
	for (int j = 0; j < new_prediction_Y.size(); j++)
	{
		if (new_prediction_Y[j] >= 0 && actual_Y[j] == 1)
			tp += 1;
		if (new_prediction_Y[j] >= 0 && actual_Y[j] == -1)
			fn += 1;
		if (new_prediction_Y[j] < 0 && actual_Y[j] == 1)
			fp += 1;
		if (new_prediction_Y[j] < 0 && actual_Y[j] == -1)
			tn += 1;
	}
	cout << endl;
	cout << "训练集预测结果：" << endl;
	cout << "\t" << "tp = " << tp << "\t" << "fn = " << fn << endl
		 << "\t" << "fp = " << fp << "\t" << "tn = " << tn << endl;
	cout << "\t" << "错误率 = " << 1.0*(fn + fp) / 60000 << endl;

	// 构建测试集的随机特征
	MatrixXf R_t_Characteristic_matrix = t_Characteristic_matrix * R;   //10000*5000
	R.resize(0, 0);    // 释放内存
	for (unsigned i = 0; i < m_test; i++)
	{
		for (unsigned j = 0; j < random_character; j++)
		{
			if (R_t_Characteristic_matrix(i, j) < 0)
				R_t_Characteristic_matrix(i, j) = 0;
		}
	}
	//cout << "测试集随机矩阵的行数=" << R_t_Characteristic_matrix.rows() << endl
	//	 << "测试集随机矩阵的列数=" << R_t_Characteristic_matrix.cols() << endl;

	// 构建测试集新的特征矩阵
	MatrixXf n_t_Characteristic_matrix(m_test, n_tcm + random_character);
	n_t_Characteristic_matrix << t_Characteristic_matrix, R_t_Characteristic_matrix;

	cout << endl;
	cout << "测试集新特征矩阵的行数 = " << n_t_Characteristic_matrix.rows() << endl
		 << "测试集新特征矩阵的列数 = " << n_t_Characteristic_matrix.cols() << endl;

	VectorXf n_t_prediction_Y = n_t_Characteristic_matrix * new_fit_coefficient;

	tp = fn = fp = tn = 0;
	for (int j = 0; j < n_t_prediction_Y.size(); j++)
	{
		if (n_t_prediction_Y[j] >= 0 && t_actual_Y[j] == 1)
			tp += 1;
		if (n_t_prediction_Y[j] >= 0 && t_actual_Y[j] == -1)
			fn += 1;
		if (n_t_prediction_Y[j] < 0 && t_actual_Y[j] == 1)
			fp += 1;
		if (n_t_prediction_Y[j] < 0 && t_actual_Y[j] == -1)
			tn += 1;
	}
	cout << endl;
	cout << "测试集预测结果：" << endl;
	cout << "\t" << "tp = " << tp << "\t" << "fn = " << fn << endl
		 << "\t" << "fp = " << fp << "\t\t" << "tn = " << tn << endl;
	cout << "\t" << "错误率 = " << 1.0*(fn + fp) / 10000 << endl;

	clock_t tEnd = clock();       // 结束计时
	cout << "程序总运行时间(s)：" << float(tEnd - tStart) / CLOCKS_PER_SEC << endl;

	system("pause");
	return 0;
}
Deep Learning(Logistic Regression)学习之MNIST C++实现
puretech_的专栏
10-01 1万+
DeepLearning Logistic Regression的MNIST例子的C++实现
C++读取MINIST数据集
qq_31232793的博客
03-09 929
注意：必须考虑大端小端对齐的问题，我的电脑就是大端对齐的，但是我只对图片数量的读数做了处理， #include <vector> #include <iostream> const char* train_images_idx3_ubyte_file = "MNIST_data/train-images.idx3-ubyte"; const char* train_...
使用LibSVM库实现的c++二分类
11-09
c++编写的支持向量机(SVM)实现二分类 实现功能：运行后会弹出图形坐标系，左键点击能产生第一类的数据点，点击鼠标中键后可再点击左键产生第二类的数据点，再点击鼠标中键后会在坐标系中画出分类超平面
Softmax回归算法对MNIST手写数字进行识别(C++实现)
05-27
1. C++实现Softmax回归算法 2. 使用Softmax回归算法对MNIST手写数字进行识别 3. 代码干净, 整洁, 有注释, 可直接迁移使用 4. 工程中以包含MNIST手写数字数据文件 5. 关于MNIST可浏览网址: http://yann.lecun.com/exdb/mnist/
C++读取MNIST数据集
晚晴小筑
11-06 1万+
Mnist数据集对应四个文件： train-images-idx3-ubyte: training set images  train-labels-idx1-ubyte: training set labels  t10k-images-idx3-ubyte:  test set images  t10k-labels-idx1-ubyte:  test set labels 训练
mnist数据集svm python_OPENCV3.1 对手写数据集MNIST实现SVM
weixin_31934101的博客
02-17 439
1.开发环境-Win10-Visual Studio 2015 64位-OpenCV3.12.MNIST手写数据库MNIST数据集分为以下四部分：(1)train-images-idx3-ubyte训练图像的集合，共有60000张，大小是28×28(2)train-labels-idx1-ubyte对应于训练图像的标签集，为0～9(3)t10k-images-idx3-ubyte测试图像的集合，共...
MNIST数据集的生成
08-16
MNIST数据集是机器学习领域一个非常经典的图像识别数据集，主要用于手写数字的识别。这个数据集包含60,000个训练样本和10,000个测试样本，每个样本都是28x28像素的灰度图像。生成类似的自定义数据集可以帮助我们理解...
C++ 实现全连接神经网络算法识别 Mnist 手写数字
hfq0219的博客
01-04 4281
C++ 实现全连接神经网络算法识别 Mnist 手写数字 完整项目代码可从 https://github.com/hfq0219/mnist 下载。 /** *@Author: fengqi *@Email: 2607546441@qq.com */ 本程序使用全连接神经网络进行手写数字识别的训练和预测。 代码结构参考了 yolo(You Only Look Once) 项目源码框架 darkne...
opencv学习笔记——用C++读取MNIST手写数据库的数据，并用opencv自带的SVM进行识别
wanty_chen的博客
04-28 4080
        本文所用的MNIST 数据集来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST). 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员。 测试集(test set) ...
（超详细）读取mnist数据集并保存成图片
热门推荐
YF_Li123的博客
08-05 4万+
mnist数据集介绍、读取、保存成图片 1、mnist数据集介绍： MNIST数据集是一个手写体数据集，简单说就是一堆这样东西  MNIST的官网地址是 MNIST; 通过阅读官网我们可以知道，这个数据集由四部分组成，分别是  ;也就是一个训练图片集，一个训练标签集，一个测试图片集，一个测试标签集；我们可以看出这个其实并不是普通的文本文件或是图片文件，而是一个压缩文件，
MNIST-C分类：C ++中的MNIST数字分类
02-10
MNIST-C ++分类 C ++中的MNIST数字分类
C++ 利用 opencv300 里的 svm 二分类
04-10
C++ 利用 opencv300 里的 svm 二分类。 opencv300/c++/svm/下二分类实验，与opencv2不同，详细对比了不同之处 svm
MNIST数据集与识别
12-03
MNIST数据集，手写数字的识别，神经网络，python代码，可以用notebook打开
minst手写数字识别数据集
05-03
MNIST 数据集来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST). 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员. 测试集(test set) 也是同样比例的手写数字数据.
C++读取MNIST 数据
chinabinlang的专栏
03-21 887
可以到这里下载数据： http://wiki.jikexueyuan.com/project/tensorflow-zh/tutorials/mnist_download.html #include <vector> class CIDX3UBYTE { public: CIDX3UBYTE(char * strFile) { m_nFile...
MNIST字符识别(C++)
最新发布
NonDay的博客
10-12 275
【代码】MNIST字符识别(C++)
3.Minst数据集分类
baici9608的博客
09-22 560
import numpy as np from keras.datasets import mnist from keras.utils import np_utils from keras.models import Sequential from keras.layers import Dense from keras.optimizers import SGD ...
My Machine Learn(四)：mnist数字识别神经网络的优化(c++版本)
xuanwolanxue的专栏
08-07 5303
一、背景 去年写过一篇关于用c++实现mnist手写数字识别的神经网络的文章，当然，这里是最基本的bp神经网络。不知不觉一年多的时间就悄悄溜过去了。 《神经网络实现手写数字识别（MNIST）》：https://blog.csdn.net/xuanwolanxue/article/details/71565934 《再谈神经网络反向传播原理》：https://blog.csdn.net/xua...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值