用C语言实现卷积操作（包含单通道单卷积和多通道多卷积以及维度的转换）

于 2022-05-05 17:10:44 发布
阅读量1.5w 收藏 89
点赞数 11
分类专栏： 深度学习C语言实现 文章标签： c语言 卷积神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42585108/article/details/124592646
版权

用C语言实现卷积

单通单卷积

卷积其实就是个点成相加的过程
原理图如下：
在这里插入图片描述
关键代码实现：

//单通道单卷积
#define IMG_SIZE 5
#define W_SIZE   3
#define OUT_SIZE 3   // (f-w+2p)/s + 1 = (5-3+0)/1+1 = 3
int conv(float img[IMG_SIZE][IMG_SIZE],float w[W_SIZE][W_SIZE],float out[OUT_SIZE][OUT_SIZE])
{
    float tmp=0.0;
    for(int k=0;k<=IMG_SIZE - W_SIZE;k++)  //特征平面的行  列平移 行卷积
    {

        for(int r=0;r<=IMG_SIZE - W_SIZE;r++) //特征平面的列  行平移  列卷积
        {
            tmp = 0.0;
            //单次卷积 点对点相乘 然后相加
            for(int i=0;i<W_SIZE;i++) //卷积的行
            {
                for(int j=0;j<W_SIZE;j++) //卷积的列
                {
                    tmp +=  img[i+k][j+r]*w[i][j];
                }
            }
            out[k][r] = tmp;
        }
    }
    return 0;
}

运行结果：

在这里插入图片描述

多通道多卷积

原理示意图：
在这里插入图片描述

关键代码实现如下：

//多通道多卷积
#define IMG_SIZE 7
#define IMG_CH   3
#define CONV_KERNEL_SIZE 3
#define CONV_KERNEL_CH 3
#define CONV_KERNEL_NUM 2
#define OUT_SIZE 5
#define OUT_CH 2 

/*
注意：这里把通道数放后面 是为了与后续 tensorflow 提取的参数保持一致 

如:
    # 进行卷积计算
    # x表示输入的描述表示4阶张量，类似[1,2,2,3]， 由于使用一张图 于是可以写成[2][3][3]
    # 第一维参数表示一次性读取的图片数量
    # 第2、3维表示图片的分辨率，最后一维表示图片的通道数

    # w表示卷积核的表述，同样是4维张量
    # 第1、2维表示卷积核的分辨率，第3维表示图片的通道数
    # 第4维表示卷积核的个数
*/


/*
img : [7][7][3]      输入图像大小   7*7  有3个通道数
w   : [3][3][3][2]   权重大小       3*3  有3个通道数 一共有2个卷积核
out : [5][5][2]      输出图像大小   5*5  有2个通道数 (输出通道数等于卷积核的数量)

*/
int convs(  float img[IMG_SIZE][IMG_SIZE][IMG_CH],
            float w[CONV_KERNEL_SIZE][CONV_KERNEL_SIZE][CONV_KERNEL_CH][CONV_KERNEL_NUM],
            float out[OUT_SIZE][OUT_SIZE][OUT_CH])
{
    float tmp=0.0,tmp1=0.0;
    for(int m=0;m<CONV_KERNEL_NUM;m++)
    {
        for(int k=0;k<=IMG_SIZE - W_SIZE;k++)  //特征平面的行  列平移 行卷积
        {

            for(int r=0;r<=IMG_SIZE - W_SIZE;r++) //特征平面的列  行平移  列卷积
            {
                //多通道累加
                tmp1 = 0.0;
                for(int n=0;n<CONV_KERNEL_CH;n++)
                {
                    tmp = 0.0;
                    //单次卷积 点对点相乘 然后相加
                    for(int i=0;i<W_SIZE;i++) //卷积的行
                    {
                        for(int j=0;j<W_SIZE;j++) //卷积的列
                        {
                            tmp +=  img[i+k][j+r][n]*w[i][j][n][m];
                        }
                    }
                    //累加多个特征平面的卷积结果
                    tmp1 += tmp;
                }
                out[k][r][m] = tmp1;
            }
        }
    }
}

