卷积C语言实现

最新推荐文章于 2024-06-21 20:58:26 发布
最新推荐文章于 2024-06-21 20:58:26 发布
阅读量2.2k 收藏 8
点赞数 1
分类专栏： darknet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lbaihao/article/details/108416345
版权

Keras入门（四）之利用CNN模型轻松网站验证码

 

https://frank909.blog.csdn.net/article/details/103149407?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-18.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-18.control

一文看懂YOLO v3

https://blog.csdn.net/jclian91/article/details/88777456?utm_medium=distribute.pc_relevant.none-task-blog-title-2&spm=1001.2101.3001.4242

https://www.zhihu.com/collection/366298672

opencv : https://github.com/gzr2017/ImageProcessing100Wen/blob/master/Question_01_10/answers_py/answer_1.py

https://blog.csdn.net/weixin_42109012/article/details/90680460?utm_medium=distribute.pc_relevant_download.none-task-blog-blogcommendfrombaidu-1.nonecase&depth_1-utm_source=distribute.pc_relevant_download.none-task-blog-blogcommendfrombaidu-1.nonecas

https://blog.csdn.net/qq_38269418/article/details/78991649?utm_medium=distribute.pc_relevant.none-task-blog-title-2&spm=1001.2101.3001.4242 

pyQT5 http://code.py40.com/1995.html

Embedding理解与代码实现

https://hichenway.blog.csdn.net/article/details/85100616?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control

 

 

 

卷积的三种模式：full,same,valid

这三种模式是对卷积核移动范围的不同限制

1、full mode

橙色部分为image(大小为N1*M1),蓝色部分为filter(大小为N2*M2),full模式下输出矩阵大小为(N1+N2-1)*(M1+M2-1)

即从filter右下角一个单元与image的第一个单元重叠开始计算，依次将filter的右下角单元与image的每一个单元重叠并计算。

2、same mode

将filter中心与image左上角单元重合，并依次与image的每个单元重合计算，最终输出结果为N1*M1

3、valid mode

filter在image内部进行卷积运算

 

需要注意的是，‘same’和‘full’只是将被卷积的矩阵做了相应尺寸的0填充后再进行‘valid’卷积即可。

此处默认步长1。

三种卷积操作的示意图：

Valid：

Same：

Full：

 

 

 

C语言代码实现

 

  1. #include<stdio.h>

  2.  

  3. #define N1 3

  4. #define M1 3

  5. #define N2 3

  6. #define M2 3

  7.  

  8. //x需要运算的矩阵

  9. //y卷积核

  10. //z(full模式的输出)

  11. //z2(same模式的输出)

  12. int x[N1][M1];//需要运算矩阵

  13. int y[N2][M2];//卷积核

  14. int z[N1+N2-1][M1+M2-1];//full模式下的输出

  15. int z2[N1][M1];//same模式下的输出

  16.  

  17. void conv2(int x[N1][M1],int y[N2][M2],int z[N1+N2-1][M1+M2-1],int z2[N1][M1])

  18. {

  19. int i,j;

  20. int n,m;

  21. for(i=0; i<N1+N2-1; i++)

  22. for(j=0; j<M1+M2-1; j++)

  23. {

  24. int temp = 0;

  25. for(m=0; m<N1; m++)

  26. for(n=0; n<M1; n++)

  27. if((i-m)>=0&&(i-m)<N2&&(j-n)>=0&&(j-n)<M2)

  28. temp+=x[m][n]*y[i-m][j-n];

  29. z[i][j]=temp;

  30. }

  31. for(i=0; i<N1; i++)

  32. for(j=0; j<M1; j++)

  33. {

  34. z2[i][j]=z[i+(N2-1)/2][j+(M2-1)/2];

  35. }

  36.  
  37.  
  38.  

  39. }

  40.  
  41.  

  42. int main()

  43. {

  44. int i,j;

  45.  
  46.  

  47. printf("请输入需要运算的矩阵：\n");

  48. for(i=0;i<N1;i++)

  49. {

  50. for(j=0;j<M1;j++)

  51. {

  52. scanf("%d",&x[i][j]);

  53. }

  54.  

  55. }

  56.  

  57. printf("请输入卷积核：\n");

  58. for(i=0;i<N2;i++)

  59. {

  60. for(j=0;j<M2;j++)

  61. {

  62. scanf("%d",&y[i][j]);

  63. }

  64.  

  65. }

  66.  

  67. conv2(x,y,z,z2);//卷积运算

  68.  

  69. printf("same model下结果输出：\n");

  70. for(i=0;i<N1;i++)

  71. {

  72. for(j=0;j<M1;j++)

  73. {

  74. printf("%d ",z2[i][j]);

  75. }

  76.  

  77. printf("\n");

  78. }

  79.  

  80. return 0;

  81. }

 

 

