卷积神经网络相关函数的实现--c语言

最新推荐文章于 2023-12-06 14:28:55 发布
最新推荐文章于 2023-12-06 14:28:55 发布
阅读量1.5k 收藏 22
点赞数 4
分类专栏： C语言 机器学习 文章标签： 卷积 神经网络 卷积神经网络 深度学习 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010835747/article/details/116563399
版权

一、介绍
这里主要介绍卷积相关函数用c语言实现，如卷积、池化、全零填充等等

二、单核单通道卷积

//单卷积 
#define IMG_SIZE 5
#define W_SIZE 3
#define OUT_SIZE 3
int conv(float img[IMG_SIZE][IMG_SIZE], float w[W_SIZE][W_SIZE], float out[OUT_SIZE][OUT_SIZE])
{
	int i,j,k,r,m,n;
	float tmp;
	
	//单张图片卷积 
	for(k = 0; k <= (IMG_SIZE - W_SIZE); k++)//行卷积 
	{
		for(r = 0; r <= (IMG_SIZE - W_SIZE); r++)//列 
		{
			//单次卷积 
			//点对点相乘，然后结果相加 
			tmp = 0.0;
			for(i = 0; i < W_SIZE; i++)//行 
			{
				for(j = 0; j < W_SIZE; j++)//列 
				{
					//单点计算 
					tmp = tmp + img[i+k][j+r]*w[i][j];
				}
			}
			out[k][r] = tmp;
		}
	}
}

int conv_test()
{
	float x[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};
	int i,j,k,r,m,n;
	
	conv(x, conv_w, img_out);
	printf("输入图片\n");
	for(i = 0; i < 5; i++)
	{
		for(j = 0; j < 5; j++)
			printf("%.1f ", x[i][j]);
		printf("\n ");
	}
	
	printf("输出图片\n");
	for(i = 0; i < 3; i++)
	{
		for(j = 0; j < 3; j++)
			printf("%.1f ", img_out[i][j]);
		printf("\n ");
	}
}

三、单通道池化
最大值池化和平均值池化

//池化 
#define IN_SIEZE  4
#define OUT_SIEZE 2
int pool(float in[IN_SIEZE][IN_SIEZE], float out[OUT_SIEZE][OUT_SIEZE])
{
	int i,j;
	float tmp1,tmp2,tmp3;
	
	//单张图片池化 
	for(i = 0; i < IN_SIEZE; i+=2)//行 
	{
		for(j = 0; j < IN_SIEZE; j+=2)//列 
		{
			//单次池化 最大值池化 
			tmp1 = in[i][j] > in[i][j+1] ? in[i][j] : in[i][j+1];
			tmp2 = in[i+1][j] > in[i+1][j+1] ? in[i+1][j] : in[i+1][j+1];
			tmp3 = tmp1 > tmp2 ? tmp1 : tmp2;
			
			out[i/2][j/2] = tmp3;
		}
	}
}

int pool1(float in[IN_SIEZE][IN_SIEZE], float out[OUT_SIEZE][OUT_SIEZE])
{
	int i,j;
	float tmp1,tmp2,tmp3;
	
	//单张图片池化 
	for(i = 0; i < IN_SIEZE; i+=2)//行 
	{
		for(j = 0; j < IN_SIEZE; j+=2)//列 
		{
			//单次池化 平均值池化 
			tmp1 = in[i][j] + in[i][j+1];
			tmp2 = in[i+1][j] + in[i+1][j+1];
			tmp3 = (tmp1 + tmp2)/4;
			
			out[i/2][j/2] = tmp3;
		}
	}
}

