用C语言实现单通道的卷积(conv )、池化(max and average pooling、填充（Padding）

已于 2022-04-26 09:21:00 修改
阅读量2.5k 收藏 25
点赞数 7
分类专栏： C语言 深度学习C语言实现 文章标签： c语言 开发语言 后端 神经网络 深度学习
于 2021-10-22 17:18:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42585108/article/details/120909976
版权

用C语言实现单通道的卷积 、激活、池化、全连接

一、单通道的卷积 conv

#include <stdio.h>

//单卷积
//IMG:5x5    kernel:3x3    out:3x3   
//计算公式：(f-w+2p)/s + 1       
//其中f是矩阵的大小  w是卷积核的大小 p是padding填充 s是步长（默认为1）
#define IMG_SIZE 5
#define W_SIZE 3
#define OUT_SIZE 3   // 根据计算公式： (5-3+2*0)/1 +1 = 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;

    float tmp;
    // 步长s=1滑动 进行 行卷积核列卷积
    for(k=0;k<=IMG_SIZE-W_SIZE;k++)  //行卷积
    {
        for(r=0;r<=IMG_SIZE-W_SIZE;r++)  //列卷积
        {
            tmp = 0.0f;  //每次计算时需要将tmp清零  来存放下一次的值（避免计算叠加）
            //单点卷积计算
            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;
        }
    } 
    return 0;
}

void conv_test()
{
    
    //输入图片
    float img[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];

    int i,j; 
    //打印输入图片数据
    printf("input picture data:\n");
    for(i=0;i<IMG_SIZE;i++)
    {
        for(j=0;j<IMG_SIZE;j++)
        {
            printf("%.1f ",img[i][j]);
        }
        printf("\n");
    }
    //打印输入权重数据
    printf("input weight data:\n");
    for(i=0;i<W_SIZE;i++)
    {
        for(j=0;j<W_SIZE;j++)
        {
            printf("%.1f ",conv_w[i][j]);
        }
        printf("\n");
    }

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

    //打印输出权重数据
    printf("output picture data:\n");
    for(i=0;i<OUT_SIZE;i++)
    {
        for(j=0;j<OUT_SIZE;j++)
        {
            printf("%.1f ",img_out[i][j]);
        }
        printf("\n");
    }

}

int main()
{
    conv_test();  
    return 0;
}

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

二、单通道池化pooling

1.max_pooling 最大池化

//单通道最大池化 max_pooling
#define IMG_POOL_SIZE 4
#define OUT_POOL_SIZE 2 
int max_pooling(float img[IMG_POOL_SIZE][IMG_POOL_SIZE],float out[OUT_POOL_SIZE][OUT_POOL_SIZE])
{
    int i,j,k,r;
    float tmp1,tmp2,tmp3;
    for(i=0,k=0;i<IMG_POOL_SIZE,k<OUT_POOL_SIZE;i=i+2,k++)
    {
         
        for(j=0,r=0;j<IMG_POOL_SIZE,r<OUT_POOL_SIZE;j=j+2,r++)
        {
           
            tmp1 = 0.0f;
            tmp2 = 0.0f;
            tmp3 = 0.0f;
            tmp1 = img[i][j] > img[i][j+1] ? img[i][j]:img[i][j+1];
            tmp2 = img[i+1][j] > img[i+1][j+1] ? img[i+1][j] : img[i+1][j+1];
            tmp3 = tmp1 > tmp2 ? tmp1:tmp2;
            out[k][r] = tmp3;
        } 
         
    }
    
    return 0;
}

void max_pooling_test()
{
    //输入图片
    float img[IMG_POOL_SIZE][IMG_POOL_SIZE] = { 
                    5,6,1,0,
                    3,2,3,8,
                    5,6,9,1,
                    7,8,6,7
                    };
    
    //存放输出的结果
    float img_out[OUT_POOL_SIZE][OUT_POOL_SIZE];

    int i,j; 
    //打印输入图片数据
    printf("input picture data:\n");
    for(i=0;i<IMG_POOL_SIZE;i++)
    {
        for(j=0;j<IMG_POOL_SIZE;j++)
        {
            printf("%.1f ",img[i][j]);
        }
        printf("\n");
    }

    //调用最大池化函数
    max_pooling(img,img_out);

    //打印输出图像数据
    printf("output picture data:\n");
    for(i=0;i<OUT_POOL_SIZE;i++)
    {
        for(j=0;j<OUT_POOL_SIZE;j++)
        {
            printf("%.1f ",img_out[i][j]);
        }
        printf("\n");
    }
}
int main()
{
    //conv_test();  
    max_pooling_test();
    //average_pooling_test();
    //padding_test();
    return 0;
}