上信号与系统后，做实验用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
  • 1
  • 2
  • 3
  • 4
  • 5

二、对卷积的求解

这个一般有两种方法实现
1、第一种是交叉相乘相加法（对于1维的卷积，注意一定要将其中一个倒叙或者翻转180度）

在这里插入图片描述
对于同一时间接触到的面积进行相乘，再相加即是这个时刻的值
例子
在这里插入图片描述
代码实现

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

int min(int x, int y) {
	return x < y ? x : y;
}

int max(int x, int y) {
	return x > y ? x : y;
}

void convolution(int* input1, int* input2, int* output, int mm, int nn)
{
	//存储地址
	int* xx = (int*)malloc(sizeof(int) * (mm + nn - 1));
	//开始卷积
	for (int i = 0; i < mm + nn - 1; i++)
	{
		xx[i] = 0;
		//以位数最少的卷积作为卷积次数
		for (int j = 0; j < min(mm,nn) ; j++) {
			//第一个卷积比第二个卷数积少执行
			if (mm <= nn) {
				if (i - j >= 0 && i - j < max(mm, nn)) {
					printf("%d ", input1[j]);
					printf("%d ", input2[i-j]);
					xx[i] += input1[j] * input2[i - j];
				}
			}
			//第一个卷积比第二个卷积数多执行
			else {
				if (i - j >= 0 && i - j < max(mm, nn)) {
					printf("%d ", input1[i-j]);
					printf("%d ", input2[j]);
					xx[i] += input2[j] * input1[i - j];
				}
			}
			printf("\n");
		}
	}
	printf("\n");
	for (int i = 0; i < mm+nn-1; i++) {
		output[i] = xx[i];
	}
	delete[] xx;
}

int main() {
	int mm, nn;
	printf("请输入第一个卷积数目\n");
	scanf_s("%d", &mm);

	//malloc分配空间
	int* input1 = (int*)malloc(sizeof(int) * mm);
	printf("请输入第一个卷积数值\n");
	for (int i = 0; i < mm; i++) {
		scanf_s("%d", &input1[i]);
	}
	printf("请输入第二个卷积数目\n");
	scanf_s("%d", &nn);
	int* input2 = (int*)malloc(sizeof(int) * nn);
	printf("请输入第二个卷积数值\n");
	for (int j = 0; j < nn; j++) {
		scanf_s("%d", &input2[j]);
	}

	//卷积最大空间
	int* output = (int*)malloc(sizeof(int) * (mm+nn-1));
	convolution(input1, input2, output, mm, nn);

	printf("卷积结果\n");
	for (int i = 0; i < mm + nn - 1; i++)
	{
		printf("%d ", output[i]);
	}
	printf("\n");

	return 0;
}
  • 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
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79

在这里插入图片描述

二、第二种方法是时延法（第二种方法相对来说比较简单，转到z域后，卷积变为多项式相乘，不需要对序列进行移动或处理，仅将结果延时相应位数，然后对应相加、提取系数即可。）

已知y[0] = i, y[1] = j, y[2]=k
这里写图片描述
下面通过演示求x[n] * y[n]的过程，揭示卷积的物理意义。
第一步，x[n]乘以y[0]并平移到位置0
在这里插入图片描述

第二步，x[n]乘以y[1]并平移到位置1
这里写图片描述
第三步，x[n]乘以y[2]并平移到位置2：
在这里插入图片描述
最后，把上面三个图叠加，就得到了x[n] * y[n]：
这里写图片描述
简单吧？无非是平移（没有反褶！）、叠加。
实例
在这里插入图片描述代码实现

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