int pool_test()
{
	float input[IN_SIEZE][IN_SIEZE] = {
	1,2,3,4,
	5,6,7,8,
	9,10,11,12,
	2,2,3,4
	};
	float output[OUT_SIEZE][OUT_SIEZE]= {0};
	int i,j;
	
	pool(input, output);
	
	printf("最大值池化\n ");
	printf(" 输入图片\n ");
	for(i = 0; i < 4; i++)
	{
		for(j = 0; j < 4; j++)
			printf("%.1f ", input[i][j]);
		printf("\n ");
	}
	printf("输出图片\n ");
	for(i = 0; i < 2; i++)
	{
		for(j = 0; j < 2; j++)
			printf("%.1f ", output[i][j]);
		printf("\n ");
	}
	pool1(input, output);
	printf("平均值池化\n ");
	printf(" 输入图片\n ");
	for(i = 0; i < 4; i++)
	{
		for(j = 0; j < 4; j++)
			printf("%.1f ", input[i][j]);
		printf("\n ");
	}
	printf("输出图片\n ");
	for(i = 0; i < 2; i++)
	{
		for(j = 0; j < 2; j++)
			printf("%.1f ", output[i][j]);
		printf("\n ");
	}
}

四、padding全零填充

#define P_IN_SIZE 4
#define P_OUT_SIZE 6
int padding_1(float in[P_IN_SIZE][P_IN_SIZE], float out[P_OUT_SIZE][P_OUT_SIZE])
{
	int i,j;
	
	//清零输出
	for(i = 0; i < P_OUT_SIZE; i++)
		for(j = 0; j < P_OUT_SIZE; j++)
			out[i][j] = 0.0;
	//填充输入
	for(i = 1; i < (P_OUT_SIZE - 1); i++)
		for(j = 1; j < (P_OUT_SIZE - 1); j++) 
			out[i][j] = in[i-1][j-1];
}

int padding_test()
{
	int i,j;
	float input[P_IN_SIZE][P_IN_SIZE] = {
	1,2,3,4,
	5,6,7,8,
	9,10,11,12,
	2,2,3,4
	};
	float output[P_OUT_SIZE][P_OUT_SIZE];
	
	padding_1(input, output);
	printf(" 输入图片\n ");
	for(i = 0; i < 4; i++)
	{
		for(j = 0; j < 4; j++)
			printf("%.1f ", input[i][j]);
		printf("\n ");
	}
	printf("输出图片\n ");
	for(i = 0; i < 6; i++)
	{
		for(j = 0; j < 6; j++)
			printf("%.1f ", output[i][j]);
		printf("\n ");
	}
}

五、多核多通道卷积

#define IMG_SIZE 7
#define IMG_CH   3
#define CONV_W_SIZE 3
#define CONV_W_CH 3
#define CONV_W_NUM 2
#define CONV_O_SIZE 5
int conv(float img[IMG_SIZE][IMG_SIZE][IMG_CH], 
float conv_w[CONV_W_SIZE][CONV_W_SIZE][CONV_W_CH][CONV_W_NUM],
float out[CONV_O_SIZE][CONV_O_SIZE][CONV_W_NUM])
{
	int i,j,k,r,m,n;
	float tmp1,tmp2;
	
	//多核多通道卷积 
	//多核卷积
	for(r = 0; r < CONV_W_NUM; r++)
	{
		//多特征平面卷卷积 
		for(m = 0; m <= (IMG_SIZE-CONV_W_SIZE); m++)//特征平面行 
		{
			for(n = 0; n <= (IMG_SIZE-CONV_W_SIZE); n++)//特征平面的列 
			{
				tmp2 = 0.0;//清零多通道单次卷积结果 
				//多通道 
				for(k = 0; k < IMG_CH; k++)
				{
					tmp1 = 0.0;//清零单次卷积结果 
					//单次卷积
					for(i = 0; i < CONV_W_SIZE; i++)//卷积核行
					{
						for(j = 0; j < CONV_W_SIZE; j++)//卷积核列
						{
							//单点计算 
							tmp1 = tmp1 + img[i+m][j+n][k]*conv_w[i][j][k][r];
						}
					}
					//累加多个特征平面的卷积结果
					tmp2 = tmp2 + tmp1;
				}
				//偏置
				
				//激活 
				
				out[m][n][r] = tmp2;
			}
		}
	}
}

