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

最新推荐文章于 2024-08-01 16:55:04 发布
最新推荐文章于 2024-08-01 16:55:04 发布
阅读量1.5w 收藏 89
点赞数 11
分类专栏： 深度学习C语言实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42585108/article/details/124592646
版权

c语言 卷积神经网络

用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²大大
关注
专栏目录
CNN卷积神经网络原理讲解+图片识别应用（附源码）
学海无涯
06-26 15万+
一、机器如何识图 先给大家出个脑筋急转弯：在白纸上画出一个大熊猫，一共需要几种颜色的画笔？——大家应该都知道，只需要一种黑色的画笔，只需要将大熊猫黑色的地方涂上黑色，一个大熊猫的图像就可以展现出来。 我们画大熊猫的方式，其实和妈妈们的十字绣很接近——在给定的格子里，绣上不同的颜色，最后就可以展现出一幅特定的“图片”。而机器识图的方式正好和绣十字绣的方式相反，现在有了一幅图片，机器通过识别图片中...
卷积神经网络的Python实现,python卷积神经网络训练
super67269的博客
08-14 6963
对于想要自学Python的小伙伴，这里整理了一份系统全面的学习路线，按照这份大纲来安排学习可以少走弯路，事半功倍。第一阶段：专业核心基础阶段目标：1.熟练掌握Python的开发环境与编程核心知识2.熟练运用Python面向对象知识进行程序开发3.对Python的核心库和组件有深入理解4.熟练应用SQL语句进行数据库常用操作5.熟练运用Linux操作系统命令及环境配置6.熟练使用MySQL，掌握数据库高级操作7.能综合运用所学知识完成项目知识点：Python编程基础、Python面向对象、Python高级进阶
C语言实现二维图像卷积
谢军的博客
12-06 7800
相关是滤波器模板移过图像并计算每个位置乘积的处理，但滤波首先要旋转180度，其本质是将卷积核或者图像旋转180度之后的相关操作。
用C语言实现卷积计算并绘制出卷积计算前后的结果图形
12-11
通过使用C语言实现卷积的计算过程，实现对任意长度的两个序列进行卷积的求解过程并对，结果绘制出图形
6-3 卷积层的代码实现
最新发布
Alkali!的博客
08-01 598
接下来，我们在corr2d函数中实现互相关运算过程，该函数接受输入张量X和卷积核张量K，并返回输出张量Y。通过 图6.2.1的输入张量X和卷积核张量K，我们来验证上述二维互相关运算的输出。这个函数KX。这在图像处理中用于特征提取、边缘检测等多种场景。
卷积——C语言实现
热门推荐
有人_295的博客
05-29 2万+
废话： 上信号与系统后，做实验用Matlab做的卷积，一个函数搞定，但是写实验报告时需要用C语言实现，额，虽说原理不难，实现起来浪费了我好久时间 一、卷积公式 Y(n)=x(n)h(n)=∑x(i)h(n-i) 先用Matlab演示卷积，后面以这个为例。 a=[1,2,3,4] b=[1,2,3] conv(a,b) ans = 1 4 10 16 17 12 ...
使用c语言写的卷积运算程序
05-14
标准C语言计算卷积的公式，在VC下编译通过
C语言实现卷积.docx
03-29
用一编程语言实现卷积 本次作业我采用的是C语言来编程实现卷积 C语言卷积实现的代码 里面含有运行结果图
python卷积神经网络代码,python卷积神经网络分类
Supermen333的博客
08-11 3759
上周末利用python简单实现了一个卷积神经网络，只包含一个卷积层和一个maxpooling层，pooling层后面的多层神经网络采用了softmax形式的输出。实验输入仍然采用MNIST图像使用10个featuremap时，卷积和pooling的结果分别如下所示。部分源码如下：[python] viewplain copy#coding=utf-8'''''Created on 2014年11月30日@author: Wangliaofan'''import numpyimport structimpor
二维卷积运算之C语言实现二维卷积运算之C语言实现
09-18
二维卷积运算之C语言实现二维卷积运算之C语言实现 二维卷积运算之C语言实现二维卷积运算之C语言实现
二维卷积之C语言实现
07-03
二维卷积 完整的C代码实现，给出简单的实力
C语言编线性卷积
10-29
用C语言实现线性卷积，有限长序列的线性卷积
C语言卷积代码——程序
11-21
C语言卷积代码，在VC6.0运行通过，并用MATLAB程序验证过
c语言实现的离散卷积程序
03-29
用c语言实现的离散卷积程序，希望对开始学卷积的人有所帮助。
基于CNN（LeNet）的垃圾分类（C语言实现）
eye_s1的博客
01-06 2942
基于CNN（LeNet）的垃圾分类（C语言实现CNN算子）一、先使用python训练模型二、提取参数提取模型参数提取图片三、编写CNN算子在windows中实现在FPGA中实现，使用avalon接口 一、先使用python训练模型 具体步骤参考基于pytorch的MNIST数据集的四层CNN，测试准确率99.77%这篇文章，各种步骤我写的很详细，只需要将MNIST数据集换成垃圾分类的数据集，再调整一下参数就好了。 二、提取参数 提取模型参数 权重和偏置 我们需要提取每一个具有学习的参数的训练层的权重和偏置
卷积的C语言实现
扁豆还在学习
03-07 3767
卷积定义 由于计算机只能进行离散计算，所以用在计算机上的卷积也就该是离散形式，长这样： 卷积性质 卷积和傅里叶变换有很大的瓜葛，怎么瓜葛上的我不清楚，但就是有很大的瓜葛（确信）。 而瓜葛之后的性质却很好用：把用来卷积的两个函数1和函数2进行傅里叶变换之后再乘起来得到一个函数3，再把函数3傅里叶反变换得到函数4，最后得到的函数4就是函数1和函数2的卷积结果。 卷积C代码 #include<s...
C语言实现卷积
amen_yanwang的博客
12-05 2168
C语言实现卷积
卷积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语言卷积编程,卷积C语言实现
weixin_34466671的博客
05-18 1388
这个是很简单，但是真写出来也写了半天保留着看自己以后会不会用到卷积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)=x(0)h(3)+x(1)h(2)+x(2)h(1)+x(3...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值