void convolution2(int* input1, int* input2, int* output, int mm, int nn)
{
	//存储地址
	int* xx = (int*)malloc(sizeof(int) * (mm + nn - 1));
	for (int i = 0; i < mm + nn - 1; i++) {
		xx[i] = 0;
	}

	//开始卷积
	//利用时延效果，记录所有乘积后，时间位置一样的相加
	for (int i = 0; i < mm; i++) {
		for (int j = 0; j < nn; j++) {
			xx[i + j] += input1[i] * input2[j];
		}
	}

	for (int i = 0; i < mm + nn - 1; i++) {
		output[i] = xx[i];
	}
	delete[] xx;
}

int main() {
	int mm, nn;
	printf("请输入第一个卷积数目\n");
	scanf_s("%d", &mm);

	//malloc分配空间
	int* input1 = (int*)malloc(sizeof(int) * mm);
	printf("请输入第一个卷积数值\n");
	for (int i = 0; i < mm; i++) {
		scanf_s("%d", &input1[i]);
	}
	printf("请输入第二个卷积数目\n");
	scanf_s("%d", &nn);
	int* input2 = (int*)malloc(sizeof(int) * nn);
	printf("请输入第二个卷积数值\n");
	for (int j = 0; j < nn; j++) {
		scanf_s("%d", &input2[j]);
	}

	//卷积最大空间
	int* output = (int*)malloc(sizeof(int) * (mm + nn - 1));
	convolution2(input1, input2, output, mm, nn);

	printf("卷积结果\n");
	for (int i = 0; i < mm + nn - 1; i++)
	{
		printf("%d ", output[i]);
	}
	printf("\n");

	return 0;
}
  • 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
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

运行结果

 

https://blog.csdn.net/jclian91/article/details/83024344

 

https://blog.csdn.net/weixin_33994429/article/details/88714099?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-6.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-6.channel_param

