继续输出lenet的c++代码

以下是使用C语言实现的LeNet模型代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define IMAGE_WIDTH 28
#define IMAGE_HEIGHT 28
#define NUM_CLASSES 10

// Convolution layer parameters
#define CONV1_KERNEL_SIZE 5
#define CONV1_NUM_FILTERS 6
#define CONV1_PADDING 0
#define CONV1_STRIDE 1

// Subsampling layer parameters
#define SUBSAMP1_KERNEL_SIZE 2
#define SUBSAMP1_STRIDE 2

#define CONV2_KERNEL_SIZE 5
#define CONV2_NUM_FILTERS 16
#define CONV2_PADDING 0
#define CONV2_STRIDE 1

#define SUBSAMP2_KERNEL_SIZE 2
#define SUBSAMP2_STRIDE 2

#define FULLY_CONNECTED_SIZE 120

// Activation function
#define RELU(x) ((x) > 0 ? (x) : 0)

// Structure to hold convolution layer
typedef struct ConvLayer {
    int num_filters;
    int filter_size;
    int stride;
    int padding;
    float *filters;
    float *biases;
} ConvLayer;

// Structure to hold subsampling layer
typedef struct SubsampLayer {
    int kernel_size;
    int stride;
} SubsampLayer;

// Structure to hold fully connected layer
typedef struct FCLayer {
    int input_size;
    int output_size;
    float *weights;
    float *biases;
} FCLayer;

// Function to perform convolution on input image
void conv(float *input, ConvLayer *layer, float *output) {
    int i, j, k, l, m, n;
    int padded_width = IMAGE_WIDTH + 2 * layer->padding;
    int padded_height = IMAGE_HEIGHT + 2 * layer->padding;
    int output_width = (int)ceil((float)(padded_width - layer->filter_size + 1) / layer->stride);
    int output_height = (int)ceil((float)(padded_height - layer->filter_size + 1) / layer->stride);

    float *padded_input = (float *)calloc(padded_width * padded_height * sizeof(float), 1);

    // Zero-pad the input image
    for (i = 0; i < IMAGE_HEIGHT; i++) {
        for (j = 0; j < IMAGE_WIDTH; j++) {
            padded_input[(i + layer->padding) * padded_width + (j + layer->padding)] = input[i * IMAGE_WIDTH + j];
        }
    }

    // Convolve each filter with the input image
    for (i = 0; i < layer->num_filters; i++) {
        for (j = 0; j < output_height; j++) {
            for (k = 0; k < output_width; k++) {
                float sum = 0.0;
                for (l = 0; l < layer->filter_size; l++) {
                    for (m = 0; m < layer->filter_size; m++) {
                        sum += padded_input[(j * layer->stride + l) * padded_width + (k * layer->stride + m)] * layer->filters[(i * layer->filter_size + l) * layer->filter_size + m];
                    }
                }
                output[(i * output_height + j) * output_width + k] = RELU(sum + layer->biases[i]);
            }
        }
    }

    free(padded_input);
}

// Function to perform subsampling on input image
void subsamp(float *input, SubsampLayer *layer, float