int conv_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_W_NUM][CONV_W_CH][CONV_W_SIZE][CONV_W_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 conv1_w[CONV_W_SIZE][CONV_W_SIZE][CONV_W_CH][CONV_W_NUM] = {0};
	float output[CONV_O_SIZE][CONV_O_SIZE][CONV_W_NUM] = {0};
	
	int i,j,k,r,m,n;
	printf("imge data \n");
	for(i = 0; i < IMG_CH; i++)
	{
		for(j = 0; j < IMG_SIZE; j++)
		{
			for(k = 0; k < IMG_SIZE; k++)
			{
				input1[j][k][i] = input[i][j][k];
				printf("%.1f ", input1[j][k][i]);
			}
			printf("\n");
		}
		printf("\n");
	}
	printf("\n");
	printf("conv w \n");
	for(i = 0; i < CONV_W_NUM; i++)
	{
		for(j = 0; j < CONV_W_CH; j++)
		{
			for(k = 0; k < CONV_W_SIZE; k++)
			{
				for(r = 0; r < CONV_W_SIZE; r++)
				{
					conv1_w[k][r][j][i] = conv_w[i][j][k][r];
					printf("%.1f ", conv1_w[k][r][j][i]);
				}
				printf("\n");
			}
			printf("\n");
		}
		printf("\n");
	}
	printf("\n");
	conv(input1, conv1_w, output);
	
	printf("result data \n");
	for(i = 0; i < CONV_W_NUM; i++)
	{
		for(j = 0; j < CONV_O_SIZE; j++)
		{
			for(k = 0; k < CONV_O_SIZE; k++)
			{
				printf("%.1f ", output[j][k][i]);
			}
			printf("\n");
		}
		printf("\n");
	}
}

六、多维转一维

#define SW_IN_SIZE  3
#define SW_IN_CH	3
#define SW_OUT_LEN (SW_IN_SIZE*SW_IN_SIZE*SW_IN_CH)
int Narry_1(float in[SW_IN_SIZE][SW_IN_SIZE][SW_IN_CH], float out[SW_OUT_LEN])
{
	int i,j,k;
	float *p = out;
	
	for(i = 0; i < SW_IN_CH; i++)
	{
		for(j = 0; j < SW_IN_SIZE; j++)
		{
			for(k = 0; k < SW_IN_SIZE; k++)
			{
				#if 1
				*p = in[j][k][i];
				p++;
				#else
				out[(i*SW_IN_SIZE*SW_IN_SIZE + j*SW_IN_SIZE + k)] = in[j][k][i];
				#endif
			}
		}
	}
}