运行结果：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

维度转换（多维转一维）

//实现多维转一维
#define IN_SIZE 3
#define IN_CH 3
#define OUT_LEN (IN_SIZE*IN_SIZE*IN_CH)
int convert(float in[IN_SIZE][IN_SIZE][IN_CH],float out[OUT_LEN])
{
    // float *p = out;
    for(int k=0;k<IN_CH;k++)
    {
        for(int i=0;i<IN_SIZE;i++)
        {
            for(int j=0;j<IN_SIZE;j++)
            {
                #if 0
                *p = in[i][j][k];
                #else 
                out[k*IN_SIZE*IN_SIZE+i*IN_SIZE+j] = in[i][j][k];
                #endif
            }
        }
    }
    return 0;
}

运行结果：
在这里插入图片描述

完整代码实现：

#include <stdio.h>

//单通道单卷积
#define IMG_SIZE 5
#define W_SIZE   3
#define OUT_SIZE 3   // (f-w+2p)/s + 1 = (5-3+0)/1+1 = 3
int conv(float img[IMG_SIZE][IMG_SIZE],float w[W_SIZE][W_SIZE],float out[OUT_SIZE][OUT_SIZE])
{
    float tmp=0.0;
    for(int k=0;k<=IMG_SIZE - W_SIZE;k++)  //特征平面的行  列平移 行卷积
    {

        for(int r=0;r<=IMG_SIZE - W_SIZE;r++) //特征平面的列  行平移  列卷积
        {
            tmp = 0.0;
            //单次卷积 点对点相乘 然后相加
            for(int i=0;i<W_SIZE;i++) //卷积的行
            {
                for(int j=0;j<W_SIZE;j++) //卷积的列
                {
                    tmp +=  img[i+k][j+r]*w[i][j];
                }
            }
            out[k][r] = tmp;
        }
    }
    return 0;
}
int conv_test()
{

    float img_in[IMG_SIZE][IMG_SIZE] = { 1,1,1,0,0,
								    0,1,1,1,0,
								    0,0,1,1,1,
								    0,0,1,1,0,
								    0,1,1,0,0};
								
	float conv_w[W_SIZE][W_SIZE] = {  1,0,1,
									  0,1,0,
									  1,0,1};

	float img_out[OUT_SIZE][OUT_SIZE] = {0};

    //调用卷积函数 
    conv(img_in,conv_w,img_out);

    int i,j;
    printf("Input picture:\n");
    for(i=0;i<5;i++)
    {
        for(j=0;j<5;j++)
        {
            printf("%.1f ",img_in[i][j]);
        }
        printf("\n");
    }

    printf("Input weight:\n");
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
        {
            printf("%.1f ",conv_w[i][j]);
        }
        printf("\n");
    }

    printf("Output picture:\n");
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
        {
            printf("%.1f ",img_out[i][j]);
        }
        printf("\n");
    }
    return 0;
}

//多通道多卷积
#define IMG_SIZE 7
#define IMG_CH   3
#define CONV_KERNEL_SIZE 3
#define CONV_KERNEL_CH 3
#define CONV_KERNEL_NUM 2
#define OUT_SIZE 5
#define OUT_CH 2 

/*
注意：这里把通道数放后面 是为了与后续 tensorflow 提取的参数保持一致 

如:
    # 进行卷积计算
    # x表示输入的描述表示4阶张量，类似[1,2,2,3]， 由于使用一张图 于是可以写成[2][3][3]
    # 第一维参数表示一次性读取的图片数量
    # 第2、3维表示图片的分辨率，最后一维表示图片的通道数

    # w表示卷积核的表述，同样是4维张量
    # 第1、2维表示卷积核的分辨率，第3维表示图片的通道数
    # 第4维表示卷积核的个数
*/