在这里插入图片描述

2.average_pooling 平均池化

//单通道平均池化maxpooling
#define IMG_POOL_SIZE 4
#define OUT_POOL_SIZE 2 

int average_pooling(float img[IMG_POOL_SIZE][IMG_POOL_SIZE],float out[OUT_POOL_SIZE][OUT_POOL_SIZE])
{
    int i,j,k,r;
    float tmp1,tmp2,tmp3;
    for(i=0,k=0;i<IMG_POOL_SIZE,k<OUT_POOL_SIZE;i=i+2,k++)
    {
         
        for(j=0,r=0;j<IMG_POOL_SIZE,r<OUT_POOL_SIZE;j=j+2,r++)
        {
           
            tmp1 = 0.0f;
            tmp2 = 0.0f;
            tmp3 = 0.0f;
            tmp1 = img[i][j] + img[i][j+1];
            tmp2 = img[i+1][j] + img[i+1][j+1];
            tmp3 = tmp1 + tmp2 ;
            out[k][r] = tmp3/4;
        } 
         
    }
}

void average_pooling_test()
{
    //输入图片
    float img[IMG_POOL_SIZE][IMG_POOL_SIZE] = { 
                    5,6,1,0,
                    3,2,3,8,
                    5,6,9,1,
                    7,8,6,7
                    };
    
    //存放输出的结果
    float img_out[OUT_POOL_SIZE][OUT_POOL_SIZE];

    int i,j; 
    //打印输入图片数据
    printf("input picture data:\n");
    for(i=0;i<IMG_POOL_SIZE;i++)
    {
        for(j=0;j<IMG_POOL_SIZE;j++)
        {
            printf("%.1f ",img[i][j]);
        }
        printf("\n");
    }

    //调用池化函数
    average_pooling(img,img_out);

    //打印输出图像数据
    printf("output picture data:\n");
    for(i=0;i<OUT_POOL_SIZE;i++)
    {
        for(j=0;j<OUT_POOL_SIZE;j++)
        {
            printf("%.1f ",img_out[i][j]);
        }
        printf("\n");
    }
}
int main()
{
    //conv_test();  
    //max_pooling_test();
    average_pooling_test();
    //padding_test();
    return 0;
}

在这里插入图片描述

三、填充（Padding）

//padding  使得图像卷积后的输入和输出不变   
// 根据计算公式： (4-3+2*p)/1 +1 = 4  ->p=1
//
#define IMG_P_SIZE 4
#define Padding 1  
#define OUT_P_SIZE (Padding*2 + IMG_P_SIZE)

int padding(float img[IMG_P_SIZE][IMG_P_SIZE],float out[OUT_P_SIZE][OUT_P_SIZE])
{
    int i,j;
    //先全部填充为0 
     for(i=0;i<OUT_P_SIZE;i++)
    {
        for(j=0;j<OUT_P_SIZE;j++)
        {
            out[i][j] = 0.0f;
        }
    }

    for(i=1;i<OUT_P_SIZE-1;i++)
    {
        for(j=1;j<OUT_P_SIZE-1;j++)
        {
            out[i][j] = img[i-1][j-1];
        }
    }
}

void padding_test()
{
    //输入图片
    float img[IMG_P_SIZE][IMG_P_SIZE] = { 
                    5,6,1,0,
                    3,2,3,8,
                    5,6,9,1,
                    7,8,6,7
                    };
    
    //存放输出的结果
    float img_out[OUT_P_SIZE][OUT_P_SIZE];

    int i,j; 
    //打印输入图片数据
    printf("input picture data:\n");
    for(i=0;i<IMG_P_SIZE;i++)
    {
        for(j=0;j<IMG_P_SIZE;j++)
        {
            printf("%.1f ",img[i][j]);
        }
        printf("\n");
    }

    //调用padding函数
    padding(img,img_out);

    //打印输出图像数据
    printf("output picture data:\n");
    for(i=0;i<OUT_P_SIZE;i++)
    {
        for(j=0;j<OUT_P_SIZE;j++)
        {
            printf("%.1f ",img_out[i][j]);
        }
        printf("\n");
    }
}
 


int main()
{
    //conv_test();  
    //max_pooling_test();
    //average_pooling_test();
    padding_test();
    return 0;
}