int Narry_1_test()
{
	float input[SW_IN_CH][SW_IN_SIZE][SW_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[SW_IN_SIZE][SW_IN_SIZE][SW_IN_CH];
	
	float output[SW_IN_SIZE*SW_IN_SIZE*SW_IN_CH] = {0};
	int i,j,k;
	float *p = output;
	
	//转换输入 
	for(i = 0; i < SW_IN_CH; i++)
	{
		for(j = 0; j < SW_IN_SIZE; j++)
		{
			for(k = 0; k < SW_IN_SIZE; k++)
			{
				input1[j][k][i] = input[i][j][k];
				printf("%.1f ", input1[j][k][i]);
			}
			printf("\n");
		}
		printf("\n");
	}
	Narry_1(input1, output);
	
	printf("input data \n");
	for(i = 0; i < SW_IN_CH; i++)
	{
		for(j = 0; j < SW_IN_SIZE; j++)
		{
			for(k = 0; k < SW_IN_SIZE; k++)
			{
				printf("%.1f ", input1[j][k][i]);
			}
			printf("\n");
		}
		printf("\n");
	}
	printf("output data \n");
	for(i = 0; i < SW_IN_CH; i++)
	{
		for(j = 0; j < SW_IN_SIZE; j++)
		{
			for(k = 0; k < SW_IN_SIZE; k++)
			{
				printf("%.1f ", *p);
				p++;
			}
			printf(" ");
		}
		printf(" ");
	}
}
锅锅是锅锅
关注
  • 4
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
卷积神经网络 c语言代码,【CNN】卷积神经网络(示例代码)
weixin_33347911的博客
05-24 2660
什么是卷积神经网络卷积神经网络是一种特殊的、简化的深层神经网络模型，它的每个卷积层都是由多个卷积滤波器组成。它最先由lecun在LeNet[40]中提出，网络结构如下图所示。在cnn中，图像的一小部分(局部感受区域)作为层级结构的最低层的输入，信息再依次传输到不同的层，每层通过多个卷积滤波器去获得观测数据的最显著的特征。卷积神经网络中的每一个特征提取层(卷积层)都紧跟着一个用来求局部平均与二次提取...
编写C语言版本的卷积神经网络CNN之二：CNN网络的总体结构
热门推荐
tostq的专栏
06-29 2万+
卷积神经网络是深度学习的基础，但是学习CNN却不是那么简单，虽然网络上关于CNN的相关代码很多，比较经典的是tiny_cnn（C++）、DeepLearnToolbox（Matlab）等等，但通过C语言来编写CNN的却比较少，本人因为想在多核DSP下运行CNN，所以便尝试通过C语言来编写，主要参考的代码是DeepLearnToolbox的内容，DeepLearnToolbox是用Matlab脚本编写，是我看过的最为简单的CNN代码，代码清晰，阅读方便，非常适合新手入门学习。本文的CNN代码是一个最基本的卷积
matlab编写识别手写数字_编写C语言版本的卷积神经网络CNN之一：前言与Minst数据集（转载）...
weixin_39626298的博客
11-20 237
原文作者：tostq原文链接：http://blog.csdn.net/tostq前言 卷积神经网络是深度学习的基础，但是学习CNN却不是那么简单，虽然网络上关于CNN的相关代码很多，比较经典的是tiny_cnn（C++）、DeepLearnToolbox（Matlab）等等，但通过C语言来编写CNN的却比较少，本人因为想在多核DSP下运行CNN，所以便尝试通过C语言来编写，主要参考的...
深度学习之卷积神经网络编程实现（二）
grafx的专栏
01-15 6883
目前网上深度学习有关资料巨多，但多数都是转载，就算原创，但很多也是光说不练，理论公式一堆，但是靠谱代码没几行，能用的更是少之又少。paper看的溜、code写的溜的人还是比较少的。
卷积神经网络的C语言实现
lihui1996524的博客
01-10 5030
卷积神经网络的C语言实现 代码实现环境是vs2019,po主使用这个代码实现了lenet-5模型的向前传播过程。不过可以通过改变主函数中的参数来实现其他模型。由于作者学艺不精，本代码只能实现卷积步长为1，池化方式只能选择最大池化，激活函数目前只写了Relu。如果小伙伴们有其他需求，可以自己修改代码~~ 工程的实现主要分为两部分 第一部分是在python上做的分为以下几个步骤。 1.搭建模型以及训练...
用C语言实现一个简单的卷积神经网络
Java、C语言、嵌入式开发，计算机科学与技术专业（海南大学）
05-29 1027
上述代码演示了一个简单的卷积神经网络模型，创建了一个包含3个过滤器（filters）的模型，每个过滤器的大小为3x3。然后给定一个5x5的输入矩阵，通过前向传播计算了输出矩阵。最后打印了输出矩阵。请注意，此代码仅用于演示目的，实际的卷积神经网络模型可能需要更复杂的结构和算法来实现。
如何在STM32上部署卷积神经网络（纯C语言搭建）
太白断水客
02-26 1万+
介绍编写神经网络的基本思路和代码介绍
卷积神经网络原理及其C++/Opencv实现(6)—前向传播代码实现
生活需要深度
07-29 586
在以上文章中，我们基本把5层网络的原理、公式推导讲过了，从本文开始，我们来讲一下基于C++和Opencv的5层卷积神经网络实现吧~需要注意的是，在卷积神经网络中，我们说的卷积运算其实是互相关运算，也即开始卷积运算之前卷积核不需要做顺时针180°的旋转。以下函数中，vec1和vec2是两个长度相同的一维向量，点乘的结果就是它们对应位置的值相乘，然后把所有乘积相加的结果。好了，本文就讲到这里，接下来的文章我们来讲反向传播的实现和参数更新的实现，敬请期待~...
卷积神经网络 c语言,图像处理之C语言实现二维卷积
weixin_42358261的博客
05-19 715
在用C语言实现图像处理中，经常要用到二维卷积的运算，这个在matlab中是非常容易实现的，只需要conv2()就OK啦，而且速度非常的快。但是在C语言中就需要四层的for循环来实现了。首先二维卷积的原理是：123 222A= 123B=111123 333单我们使用A和B卷积时，首先需要将B旋转1...
C++卷积神经网络
qq_42877866的博客
08-26 1560
C++卷积神经网络
200个C语言常用函数实现代码大全.rar
03-31
200个C语言常用函数实现代码大全
C语言函数库大全.txt
04-20
C语言函数库大全
发那科机器人操作的C语言函数库及说明，支持多个操作系统
04-10
发那科机器人操作的C语言函数库及说明，支持多个操作系统
C 代码 计算函数 f（x） 的格根鲍尔加权积分 使用克伦肖-柯蒂斯方法.rar
05-26
C语言实现的功能，金品源码
C 代码 最小化多个变量的标量函数 使用Nelder-Mead算法.rar
05-26
实用的C语言实现代码
用 C 写一个卷积神经网络
最新发布
zerok的专栏
12-06 2589
用 C 语言从 0 写一个卷积神经网络
cnn c语言,编写C语言版本的卷积神经网络CNN之一：前言与Minst数据集
weixin_39788256的博客
05-19 1109
原创文章转载请注册来源http://blog.csdn.net/tostq前言卷积神经网络是深度学习的基础，但是学习CNN却不是那么简单，虽然网络上关于CNN的相关代码很多，比较经典的是tiny_cnn(C++)、DeepLearnToolbox(Matlab)等等，但通过C语言来编写CNN的却比较少，本人因为想在多核DSP下运行CNN，所以便尝试通过C语言来编写，主要参考的代码是DeepLear...
卷积神经网络原理及其C++/Opencv实现(2)
生活需要深度
07-29 732
对于分类问题，在网络的最后需要输出各个类别的概率，并认为最大概率的类别为最终分类结果，因此在Affine层之后还需要连接一层输出层，把每个类别的输出值转换为0~1之间的概率，转换函数通常使用Softmax函数。既然是窗口滑动，就涉及到滑动步长step的选择，step可以取固定的1，2，3...，但是要求满足条件step+c...
用C语言构建一个数字识别卷积神经网络
midaszhk的博客
08-04 1550
为3x3的卷积层, 默认8个卷积核, 采用valid_padding(不填充),移动扫描步长为1. 需要通过训练来确定各个卷积核参数. 3x3的卷积核相比5x5和7x7的卷积核其参数量更少，非线性度更高，同时可以提取更小的特征. (5x5和7x7的卷积可以用多层3x3卷积来表示, 当然，随着层数的增加可能会产生新的问题.) 卷积层的输入部分就是灰度值表示的28x28的手写数字图像,这里也预先进行了归一化处理，即除以255.0．。取5万条训练样本进行训练，训练后再进行测试，其准确率可超过94%．。
用c语言复刻一个卷积神经网络
03-31
抱歉，作为AI语言模型，我无法提供代码复刻卷积神经网络的任务。但我可以向您解释卷积神经网络的基本原理和结构。...如果您有兴趣，可以学习深度学习相关的知识，然后使用C语言或其他编程语言实现一个卷积神经网络。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值