已知LeNet5输入和各层权值，C语言，hls端实现其前向传播，得出MNIST分类结果

首先，LeNet5的输入为28x28的灰度图像，共有6层，其中前两层为卷积层，后三层为全连接层，最后一层为输出层。

下面是LeNet5的各层参数：

1. 第一层卷积层：
* 输入：28x28的灰度图像
* 卷积核大小：5x5
* 卷积核个数：6
* 步长：1
* 激活函数：sigmoid
* 输出大小：24x24x6

2. 第二层池化层：
* 输入：24x24x6
* 池化核大小：2x2
* 步长：2
* 输出大小：12x12x6

3. 第三层卷积层：
* 输入：12x12x6
* 卷积核大小：5x5
* 卷积核个数：16
* 步长：1
* 激活函数：sigmoid
* 输出大小：8x8x16

4. 第四层池化层：
* 输入：8x8x16
* 池化核大小：2x2
* 步长：2
* 输出大小：4x4x16

5. 第五层全连接层：
* 输入：4x4x16=256
* 输出：120
* 激活函数：sigmoid

6. 第六层全连接层：
* 输入：120
* 输出：84
* 激活函数：sigmoid

7. 输出层：
* 输入：84
* 输出：10（0~9的数字）
* 激活函数：softmax

下面是C语言实现LeNet5前向传播的伪代码：

// 定义卷积核和偏置
float conv1_kernel[5][5][6];
float conv1_bias[6];
float conv2_kernel[5][5][16];
float conv2_bias[16];

// 定义全连接层权重和偏置
float fc1_weight[120][256];
float fc1_bias[120];
float fc2_weight[84][120];
float fc2_bias[84];
float output_weight[10][84];
float output_bias[10];

// 定义输入和输出
float input[28][28];
float output[10];

// 定义卷积和池化函数
void convolution(float input[][28], float kernel[][][], float bias[], float output[][24][24], int kernel_num)
{
    for (int k = 0; k < kernel_num; k++)
    {
        for (int i = 0; i < 24; i++)
        {
            for (int j = 0; j < 24; j++)
            {
                float sum = 0.0;
                for (int m = 0; m < 5; m++)
                {
                    for (int n = 0; n < 5; n++)
                    {
                        sum += input[i+m][j+n] * kernel[m][n][k];
                    }
                }
                output[k][i][j] = sigmoid(sum + bias[k]);
            }
        }
    }
}

void max_pooling(float input[][24][24], float output[][12][12])
{
    for (int k = 0; k < 6; k++)
    {
        for (int i = 0; i < 12; i++)
        {
            for (int j = 0; j < 12; j++)
            {
                float max_value = 0.0;
                for (int m = 0; m < 2; m++)
                {
                    for (int n = 0; n < 2; n++)
                    {
                        if (input[k][2*i+m][2*j+n] > max_value)
                        {
                            max_value = input[k][2*i+m][2*j+n];
                        }
                    }
                }
                output[k][i][j] = max_value;
            }
        }
    }
}

// 定义全连接层函数
void fully_connected(float input[], float weight[][], float bias[], float output[], int input_num, int output_num)
{
    for (int i = 0; i < output_num; i++)
    {
        float sum = 0.0;
        for (int j = 0; j < input_num; j++)
        {
            sum += input[j] * weight[i][j];
        }
        output[i] = sigmoid(sum + bias[i]);
    }
}

// 定义softmax函数
void softmax(float input[], float output[], int input_num)
{
    float sum = 0.0;
    for (int i = 0; i < input_num; i++)
    {
        sum += exp(input[i]);
    }
    for (int i = 0; i < input_num; i++)
    {
        output[i] = exp(input[i]) / sum;
    }
}

// LeNet5前向传播函数
void forward(float input[][28], float output[])
{
    // 第一层卷积层和池化层
    float conv1_output[6][24][24];
    convolution(input, conv1_kernel, conv1_bias, conv1_output, 6);
    float pool1_output[6][12][12];
    max_pooling(conv1_output, pool1_output);

    // 第二层卷积层和池化层
    float conv2_output[16][8][8];
    convolution(pool1_output, conv2_kernel, conv2_bias, conv2_output, 16);
    float pool2_output[16][4][4];
    max_pooling(conv2_output, pool2_output);

    // 展开全连接层输入
    float fc_input[256];
    int count = 0;
    for (int k = 0; k < 16; k++)
    {
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                fc_input[count] = pool2_output[k][i][j];
                count++;
            }
        }
    }

    // 第一层全连接层
    float fc1_output[120];
    fully_connected(fc_input, fc1_weight, fc1_bias, fc1_output, 256, 120);

    // 第二层全连接层
    float fc2_output[84];
    fully_connected(fc1_output, fc2_weight, fc2_bias, fc2_output, 120, 84);

    // 输出层
    float output_input[10];
    fully_connected(fc2_output, output_weight, output_bias, output_input, 84, 10);
    softmax(output_input, output, 10);
}

在hls端实现时，可以使用Vivado HLS工具生成IP核，将这些C语言函数封装成IP核，在设计中调用该IP核即可。