在这里插入图片描述

w²大大
关注
  • 7
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
conv:实用程序函数，可为C ++转换整数，字符串和其他对象
05-08
转换 conv是一个实用程序函数，用于转换C ++的整数，字符串和其他对象。 它的灵感来自于D编程语言的std.conv模块。 安装 conv是仅标头的库，您只需将include / conv复制到项目目录中。 例子 conv :: to <T>（）将整数，浮点数，布尔值和字符串转换为T的类型。 conv::to<char>(10); // == static_cast<char>(10) conv::to<std>(10); // "10" conv::to<std>(3.14); // "3.14" conv::to<std>(true); // "true" conv::to<int>("00001234"); // 1234 conv::to<int>("0
matlab的函数conv（）的C语言实现
理木客
05-25 1911
1.用C语言实现matlab中conv（）自带的函数 int max(int a,int b) { return a>b ? a:b; } int min(int a, int b) { return a<b ? a:b; } void conv(double *Ptr_Src1,double *Ptr_Src2, int Src1Lenth, int Src2Lenth, double *Ptr_Target) { double temp = 0; int i = 0; int
padding(卷积中的填充)
路人的博客
07-13 1万+
一个6x6的图像，3x3的卷积核，每一行卷积的过程类似，如图卷积核每走一步（第一个黑框到第一个绿框），输出一个像素。所以要计算卷积后图像的大小，需要知道图像大小及卷积核大小。(6-3)+1的结果为4，所以得到的卷积图像大小为4x4。公式为(图片大小 - 卷积核大小) + 1，这里的(图片大小 - 卷积核大小)意味着卷积核移动的次数，移动3次（绿色框），输出3个像素，+1意味着第一次计算卷积，即卷积核初始位置不需要移动的那一次。令原图像大小为，卷积核大小为。 所以在步长为1的情况下，则卷积后图像边长为，即移动
深度学习笔记（25） 池化层
氢键H-H
06-25 1万+
max pooling、mean pooling、pooling 超参
python 进程池详解
程序员小陶的大数据分享
04-24 1242
在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，十几个还好，但如果是上百个，上千个目标，手动的去限制进程数量却又太过繁琐，此时可以发挥进程池的功效。 Pool可以提供指定数量的进程供用户调用，当有新的请求提交到pool中时，如果池...
全连接神经网络用C语言实现
qq_42585108的博客
10-29 1945
全连接神经网络用C语言实现一、分析输入输出二、分析神经网络层数三、分析神经元数量四、分析参数数量五、分析传递过程连接方式六、代码框架七、完整代码实现： 关于参数的获取：已经在上篇博客中提出，请参照相关链接请点击 一、分析输入输出 1、手写体输入为28x28的黑白图片，所以输入为784个x 2、输出为识别0-9的数字的概率，所以有10个输出 3、输入只能是-1~1的小数，主要是防止计算溢出 二、分析神经网络层数 如果只是一层，输入784，输出10，中间能记录的神经元只能是10个，很难达到识别0-9这10个数字
C++实现卷积(conv)操作-三种方式（valid,full,same） ,卷积的三种模式:full, same, valid
weili_的博客
07-23 5389
#include<iostream> #include<malloc.h> using namespace std; //matrix表示原图像，new_h表示原图像的高，new_w表示原图像的宽，m_h表示模板的高，m_w表示模板的宽. //返回值为：填充好的图像. int * zero_pad(int * matrix, int new_h, int new_w, ...
卷积——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 ...
深度学习之最大池化操作的实现
大腿壮的博客
04-25 2831
在darknet框架中（C语言实现），max pooling实现方式如下： void forward_maxpool_layer(const maxpool_layer l, network net) { int b,i,j,k,m,n; int w_offset = -l.pad; int h_offset = -l.pad; int h = l.out_h; ...
计算机视觉：填充(padding)技术
huanfeng_AI的博客
05-27 1271
在前面的课程中，我们学习了使用3*3的过滤器去卷积一个5*5的图像，那么最终会得到一个3*3的输出。那是因为 3×3 过滤器在 5×5 矩阵中，只可能有 3×3 种可能的位置。这背后的数学解释是，如果我们有一个nn的图像，用f×f的过滤器做卷积，那么输出的维度就是。在这个例子里是5−3+1=3，因此得到了一个 3×3 的输出。
二维卷积运算之C语言实现二维卷积运算之C语言实现
09-18
二维卷积运算之C语言实现二维卷积运算之C语言实现 二维卷积运算之C语言实现二维卷积运算之C语言实现
C语言实现卷积.docx
03-29
用一编程语言实现卷积 本次作业我采用的是C语言来编程实现卷积 C语言卷积实现的代码 里面含有运行结果图
UFLDL Exercise: Convolution and Pooling 卷积和池化
01-01
UFLDL Exercise: Convolution and Pooling 卷积和池化 matlab代码 只需下载训练集和测试集就可以直接运行
pytorch中的卷积和池化计算方式详解
09-18
今天小编就为大家分享一篇pytorch中的卷积和池化计算方式详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
基于深度时空特征卷积—池化的视频人群计数方法
01-19
利用视频的时空特征和卷积—池化方法形成高层的视觉特征，采用局部特征聚合描述符进行量化和码本计算，实现了对视频人群信息的精准描述；该方法充分利用了视频的运动和外观信息，基于卷积神经网络和池化方法提升了对...
排序3——C语言
最新发布
qq_74245477的博客
04-24 1040
让每一个数都减去最小值，那么如果有负数，减去最小值（也是负数，可能是本身）之后的值肯定大于等于0，就可以满足数组的下标了。将序列分割，若子区间无序，对子区间再分割，直至子区间有序（只有一个数时）再进行合并（相当于合并两个有序数组）。不稳定，例子如下图，时间复杂度O（N*logN）空间复杂度O（logN）不稳定，例子如下图，时间复杂度O（N*logN）空间复杂度O（1）归并排序的缺点，空间复杂度为O（N），即额外需要一块辅助空间。不稳定，例子如下图，时间复杂度O（N^2）空间复杂度O（1）
C++高级特性：C/C++内存结构模型（十一）
weixin_43808717的博客
04-21 1337
代码段可制度数据段通常在程序加载时有操作系统加载到内存，一旦加载就不能被修改在函数调用时，函数的机器码也存储在代码段中，每个函数有其独特的代码段地址字符串常量等只读数据段中的数据是不可修改的，任何企图修改这些数据的尝试都会导致运行时错误作为一个专业的C++使用者来说，清楚的知道自己的代码变量存储的区域会有非常大的好处，补单能够写出高性能代码，而且有助于减少一些深层次的BUG。使用C++内存的一些注意事项内存泄漏：确保在动态分配内存后找个合适的时机释放掉，避免出现内存泄漏。
Day17.一刷数据结构算法(C语言版) 654最大二叉树；617合并二叉树；700二叉搜索树中的搜索；98验证二叉搜索树
m0_64336804的博客
04-22 1078
这里是c语言版数据结构算法。本期主题是：最大二叉树；合并二叉树；二叉搜索树中的搜索；验证二叉搜索树。
开发语言漫谈-SQL
wangbing1125的博客
04-21 616
坏消息是SQL有很多方言，每个数据库系统都有或多或少的扩展，各个数据库之间有很多细微的差距。这个困惑类似做Javascript的怎么兼容各浏览器，编写SQL的得考虑怎么做数据库兼容。SQL是另一个门类的开发语言，是专用于结构化数据库操作的专用语言。SQL不可能单独开发系统，但是做数据库方面的系统不懂SQL也不行。市面上很大部分开发岗位（后台）都是要和数据库打交道的，所以SQL必须掌握。目前流行的趋势是这些逻辑由服务程序处理，数据库只做单纯的存储。做管理系统维护和服务的同学，SQL是必备技能。
conv pooling与max pooling和average pooling的区别
05-21
Convolutional pooling、max pooling和average pooling都是CNN中常用的池化操作，它们的区别在于： 1. Convolutional pooling: 该类型的池化操作通常被称为“strided convolution”。它与标准的卷积操作非常相似，但是它只使用了一小部分的卷积核。它通过对输入数据的卷积输出进行下采样来实现池化操作，因此它可以降低输出特征图的维度，同时也可以保留一些重要的特征。 2. Max pooling: 该类型的池化操作基于每个池化窗口内的最大值进行操作。它通常用于减小特征图的大小，并将强烈的特征保留下来。它通常用于分类任务中。 3. Average pooling: 该类型的池化操作基于每个池化窗口内的平均值进行操作。它与max pooling相比，可以更好地保留特征的分布情况，因此它通常用于需要对特征进行平滑处理的任务中，比如图像分割。 总之，三种池化操作各有优缺点，具体使用哪种操作取决于具体的任务需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值