/*
img : [7][7][3]      输入图像大小   7*7  有3个通道数
w   : [3][3][3][2]   权重大小       3*3  有3个通道数 一共有2个卷积核
out : [5][5][2]      输出图像大小   5*5  有2个通道数 (输出通道数等于卷积核的数量)

*/
int convs(  float img[IMG_SIZE][IMG_SIZE][IMG_CH],
            float w[CONV_KERNEL_SIZE][CONV_KERNEL_SIZE][CONV_KERNEL_CH][CONV_KERNEL_NUM],
            float out[OUT_SIZE][OUT_SIZE][OUT_CH])
{
    float tmp=0.0,tmp1=0.0;
    for(int m=0;m<CONV_KERNEL_NUM;m++)
    {
        for(int k=0;k<=IMG_SIZE - W_SIZE;k++)  //特征平面的行  列平移 行卷积
        {

            for(int r=0;r<=IMG_SIZE - W_SIZE;r++) //特征平面的列  行平移  列卷积
            {
                //多通道累加
                tmp1 = 0.0;
                for(int n=0;n<CONV_KERNEL_CH;n++)
                {
                    tmp = 0.0;
                    //单次卷积 点对点相乘 然后相加
                    for(int i=0;i<W_SIZE;i++) //卷积的行
                    {
                        for(int j=0;j<W_SIZE;j++) //卷积的列
                        {
                            tmp +=  img[i+k][j+r][n]*w[i][j][n][m];
                        }
                    }
                    //累加多个特征平面的卷积结果
                    tmp1 += tmp;
                }
                out[k][r][m] = tmp1;
            }
        }
    }
}