lbaihao
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
卷积——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语言卷积编程,卷积C语言实现
weixin_34466671的博客
05-18 1342
这个是很简单，但是真写出来也写了半天保留着看自己以后会不会用到卷积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...
卷积和池化
lbr15660656263的博客
06-21 922
（1）卷积对于卷积经过某层后的特征图大小计算方式：h2 = （h1-k+2p）/s + 1 w2 = （w1-k+2p）/s + 1总结：卷积输出大小=[（输入大小-卷积核大小+2*Padding）／步长]+1 所以当stride为1时,当卷积核的大小比padding的两倍大1时，可以不改变特征图的尺寸，只改变通道数。卷积的计算过程非常简单，当卷积核在输入图像上扫描时，将卷积核与输入图像中对应位置的数值逐个相乘，最后汇总求和，就得到该位置的卷积结果。不断移动卷积核，就可算出各个位置的卷积结果。
c语言卷积编程,卷积原创C语言卷积代码
weixin_39851008的博客
05-18 414
//说明运行环境Visual C++6.0#inc lude"stdio.h"int table_a[6]={1,2,3,4,5,6};//原数组A-给定int table_b[6]={6,2,3,6,4,2};//原数组B-给定void My_Convo lut ion(int *Tab_A,int *Tab_B){int temp=0;int i=0;int j=0;int k=0;int L...
C语言实现卷积
amen_yanwang的博客
12-05 2064
C语言实现卷积
用C语言实现卷积操作（包含单通道单卷积和多通道多卷积以及维度的转换）
热门推荐
qq_42585108的博客
05-05 1万+
用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_
离散卷积的C语言实现
geduo4612的专栏
03-02 1万+
卷积公式可以去wiki上搜索，这里就不贴出了，具体的算法要参考MATLAB help中查看conv函数。根据conv的定义，我写出下面的程序，可以直接在MATLAB进行验证。唉，虽然程序是写出来，可心里对卷积还是有一种抓不住的感觉，这是为什么？ #include #include conv(int *u,int *v, int m, int n);void ma
C语言实现卷积.docx
03-29
"C语言实现卷积" C语言是编程语言中的一种，广泛应用于操作系统、嵌入式系统、游戏开发等领域。卷积是信号处理中的一种基本操作，用于计算两个信号的乘积。下面是对C语言实现卷积的知识点总结： 一、卷积的定义 ...
数字信号卷积C语言实现
05-22
本文件为数字信号的卷积用C语言实现，简单代码
二维卷积运算之C语言实现二维卷积运算之C语言实现
09-18
二维卷积运算之C语言实现二维卷积运算之C语言实现 二维卷积运算之C语言实现二维卷积运算之C语言实现
卷积运算C代码
06-18
卷积运算在数字信号处理中应用广泛，我自己运行过，代码没有错误，分享一下
juanji.rar_c语言 卷积_c语言卷积_c语言数组卷积_二维卷积_卷积C语言
09-21
在这个“juanji.rar”压缩包中，我们找到了一个使用C语言实现的二维数组卷积算法。 卷积是一种数学运算，通常用于分析信号或图像，通过将两个函数结合来得到一个新的函数，这个新函数描述了原始函数如何相互作用。...
C语言实现卷积(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-20 309
C语言实现卷积(附完整源码)
卷积的C语言实现
扁豆还在学习
03-07 3591
卷积定义 由于计算机只能进行离散计算，所以用在计算机上的卷积也就该是离散形式，长这样： 卷积性质 卷积和傅里叶变换有很大的瓜葛，怎么瓜葛上的我不清楚，但就是有很大的瓜葛（确信）。 而瓜葛之后的性质却很好用：把用来卷积的两个函数1和函数2进行傅里叶变换之后再乘起来得到一个函数3，再把函数3傅里叶反变换得到函数4，最后得到的函数4就是函数1和函数2的卷积结果。 卷积C代码 #include<s...
C语言实现卷积运算
陈腾飞的博客
09-26 1万+
考查：卷积计算公式、自定义函数、循环嵌套
用C语言实现一个简单的卷积神经网络
Java、C语言、嵌入式开发，计算机科学与技术专业（海南大学）
05-29 1174
上述代码演示了一个简单的卷积神经网络模型，创建了一个包含3个过滤器（filters）的模型，每个过滤器的大小为3x3。然后给定一个5x5的输入矩阵，通过前向传播计算了输出矩阵。最后打印了输出矩阵。请注意，此代码仅用于演示目的，实际的卷积神经网络模型可能需要更复杂的结构和算法来实现。
C/C++ 卷积算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-08 2378
卷积算法的核心思想是通过卷积操作来提取输入数据中的特征。具体而言，它将卷积核与输入数据进行逐点相乘，然后将乘积累加得到输出结果的对应位置的值。这个过程可以看作是在输入数据的局部区域进行加权求和，从而达到提取特征的目的。卷积算法是一种常用的信号处理技术，用于图像处理、音频处理、自然语言处理等领域。简而言之，卷积算法将两个函数进行运算，其中一个函数作为输入，另一个函数通常称为卷积核或滤波器。
pillow-10.4.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl
最新发布
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
两个长度为4的复数序列进行卷积c语言实现步骤
05-27
下面是两个长度为4的复数序列进行卷积的C语言实现步骤： 1. 定义复数结构体 ``` typedef struct { float real; float imag; } complex; ``` 2. 实现FFT算法 可以使用已有的FFT库，如FFTW，也可以手动实现FFT算法。 3. 实现复数卷积 ``` void complex_convolve(complex x[], complex y[], int n) { int i; complex *tmp = malloc(n * sizeof(complex)); // 对x和y分别进行FFT fft(x, n); fft(y, n); // 将x和y相乘 for (i = 0; i < n; i++) { tmp[i].real = x[i].real * y[i].real - x[i].imag * y[i].imag; tmp[i].imag = x[i].real * y[i].imag + x[i].imag * y[i].real; } // 对相乘结果进行IFFT ifft(tmp, n); // 将结果赋值给x for (i = 0; i < n; i++) { x[i].real = tmp[i].real; x[i].imag = tmp[i].imag; } free(tmp); } ``` 4. 调用复数卷积函数 ``` int main() { int n = 4; complex x[] = {{1, 0}, {2, 0}, {3, 0}, {4, 0}}; complex y[] = {{1, 0}, {1, 0}, {1, 0}, {1, 0}}; complex_convolve(x, y, n); int i; for (i = 0; i < n; i++) { printf("(%f, %f)\n", x[i].real, x[i].imag); } return 0; } ``` 以上代码实现了两个长度为4的复数序列进行卷积，结果存储在第一个序列x中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值