网站开发的英文书有什么,网络科技公司取名字参考大全,色一把做最好的看片网站,网站建设发布设需求pytorch教材
3.4. softmax回归 — 动手学深度学习 2.0.0 documentation
c实现代码
代码太长了就没整理了#xff0c;也暂时没有运行效果截图
同样没有本文也没有实现反向自动求导
超长代码警告#xff0c;757行。不过可能注释占一半
#include bits/stdc.h
usin…pytorch教材
3.4. softmax回归 — 动手学深度学习 2.0.0 documentation
c实现代码
代码太长了就没整理了也暂时没有运行效果截图
同样没有本文也没有实现反向自动求导
超长代码警告757行。不过可能注释占一半
#include bits/stdc.h
using namespace std;
// reverseInt 函数将32位整数的大小端进行转换
// 参数
// x: 需要进行大小端转换的32位整数
// 返回值
// 转换后即小端转大端或大端转小端的32位整数
int reverseInt(int x)
{// 定义四个无符号字符变量用于存储整数x的四个字节 unsigned char a, b, c, d;// 获取整数x的最低8位即第一个字节 // (int)255的二进制是00000000 00000000 00000000 11111111与操作后只保留最低8位 a x 255;// 获取整数x的第二个字节即第9-16位b (x8) 255;// 获取整数x的第三个字节即第17-24位c (x16) 255;// 获取整数x的最高字节即第25-32位 d (x24) 255;// 将这四个字节按照相反的顺序重新组合成一个整数实现大端序和小端序的转换 int ans ((int)a24) ((int)b16) ((int)c8) d;return ans;
}/** * brief 获取最大值 * * 从给定的双精度浮点数数组中找出最大值并返回。 * * param a 指向双精度浮点数数组的指针 * param len 数组的长度元素的数量 * * return 数组中的最大值 */
double getMax(double* a, int len)
{ double smax -DBL_MAX; // 初始化最大值为 double max确保即使数组中包含负数该函数仍然会返回最大的那个数assert(len0); // 断言数组长度必须大于 0 for (int i 0; i len; i) { // 使用三元运算符更新最大值 smax a[i] smax ? a[i] : smax; } return smax;
}
/** * brief 计算 Softmax 函数值 * * 对于给定的实数数组计算其 Softmax 函数值并返回一个新的数组其中每个元素是输入数组中对应元素的 Softmax 值。 * * param num 输入的实数数组 * param len 数组的长度元素的数量 * * return 指向计算得到的 Softmax 值数组的指针 * * note 返回的数组需要调用者在使用完毕后手动释放内存。 * 为了数值稳定性在计算 Softmax 之前先对数组中的最大值进行减去操作称为 Shifted Softmax。 * 此外如果数组中包含极大的正数或极小的负数可能会导致溢出或下溢但在此实现中通过减去最大值来减少溢出的可能性。 */
double* softmax(double* num, int len)
{ // 分配一个新的双精度浮点数数组来存储 Softmax 值 double* ans new double[len]; // 断言数组长度必须大于 0 assert(len 0); // 复制输入数组到输出数组初始时两者相同 for (int i 0; i len; i){ ans[i] num[i]; } // 数组元素的总和 与 最大值 double sum 0, smax getMax(ans, len); // 对每个元素应用 Shifted Softmax 公式 for (int i 0; i len; i){ // 减去最大值后计算指数函数避免上溢 ans[i] exp(ans[i] - smax); // 累加所有 exp() 的值到 sum 中 sum ans[i]; } // 归一化 Softmax 值 for (int i 0; i len; i){ ans[i] / sum; } // 返回计算得到的 Softmax 值数组 return ans;
}
/** * brief 矩阵乘法 * * 执行两个二维数组的矩阵乘法运算并返回结果矩阵。 * * param X 第一个矩阵一个指向指针的指针表示二维数组 * param W 第二个矩阵一个指向指针的指针表示二维数组 * param xrow 矩阵X的行数 * param xcol 矩阵X的列数同时也是矩阵W的行数由断言保证 * param wrow 矩阵W的行数实际上与xcol相同但此参数在此函数中不使用 * param wcol 矩阵W的列数 * * return 指向结果矩阵的指针一个指向指针的指针表示二维数组 * * note 调用此函数前应确保矩阵X和W的维度匹配即X的列数等于W的行数。 * 此外返回的结果矩阵需要调用者在使用完毕后手动释放内存。 * 这个函数使用了断言来确保矩阵X的列数等于矩阵W的行数。 */
double** matmul(double** X, double** W, int xrow, int xcol, int wrow, int wcol)
{ // 断言以确保矩阵X的列数等于矩阵W的行数 assert(xcol wrow); // 分配结果矩阵的内存 double** ans new double*[xrow]; for (int i 0; i xrow; i) { ans[i] new double[wcol]; } // 遍历计算结果矩阵的每个元素 for(int i 0; i xrow; i) { for (int j 0; j wcol; j) { double sum 0; // 初始化累加器 // 遍历矩阵X的第i行和矩阵W的第j列对应的元素执行乘法并累加 for (int k 0; k xcol; k) { double x X[i][k]; // 从矩阵X中取出元素 sum x * W[k][j]; // 累加乘法结果 } // 将累加结果存储到结果矩阵的对应位置 ans[i][j] sum; } } // 返回结果矩阵 return ans;
}
/** * brief 矩阵乘法与偏置项相加 * * 对给定的输入矩阵X、权重矩阵W和偏置项b进行线性变换即执行X*Wb的操作 * 并返回结果矩阵。 * * param X 输入矩阵大小为[batch_size, num_input] * param W 权重矩阵大小通常为[num_input, num_output]* param b 偏置项大小为[num_output] * param batch_size 批量大小即输入矩阵X的行数 * param num_input 输入特征的维度 * param num_output 输出特征的维度 * * return 指向结果矩阵的指针大小为[batch_size, num_output] * * note 调用此函数前应确保输入矩阵X、权重矩阵W和偏置项b的维度正确匹配。 * 此外返回的结果矩阵需要调用者在使用完毕后手动释放内存。 */
double** xwpb(double** X, double** W, double* b, int batch_size, int num_input, int num_output)
{ // 执行矩阵乘法X*W double** o matmul(X, W, batch_size, num_input, num_input, num_output); // 将偏置项b加到结果矩阵o的每一行上 for (int i 0; i batch_size; i) // 遍历批量中的每个样本 { for(int j 0; j num_output; j) // 遍历输出特征的每个维度 { o[i][j] b[j]; // 将偏置项加到结果矩阵的对应位置上 } } // 返回结果矩阵 return o;
}/** * brief Softmax回归函数 * * 对给定的输入矩阵X、权重矩阵W和偏置项b执行线性变换即XWb * 然后对每个样本的输出应用Softmax函数并返回包含Softmax结果的向量。 * * param X 输入矩阵大小为[batch_size, num_input] * param W 权重矩阵大小为[num_input, num_output] * param b 偏置项大小为[num_output] * param batch_size 批量大小即输入矩阵的行数 * param num_input 输入特征的维度 * param num_output 输出特征的维度同时也是类别数 * * return 返回一个向量其中每个元素是一个指向double数组的指针表示每个样本的Softmax输出 * * note 调用此函数前应确保输入矩阵X、权重矩阵W和偏置项b的维度正确匹配。 * 返回的向量中的double指针数组即Softmax结果在使用完毕后需要手动释放内存。 * 函数内部调用了xwpb函数进行线性变换并调用了softmax函数对每个样本的输出应用Softmax。 */
vectordouble* sofreg(double** X, double** W, double* b, int batch_size, int num_input, int num_output)
{ // 执行线性变换XWb并返回结果矩阵o double** o xwpb(X, W, b, batch_size, num_input, num_output); // 创建一个大小为batch_size的向量y_hat用于存储每个样本的Softmax输出 vectordouble* y_hat(batch_size); // 遍历每个样本 for (int i 0; i batch_size; i) { // 对当前样本的输出应用Softmax函数并返回结果指针so double* so softmax(o[i], num_output); // 将Softmax结果存储到y_hat向量的对应位置 y_hat[i] so; } // 释放内存 for(int i0; ibatch_size; i) delete[] o[i];delete[] o;// 返回包含每个样本Softmax输出的向量 return y_hat;
}
/** * brief 交叉熵损失函数 * * 计算给定预测值经过Softmax处理后的概率分布y_hat和实际标签y之间的交叉熵损失。 * * param y_hat 预测值向量每个元素是一个指向double数组的指针表示每个样本的Softmax输出 * param y 实际标签数组为0到9之间的整数* param batch_size 批量大小即y_hat和y中元素的数量 * param num_output 输出特征的维度同时也是类别数在此为100-9的10个类别 * * return 返回一个指向double数组的指针数组大小为batch_size表示每个样本的交叉熵损失 * * note 调用此函数前应确保y_hat和y的长度相等并且与batch_size匹配。 * 此外y中的每个标签值应为0到num_output-1之间的整数。 * 函数内部使用了assert来检查y中的值是否在有效范围内以及y_hat中对应位置的预测值是否在(0,1)之间。 * 返回的double数组需要调用者在使用完毕后手动释放内存。 */
double* cross_entropy(vectordouble* y_hat, char* y, int batch_size, int num_output)
{ // 分配一个大小为batch_size的double数组用于存储每个样本的交叉熵损失 double* loss new double[batch_size]; // 遍历每个样本 for (int i 0; i batch_size; i) { int yi y[i];// 使用assert断言来检查标签值是否在有效范围内0-9 assert(yi 0 yi 9); // 使用assert断言来检查y_hat中对应位置的预测值是否在(0,1)之间 assert(y_hat[i][yi] 0 y_hat[i][yi] 1); // 计算交叉熵损失这里只考虑了单标签的情况即每个样本只有一个类别标签 loss[i] -log(y_hat[i][yi]); } // 返回包含每个样本交叉熵损失的double数组 return loss;
}
/*** brief sgd 函数用于执行随机梯度下降Stochastic Gradient Descent算法
// 来更新神经网络中的权重 W 和偏置 b // 参数说明
// X: 输入数据是一个二维数组指针的指针大小为 [batch_size][num_input]
// y: 标签数据是一个字符串但实际上是标签的索引数组大小为 [batch_size]
// W: 权重矩阵是一个二维数组指针的指针大小为 [num_input][num_output]
// b: 偏置向量是一个一维数组大小为 [num_output]
// lr: 学习率用于控制权重更新的步长
// batch_size: 批量大小即每次用于梯度计算的样本数量
// num_input: 输入数据的特征数量
// num_output: 输出数据的类别数量或神经元的数量 */
void sgd(double** X, const char* y, double** W, double* b, double lr, int batch_size, int num_input, int num_output)
{
// vectordouble* y_hat sofreg(X, W, b, batch_size, num_input, num_output);// 计算线性组合的结果未经过激活函数 double** oxwpb(X, W, b, batch_size, num_input, num_output);// 为权重梯度 gradw 和偏置梯度 gradb 分配内存 double** gradwnew double*[num_input];double* gradbnew double[num_output];// 初始化权重梯度 gradw 为 0 for (int i0; inum_input; i){gradw[i] new double[num_output];for (int j0; jnum_output; j)gradw[i][j]0.0;}// 初始化偏置梯度 gradb 为 0for (int j0; jnum_output; j)gradb[j]0.0;// 遍历批量中的每个样本计算梯度 for (int i0; ibatch_size; i){int yi y[i];// 计算 softmax 函数的结果 double* sosoftmax(o[i], num_output);// 计算 cross entropy 对 小批量的未规范化预测 O 的导数 // softmax(o)[j]-y[j] 将 y 视为独热标签向量 double grad[num_output];for(int j0; jnum_output; j){grad[j] so[j];}grad[yi]-1;// 计算 gradb , cross entropy 对 b 的导数链式求导 // o X * W b for (int j0; jnum_output; j){gradb[j]grad[j];}// 计算 gradw cross entropy 对 W 的导数链式求导 // o X * W b for (int j0; jnum_input; j){for (int k0; knum_output; k){double xX[i][j];gradw[j][k] grad[k]*x;}}delete[] so;}// 使用计算得到的梯度来更新权重 W 和偏置 b for(int i0; inum_input; i){for (int j0; jnum_output; j){W[i][j] W[i][j] - lr * gradw[i][j] / batch_size;}}for (int i0; inum_output; i){b[i] b[i] - lr * gradb[i]/ batch_size;}for (int i0; ibatch_size; i) delete[] o[i];delete[] o;for (int i0; inum_input; i) delete[] gradw[i];delete[] gradw;delete[] gradb;
}
/** * brief 计算平均值 * * 计算给定双精度浮点数数组的平均值。 * * param loss 包含要计算平均值的双精度浮点数的数组 * param len 数组的长度元素的数量 * * return 数组 loss 中所有元素的平均值 * */
double mean(double* loss, int len)
{ double ans 0; // 初始化累加器为 0 assert(len0); // 断言数组长度必须大于 0 // 遍历数组 loss 中的每个元素 for (int i 0; i len; i) { // 将当前元素加到累加器 ans 上 ans loss[i]; } // 返回累加器 ans 除以数组长度 len 的结果即平均值 return ans / len;
}unsigned char** read_mnist_image(string file_name, int num_image, int num_row, int num_col, const int check_number);
char* read_mnist_label(string file_name, const int num_image, const int check_number);
unsigned char** get_image(string path, int num_image, int num_row, int num_col, bool is_train);
char* get_label(string path, int num_image, bool is_train);
/** * brief 归一化图像数据 * * 将输入的二维无符号字符数组通常是灰度图像归一化到 0 到 1 的范围内 * 并返回一个二维双精度浮点数数组其中包含了归一化后的图像数据。 * * param cX 输入的二维无符号字符数组代表原始图像数据 * param row 图像的行数 * param col 图像的列数 * * return 指向归一化后二维双精度浮点数数组的指针 * * note 调用者需要确保输入的 cX 数组是有效且已经分配了足够的内存。 * 返回的 X 数组需要调用者在使用完毕后手动释放内存。 */
double** normalization(unsigned char** cX, int row, int col)
{ // 创建一个新的二维双精度浮点数数组 X 来存储归一化后的图像数据 double** X new double*[row]; for(int i0; irow; i) { X[i] new double[col]; } // 遍历原始图像数据的每个像素并进行归一化 for (int i0; irow; i) { for (int j0; jcol; j) { // 读取原始图像数据中的像素值 int x cX[i][j]; // 归一化到 0 到 1 的范围 X[i][j] x * 1.0 / 255.0;} } // 返回归一化后的图像数据 return X;
}/** * brief 打乱图像数据和标签的顺序 * * 使用 Fisher-Yates 洗牌算法也被称为 Knuth 洗牌结合一个随机数生成器来 * 打乱传入的图像数据和对应的标签。 * * param X 指向图像数据的指针数组每个元素指向一个图像一维数组 * param y 指向标签数据的指针每个元素表示一个标签 * param num_image 图像和标签的数量 * * note 此函数会直接修改传入的 X 和 y而不需要额外的存储空间。 */
void shuffle(unsigned char** X, char* y, int num_image)
{ // 创建一个整数向量 num用于存储原始索引 vectorint num(num_image); for(int i 0; i num_image; i) num[i] i; // 使用当前时间作为随机数生成器的种子 // 这样可以确保每次调用 shuffle 函数时都能得到不同的随机序列 random_device rd; mt19937 g(rd()); // 使用 Mersenne Twister 算法来生成随机数 // 打乱整数向量 num 中的元素顺序 shuffle(num.begin(), num.end(), g); // 使用 Fisher-Yates 洗牌算法来打乱图像数据和标签的顺序 unsigned char* tmpcp; // 临时指针用于交换图像数据 char tmpc; // 临时字符用于交换标签 for (int i 0; i num_image; i) { // 交换图像数据 tmpcp X[i]; X[i] X[num[i]]; X[num[i]] tmpcp; // 交换标签数据 tmpc y[i]; y[i] y[num[i]]; y[num[i]] tmpc; }
}int main()
{// 定义数据集的路径 string path../data/MNIST/raw/;// 定义变量来存储图像和标签的数量以及尺寸 // 训练图像的数量、像素行数和列数高和宽 int num_image, num_row, num_col;// 测试图像的数量、像素行数和列数 int num_test_image, num_test_row, num_test_col;// 从指定路径读取训练集与测试集图像并返回图像数据和图像数量以及像素宽高 unsigned char** cX get_image(path, num_image, num_row, num_col, true);unsigned char** test_cX get_image(path, num_test_image, num_test_row, num_test_col, false);// 从指定路径加载标签 char* y get_label(path, num_image, true);char* test_y get_label(path, num_test_image, false); // 对训练数据和标签进行随机打乱 shuffle(cX, y, num_image);// 对图像数据进行归一化处理并返回处理后的数据 double** Xnormalization(cX, num_image, num_row*num_col);double** test_Xnormalization(test_cX, num_test_image, num_test_row*num_test_col); // 定义超参数 const double lr 0.01;// 学习率 const int num_epochs 10;// 训练轮数 const int num_output 10;// 输出层神经元数量对应MNIST的10个类别 const int batch_size 256;// 批量大小const int num_sample num_image;// 总样本数这里等于训练样本数 const int num_input num_row * num_col; // 输入层神经元数量等于图像的像素数 // 初始化权重矩阵W和偏置向量b double** Wnew double* [num_input];for (int i0; inum_input; i) W[i]new double[num_output];double* bnew double[num_output];// 将W和b的所有元素初始化为0.0 for(int i0; inum_input; i){for (int j0; jnum_output; j){W[i][j]0.0;}}for (int j0; jnum_output; j){b[j]0.0;}// 开始进行训练循环迭代num_epochs次 for (int epoch0; epochnum_epochs; epoch){// 对所有样本进行迭代每次处理batch_size个样本 for (int j0; jnum_sample; jbatch_size){// 确保每一批量获得正确的样本个数 int batch min(batch_size, num_sample-j);// 对当前batch的数据进行softmax回归计算得到预测结果y_hat vectordouble* y_hat sofreg(Xj, W, b, batch, num_input, num_output);// 计算当前batch的交叉熵损失 double* loss cross_entropy(y_hat, yj, batch, num_output);// 使用随机梯度下降SGD更新权重W和偏置b sgd(Xj, yj, W, b, lr, batch, num_input, num_output);delete[] loss;for (auto i:y_hat) delete[] i;y_hat.clear();}// 在每个epoch结束后测试模型在测试集上的性能 {// 初始化索引和当前batch的大小对于测试集这里通常使用整个测试集 int j0;// 但因为测试集通常全部使用所以batch_size可能不会被限制 int batch min(batch_size, num_test_image-j);// 对测试集进行softmax回归计算得到预测结果y_hat vectordouble* y_hat sofreg(test_Xj, W, b, batch, num_input, num_output);// 初始化预测正确的样本数 int right_num0;// 遍历当前batch的所有样本 for (int i0; ibatch; i){// 获取当前样本的预测结果 double* yy y_hat[i];double mm0, id-1;// 找到预测概率最大的类别 for (int j0; jnum_output; j){if (yy[j]mm) mmyy[j], idj;}// 检查预测类别是否与实际类别相同如果相同则增加正确数if (id (test_yj)[i]) right_num;}// 计算并打印当前epoch的测试集准确率double* loss cross_entropy(y_hat, test_yj, batch, num_output);printf(in epoch %d, accuracy is %.4Lf\n, epoch1, right_num*1.0/batch*1.0);delete[] loss;for (auto i:y_hat) delete[] i;y_hat.clear();} }// 累了交给操作系统自己释放吧 //delete cX, test_cX, y, test_y, X, test_X, w, b;
}/*******************************************
// 读取MNIST数据集图像的函数
// 参数
// file_name: 图像文件的名字需要绝对或相对路径
// num_image: 读取的图像数量引用传递用于修改外部变量
// num_row: 每张图像的行数引用传递用于修改外部变量
// num_col: 每张图像的列数引用传递用于修改外部变量
// check_number: 用于检查文件头部magic number的期望值
// 返回值
// 返回一个二维指针指向由unsigned char数组组成的图像数组
// 第一个维度是图片数量第二个维度是单张图片大小
// 注意调用此函数的代码应确保在适当的时候释放images指向的内存避免内存泄漏
********************************************/
unsigned char** read_mnist_image(string file_name, int num_image, int num_row, int num_col, const int check_number)
{// 以二进制读模式打开文件 FILE *fp fopen(file_name.c_str(), rb);// 如果文件打开失败退出程序if (!fp){printf(file open fail!\n);exit(0);}// 读取magic number、图像数量、图像的行数和列数 int magic_number;fread((char*)magic_number, sizeof(magic_number), 1, fp);fread((char*)num_image, sizeof(num_image), 1, fp);fread((char*)num_row, sizeof(num_row), 1, fp);fread((char*)num_col, sizeof(num_col), 1, fp);//由于MNIST文件是以大端字节序存储的所以需要转换为小端序 magic_numberreverseInt(magic_number);num_imagereverseInt(num_image);num_rowreverseInt(num_row);num_colreverseInt(num_col);// 检查magic number是否匹配 if (check_number ! magic_number){printf(magic number is error, this is not the right image file\n);fclose(fp); // 关闭文件句柄 exit(0); // 退出程序 }// 分配二维数组以存储图像 unsigned char** imagesnew unsigned char*[num_image];// 读取所有图像for(int i0; inum_image; i){// 为每个图像分配内存 unsigned char* imagenew unsigned char[num_row * num_col];// 读取图像数据fread(image, sizeof(unsigned char), num_row * num_col, fp);// 将图像数据存入二维数组 images[i]image;}// 关闭文件句柄 fclose(fp);// 返回二维图像指针 return images;// 示例使用delete[]来释放每个图像的内存并最后释放images本身// for (int i 0; i num_image; i) { // delete[] images[i]; // } // delete[] images;
}/*************************************
// 读取MNIST数据集标签的函数
// 参数
// file_name: 标签文件的名字需要绝对或相对路径
// num_image: 预期读取的标签数量应与文件内标签数量一致
// check_number: 用于检查文件头部magic number的期望值检查文件是否正确
// 返回值
// 返回一个包含标签的char数组指针此处char应理解为单字节类型整数
// 注意调用此函数的代码应确保在适当的时候释放labels指向的内存避免内存泄漏
***************************************/
char* read_mnist_label(string file_name, const int num_image, const int check_number)
{// 以二进制读模式打开文件 FILE *fp fopen(file_name.c_str(), rb);// 如果文件打开失败退出程序if (!fp){printf(file open fail!\n);exit(-1);}// 定义并读取magic number和标签数量 int magic_number, num_label;fread((char*)magic_number, sizeof(magic_number), 1, fp);fread((char*)num_label, sizeof(num_label), 1, fp);//由于MNIST文件是以大端字节序存储的所以需要转换为小端序 magic_numberreverseInt(magic_number);num_labelreverseInt(num_label);// 检查magic number是否匹配 if (check_number ! magic_number){printf(magic number is error, this is not the right label file!\n);fclose(fp);exit(-1);}// 检查标签数量是否与预期一致 if (num_label!num_image){printf(num_label not equal num_image!\n);fclose(fp);exit(-1);}// 动态分配内存以存储标签 char* labelsnew char[num_label];// 读取所有标签 for(int i0; inum_label; i){fread(labels[i], sizeof(char), 1, fp);}// 关闭文件句柄 fclose(fp);// 返回标签数组指针return labels;// 示例使用delete[]来释放标签的内存//delete[] labels;
}/** * brief 获取 MNIST 数据集的图像数据 * * 根据指定的文件路径和是否训练数据集的标志从 MNIST 数据集中加载图像数据 * 并返回指向图像数据的指针二维数组。同时更新图像数量、行数和列数的引用参数。 * * param path 数据集所在的路径 * param num_image 引用参数用于返回图像数量 * param num_row 引用参数用于返回每个图像的行数 * param num_col 引用参数用于返回每个图像的列数 * param is_train 是否为训练数据集的标志true 为训练数据false 为测试数据 * * return 指向图像数据的指针二维数组每个元素为 unsigned char 类型 */
unsigned char** get_image(string path, int num_image, int num_row, int num_col, bool is_train)
{// 定义 MNIST 数据集的文件名 string name_train_imagetrain-images-idx3-ubyte;string name_train_labeltrain-labels-idx1-ubyte;string name_test_imaget10k-images-idx3-ubyte;string name_test_labelt10k-labels-idx1-ubyte;// 根据是否训练数据集的标志选择加载训练或测试数据集的图像文件 if (is_train) {// 加载训练数据集的图像文件 return read_mnist_image(pathname_train_image, num_image, num_row, num_col, 2051);} else {// 加载测试数据集的图像文件 return read_mnist_image(pathname_test_image, num_image, num_row, num_col, 2051);}
}/** * brief 获取 MNIST 数据集的标签数据 * * 根据给定的路径、图像数量和是否训练数据集的标志从 MNIST 数据集中加载标签数据 * 并返回指向标签数据的指针一维字符数组。 * * param path 数据集所在的路径 * param num_image 预期的标签数量用于检查文件标签数量是否与预期一致* param is_train 是否为训练数据集的标志true 为训练数据false 为测试数据 * * return 指向标签数据的指针一维字符数组每个元素表示一个标签 */
char* get_label(string path, const int num_image, bool is_train)
{// 定义 MNIST 数据集的文件名 string name_train_imagetrain-images-idx3-ubyte;string name_train_labeltrain-labels-idx1-ubyte;string name_test_imaget10k-images-idx3-ubyte;string name_test_labelt10k-labels-idx1-ubyte;// 根据是否训练数据集的标志选择加载训练或测试数据集的标签文件if (is_train) {// 加载训练数据集的标签文件return read_mnist_label(pathname_train_label, num_image, 2049);} else {// 加载测试数据集的标签文件 return read_mnist_label(pathname_test_label, num_image, 2049);}
}