int convs_test()
{
    float input[IMG_CH][IMG_SIZE][IMG_SIZE] = {
	0,0,0,0,0,0,0,
	0,1,1,2,2,1,0,
	0,1,1,1,2,1,0,
	0,2,1,1,0,2,0,
	0,2,1,0,1,2,0,
	0,2,1,2,2,2,0,
	0,0,0,0,0,0,0,
	
	0,0,0,0,0,0,0,
	0,0,1,2,0,1,0,
	0,2,2,1,1,0,0,
	0,2,1,0,0,2,0,
	0,1,0,0,0,2,0,
	0,0,1,0,1,2,0,
	0,0,0,0,0,0,0,
	
	0,0,0,0,0,0,0,
	0,2,2,0,1,2,0,
	0,0,0,2,1,2,0,
	0,2,1,0,2,1,0,
	0,1,1,0,0,0,0,
	0,0,0,1,1,1,0,
	0,0,0,0,0,0,0,};

    

    
	
	float conv_w[CONV_KERNEL_NUM][CONV_KERNEL_CH][CONV_KERNEL_SIZE][CONV_KERNEL_SIZE] = {
	1,1,1,
	-1,-1,0,
	-1,1,0,
	
	-1,-1,1,
	-1,1,0,
	-1,1,0,
	
	1,0,-1,
	0,0,0,
	1,-1,-1,
	
	0,0,-1,
	-1,1,1,
	0,0,0,
	
	0,0,1,
	1,0,1,
	0,-1,-1,
	
	-1,1,1,
	0,1,1,
	1,-1,1};

  
    //由于输入的图像是正规的数据排列 ，但是函数调用是图像数据需要做预处理
    float input1[IMG_SIZE][IMG_SIZE][IMG_CH] = {0};
    float conv_w1[CONV_KERNEL_SIZE][CONV_KERNEL_SIZE][CONV_KERNEL_CH][CONV_KERNEL_NUM] = {0};
    float img_out[OUT_SIZE][OUT_SIZE][OUT_CH] = {0};
  
    int i,j,k,r,m,n;

    printf("Input picture\n");
    for(k =0;k<IMG_CH;k++)
    {
        for(i=0;i<IMG_SIZE;i++)
        {
            for(j=0;j<IMG_SIZE;j++)
            {
                input1[i][j][k] = input[k][i][j];
                printf("%.1f  ",input1[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
    printf("\n");

    printf("CONV_KERNEL:\n");
    for(r=0;r<CONV_KERNEL_NUM;r++)
    {
        for(k=0;k<CONV_KERNEL_CH;k++)
        {
            for(i=0;i<CONV_KERNEL_SIZE;i++)
            {
                for(j=0;j<CONV_KERNEL_SIZE;j++)
                {
                    conv_w1[i][j][k][r] = conv_w[r][k][i][j];
                    printf("%.1f  ",conv_w1[i][j][k][r]);
                }
                printf("\n");
            }
            printf("\n");
        }
    }
    printf("\n");

    convs(input1,conv_w1,img_out);

    printf("Output picture\n");
    for(k=0;k<OUT_CH;k++)
    {
        for(i=0;i<OUT_SIZE;i++)
        {
            for(j=0;j<OUT_SIZE;j++)
            {
                printf("%.1f   ",img_out[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
    printf("\n");
    return 0;

}

//实现多维转一维
#define IN_SIZE 3
#define IN_CH 3
#define OUT_LEN (IN_SIZE*IN_SIZE*IN_CH)
int convert(float in[IN_SIZE][IN_SIZE][IN_CH],float out[OUT_LEN])
{
    // float *p = out;
    for(int k=0;k<IN_CH;k++)
    {
        for(int i=0;i<IN_SIZE;i++)
        {
            for(int j=0;j<IN_SIZE;j++)
            {
                #if 0
                *p = in[i][j][k];
                #else 
                out[k*IN_SIZE*IN_SIZE+i*IN_SIZE+j] = in[i][j][k];
                #endif
            }
        }
    }
    return 0;
}

int convert_test()
{
    float input[IN_CH][IN_SIZE][IN_SIZE] = {
	1,1,1,
	-1,-1,0,
	-1,1,0,
	
	-1,-1,1,
	-1,1,0,
	-1,1,0,
	
	1,0,-1,
	0,0,0,
	1,-1,-1,
	};

    float input1[IN_SIZE][IN_SIZE][IN_CH] = {0};
    float output[OUT_LEN] ={0};
    int i,j,k,r,m,n;
    float *p = output;
    printf("Input picture\n");
    for(k=0;k<IN_CH;k++)
    {
        for(i=0;i<IN_SIZE;i++)
        {
            for(j=0;j<IN_SIZE;j++)
            {
                input1[i][j][k] = input[k][i][j];
                printf("%.1f  ",input1[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
    printf("\n");

    convert(input1,output);

    printf("Output picture\n");
    for(k=0;k<IN_CH;k++)
    {
        for(i=0;i<IN_SIZE;i++)
        {
            for(j=0;j<IN_SIZE;j++)
            {
                // printf("%.1f  ",*p);
                // p++;
                // printf("%.1f   ",output[i][j][k]);
                printf("%.1f  ",output[k*IN_SIZE*IN_SIZE+i*IN_SIZE+j]);
                // printf("%.1f  ",output[k*IN_SIZE*IN_SIZE+i*IN_SIZE+j]);
            }
        }
    }
    return 0;

}

int main()
{
    //conv_test();
    //convs_test();
    convert_test();
    return 0;

}
w²大大
关注
  • 11
    点赞
  • 踩
  • 89
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C/C++ 卷积算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-08 2284
卷积算法的核心思想是通过卷积操作来提取输入数据中的特征。具体而言，它将卷积核与输入数据进行逐点相乘，然后将乘积累加得到输出结果的对应位置的值。这个过程可以看作是在输入数据的局部区域进行加权求和，从而达到提取特征的目的。卷积算法是一种常用的信号处理技术，用于图像处理、音频处理、自然语言处理等领域。简而言之，卷积算法将两个函数进行运算，其中一个函数作为输入，另一个函数通常称为卷积核或滤波器。
卷积C语言实现
热门推荐
wejoncy的专栏
05-24 1万+
这个是很简单，但是真写出来也写了半天 保留着看自己以后会不会用到 卷积Y(n)=x(n)*h(n) =∑x(i)h(n-i); 举个例子 简单点 x(n)={1,2,3,4};h(n)=(1,2,3,4); y(0)=x(0)h(0); y(1)=x(0)h(1)+x(1)h(0) y(2)=x(0)h(2)+x(1)h(1)+x(2)h(0); y(3)=
【数字图像处理】图像形态学算法C语言实现（图像卷积，膨胀，腐蚀，开运算，闭运算，顶帽，黑帽，雕版，锐化）
yy197696的博客
11-25 2928
文章目录(一)图像卷积1. 图像卷积2. 数字信号处理中的卷积3 数字图像处理中的卷积（二）图像卷积实现各种形态学运算腐蚀膨胀形态学梯度开运算闭运算顶帽黑帽雕版锐化li_conv.cmain.c(三)效果展示原图腐蚀膨胀形态学梯度开运算闭运算顶帽黑帽雕版锐化 (一)图像卷积 1. 图像卷积 图像卷积是进行空间域滤波与梯度运算的基础。首先我们需要理解卷积的运算方式从而可以编程实现。 2. 数字信号处理中的卷积 卷积一词最开始出现在信号与线性系统中，信号与线性系统中讨论的就是信号经过一个线性系统以后发生的变化。
c语言卷积算法
chinayu2007的专栏
11-10 3334
卷积的4个步骤：反折，平移，相
C语言实现卷积运算
陈腾飞的博客
09-26 1万+
考查：卷积计算公式、自定义函数、循环嵌套
用C语言实现卷积计算并绘制出卷积计算前后的结果图形
12-11
通过使用C语言实现卷积的计算过程，实现对任意长度的两个序列进行卷积的求解过程并对，结果绘制出图形
多通道并行卷积神经网络实现
weixin_41534781的博客
09-13 1万+
一、网络结构 多通道并行卷积神经网络主要由多个卷积池化层和全连接层组合而成，其网络结构图如下所示： 二、基于pytorch的实现如下（双通道）： 1.网络模型 class C_lenet(nn.Module): def __init__(self): super(C_lenet, self).__init__() self.conv1 = nn.Sequential( nn.Conv2d(3, 16, 5), nn.R
CNN内部计算及卷积核、通道数关系
dabingsun的博客
03-09 7005
目录 CNN 内部计算 具体实现：tensorflow CNN 局部连接 权值共享 两者目的都是减少参数。通过局部感受视野，通过卷积操作获取高阶特征，能达到比较好的效果。 内部计算 先看卷积与池化示意图：部分图片来自于：链接 标准卷积过程 最大池化层 输入、卷积、池化形状定义: 输入为（长，宽，RGB通道数）=（7*7*3）的图片，即inputs = (bat...
C语言实现卷积.docx
03-29
在C语言中，可以使用循环来实现卷积操作。下面是使用C语言实现卷积的示例代码： ```c conv(int *u, int *v, int m, int n) { int k, i; int len = m + n - 1; int result[100] = {0}; for(k = 0; k ; k++) { ...
MATLAB实现CNN-GRU卷积门控循环单元多特征分类预测（完整源码和数据）
11-14
MATLAB实现CNN-GRU卷积门控循环单元多特征分类预测（完整源码和数据） 数据为多特征分类数据，输入15个特征，分四类,程序乱码是由于版本不一致导致，可以用记事本打开复制到你的文件。 运行环境MATLAB2020b及以上。
二维卷积运算之C语言实现二维卷积运算之C语言实现
09-18
二维卷积运算之C语言实现二维卷积运算之C语言实现 二维卷积运算之C语言实现二维卷积运算之C语言实现
C语言卷积代码——程序
11-21
C语言卷积代码，在VC6.0运行通过，并用MATLAB程序验证过
卷积码C语言实现 好好学习
07-17
卷积码 C语言 实现 好好学习 天天向上 卷积码 C语言 实现 好好学习 天天向上 卷积码 C语言 实现 好好学习 天天向上 卷积码 C语言 实现 好好学习 天天向上
FPGA_图像卷积算法_代码、工程（分辨率可变、支持多通道、8个乘法器）.zip
04-16
FPGA_图像卷积算法_代码、工程（分辨率可变、支持多通道、8个乘法器），以流水并行方式，快速实现算法。
快速 卷积 （用 fft 快速傅里叶变换 做）c 源码
12-04
快速 卷积 （用 fft 快速傅里叶变换 做）c 源码
Matlab实现BO-CNN贝叶斯优化卷积神经网络多输入单输出回归预测（完整源码和数据）
02-14
Matlab实现BO-CNN贝叶斯优化卷积神经网络多输入单输出回归预测（完整源码和数据） 1.data为数据集，输入7个特征，输出1个变量。 2.MainBO_CNN.m为程序主文件，其他为函数文件无需运行。 3.命令窗口输出MAE、MSE、...
MATLAB实现CNN卷积神经网络多输入多输出预测（完整源码和数据）
11-11
MATLAB实现CNN卷积神经网络多输入多输出预测（完整源码和数据） 数据为多输入多输出预测，输入10个特征，输出3个变量,程序乱码是由于版本不一致导致，可以用记事本打开复制到你的文件。 运行环境MATLAB2018b及以上。
obd.zip_Blind-deconvolution_blind_图像反卷积_图像多通道
09-24
这个“obd.zip”压缩包包含的是2009年发布的一个在线盲图像反卷积的源代码，专门针对天文学领域的应用。该算法旨在提高图像质量，特别是在观测条件较差或者成像系统复杂的情况下，如大气湍流、望远镜光学畸变等。 ...
C语言实现矩阵卷积运算
qq_38856421的博客
02-22 4355
直观的说卷积操作可以理解为——每次透过一个较小的“窗口”去覆盖被输入进来的大窗口中的某一部分所得出的结果。每次得出结果后小窗口就会根据步长滑动至下一个位置并重复这一计算过程，最终得到卷积后的输出矩阵结果。 卷积的计算过程可由下图直观说明。 必须注意的是，根据卷积的数学原理，上图中的3*3矩阵实际上是真正卷积核矩阵经逆时针旋转180度所得到的矩阵。再举一详细示例加以说明。 假设卷积核为： 待处理...
C语言实现卷积操作的代码和详细注释
最新发布
09-07
以下是 C 语言实现卷积操作的代码和详细注释： ```c #include <stdio.h> #define ROWS 3 // 卷积核的行数 #define COLS 3 // 卷积核的列数 // 定义卷积核 int kernel[ROWS][COLS] = { {1, , -1}, {1, , -1}, {1, , -1} }; // 定义输入矩阵 int input[5][5] = { {1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15}, {16, 17, 18, 19, 20}, {21, 22, 23, 24, 25} }; // 定义输出矩阵 int output[3][3]; int main() { // 遍历输出矩阵的每一个元素 for (int i = ; i < 3; i++) { for (int j = ; j < 3; j++) { // 计算卷积结果 int sum = ; for (int k = ; k < ROWS; k++) { for (int l = ; l < COLS; l++) { sum += input[i + k][j + l] * kernel[k][l]; } } output[i][j] = sum; } } // 输出结果 for (int i = ; i < 3; i++) { for (int j = ; j < 3; j++) { printf("%d ", output[i][j]); } printf("\n"); } return ; } ``` 注释： 1. `#include <stdio.h>`：引入标准输入输出库。 2. `#define ROWS 3` 和 `#define COLS 3`：定义卷积核的行数和列数。 3. `int kernel[ROWS][COLS]`：定义卷积核。 4. `int input[5][5]`：定义输入矩阵。 5. `int output[3][3]`：定义输出矩阵。 6. `for (int i = ; i < 3; i++)` 和 `for (int j = ; j < 3; j++)`：遍历输出矩阵的每一个元素。 7. `for (int k = ; k < ROWS; k++)` 和 `for (int l = ; l < COLS; l++)`：遍历卷积核的每一个元素。 8. `sum += input[i + k][j + l] * kernel[k][l]`：计算卷积结果。 9. `output[i][j] = sum`：将卷积结果存入输出矩阵。 10. `printf("%d ", output[i][j])`：输出结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值