CNN学习（7）：用C++实现简单不同参数的卷积模型

于 2024-06-22 21:48:42 发布
阅读量75 收藏
点赞数
文章标签： cnn 学习 c++
原文链接：https://blog.csdn.net/zhenz0729/article/details/139644768?spm=1001.2100.3001.7377&utm_medium=distribute.pc_feed_blog.none-task-blog-hot-3-139644768-null-null.nonecase&depth_1-utm_source=distribute.pc_feed_blog.none-task-blog-hot-3-139644768-null-null.none
版权

目录

一、参数说明和计算公式

1、符号约定

2、输出大小计算公式

二、不同类型的卷积

1、输入3*3*1，卷积核3*3*1，输出1*1*1

（1）实现代码

（2）代码说明

2、输入4*4*1，卷积核3*3*1，步长1*1，输出2*2*1

（1）实现代码

（2）代码说明

3、输入4*4*1，卷积核2*2*1，步长2*2，输出2*2*1

（1）实现代码

4、输入4*4*1，卷积核3*3*1，步长1*1，padding为1*1，输出2*2*1

​编辑

（1）实现代码

（2）代码说明

5、输入4*4*2，卷积核3*3*2，步长1*1，padding为1*1，输出2*2*1

（1）实现代码

6、输入4*4*1，卷积核3*3*1，卷积核个数2，步长1*1，padding为1*1，输出2*2*1

（1）实现代码

（2）代码说明

7、输入4*4*2，卷积核3*3*2，步长1*1，padding为1*1，膨胀系数2，输出2*2*2

三、可执行的卷积操作代码

参考资料：

(图解)一步一步使用CPP实现深度学习中的卷积 - GiantPandaCV

其实在上述链接里已经写的非常详细了，为了便于后续理解和学习，所以写个理解的备忘录。

一、参数说明和计算公式
1、符号约定
F[] 为输入;
width 为输入的宽;
height 为输入的高;
channel 为输入的通道;
 
K[] 为 kernel;
kSizeX 为 kernel 的宽;
kSizeY 为 kernel 的高;
filters 为 kernel 的个数;
padX 为水平方向的填充；
padY 为垂直方向的填充；
strideX 为水平方向的步长；
strideY 为垂直方向的步长；
 
 
O[] 为输出;
outW 为输出的宽;
outH 为输出的高;
outChannel 为输出的通道;
2、输出大小计算公式
int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
公式说明：

height + 2 * padY: 首先，将输入图像的高度加上两倍的填充量，这是因为填充是对称地加在图像的顶部和底部。

dilationY * (kSizeY - 1): 这是计算卷积核中除了中心元素外，其他元素之间的总间隔。kSizeY - 1表示卷积核的高度减去中心元素，乘以膨胀系数dilationY，得到这些元素之间的间隔数。

dilationY * (kSizeY - 1) + 1: 将上述间隔数加上1，是因为我们还要包括卷积核的中心元素。

(height + 2 * padY - (dilationY * (kSizeY - 1) + 1)): 这个表达式计算了在考虑填充和膨胀后，输入图像实际上被卷积核覆盖的区域的高度。

/ strideY: 将上述计算得到的高度除以步长，得到在垂直方向上卷积核可以覆盖的步数。

+ 1: 最后，由于输出的高度至少要有一个元素，即使计算结果为0，我们也需要加1，以确保输出尺寸至少为1。

二、不同类型的卷积
1、输入3*3*1，卷积核3*3*1，输出1*1*1


（1）实现代码
封装成demo0()，main()函数可直接调用

void demo0()
{
    float F[] = {1,2,3,4,5,6,7,8,9};
    float K[] = {1,2,3,4,5,6,7,8,9};
    float O = 0;
 
    int width  = 3;
    int height = 3;
    int kSizeX = 3;
    int kSizeY = 3;
 
    for(int m=0;m<kSizeY;m++)
    {
        for(int n=0;n<kSizeX;n++)
        {
            O+=K[m*kSizeX+n]*F[m*width+n];
        }
    }
 
    std::cout<<O<<" ";
}
（2）代码说明
前面都是定义输入矩阵和卷积核，同时定义一个浮点数变量O并初始化为0，用于累加结果。
两个嵌套循环遍历卷积核的每个元素：
for(int m=0; m<kSizeY; m++)：外层循环遍历卷积核的高度。
for(int n=0; n<kSizeX; n++)：内层循环遍历卷积核的宽度。
嵌套循环内部，O += K[m*kSizeX + n] * F[m*width + n];用来执行卷积操作。这行代码将卷积核的当前元素 K[m*kSizeX + n] 与输入矩阵的对应元素 F[m*width + n] 相乘，并将结果累加到 O 中【其中位置是相同的，m只是用来决定以kSize为单位的轮次】。
2、输入4*4*1，卷积核3*3*1，步长1*1，输出2*2*1


（1）实现代码
void demo1()
{
    float F[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    float K[] = {1,2,3,4,5,6,7,8,9};
    float O[] = {0,0,0,0};
 
    int padX = 0;
    int padY = 0;
 
    int dilationX = 1;
    int dilationY = 1;
 
    int strideX  = 1;
    int strideY  = 1;
 
    int width = 4;
    int height = 4;
 
    int kSizeX = 3;
    int kSizeY = 3;
 
    int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
    int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
 
    for(int i=0;i<outH;i++)
    {
        for(int j=0;j<outW;j++)
        {
            for(int m=0;m<kSizeY;m++)
            {
                for(int n=0;n<kSizeX;n++)
                {
                    O[i*outW+j]+=K[m*kSizeX+n]*F[(m+i)*width+(n+j)];
                }
            }
        }
    }
 
    for (int i = 0; i < outH; ++i)
    {
        for (int j = 0; j < outW; ++j)
        {
            std::cout<<O[i*outW+j]<<" ";
        }
        std::cout<<std::endl;
    }
}
（2）代码说明
前面都是定义输入矩阵和卷积核，同时定义一个浮点数变量O并初始化【和前面后面一样，都是先计算出来输出结果的大小，然后再执行】，用于累加结果。
四个嵌套循环开始进行卷积计算：
外层两个循环遍历输出特征图的每个位置。
内层两个循环遍历卷积核的每个元素。
在内层循环中，计算卷积核覆盖的输入特征图区域的加权和，并将结果累加到输出特征图的相应位置。

3、输入4*4*1，卷积核2*2*1，步长2*2，输出2*2*1


（1）实现代码
void demo2()
{
    // (height + 2 * paddingY - (dilationY * (kSizeY - 1) + 1)) / strideY + 1;
    // (width + 2 * paddingX - (dilationX * (kSizeX - 1) + 1)) / strideX + 1;
 
    float F[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    float K[] = {1,2,3,4};
    //float K[] = {1,2,3,4,5,6,7,8,9};
    float O[] = {0,0,0,0};
 
    int padX = 0;
    int padY = 0;
 
    int dilationX = 1;
    int dilationY = 1;
 
    int strideX  = 2;
    int strideY  = 2;
 
    int width = 4;
    int height = 4;
 
    int kSizeX = 2;
    int kSizeY = 2;
 
    int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
    int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
 
    for(int i=0;i<outH;i++)
    {
        for(int j=0;j<outW;j++)
        {
            for(int m=0;m<kSizeY;m++)
            {
                for(int n=0;n<kSizeX;n++)
                {
                    O[i*outW+j]+=K[m*kSizeX+n]*F[(m+i*strideY)*width+(n+j*strideX)];
                }
            }
        }
    }
 
    for (int i = 0; i < outH; ++i)
    {
        for (int j = 0; j < outW; ++j)
        {
            std::cout<<O[i*outW+j]<<" ";
        }
        std::cout<<std::endl;
    }
}
这个和上一段代码解释相同，只不过步长和卷积核大小有改变。

4、输入4*4*1，卷积核3*3*1，步长1*1，padding为1*1，输出2*2*1

（1）实现代码
void demo3()
{
    float F[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    float K[] = {1,2,3,4,5,6,7,8,9};
    float O[] = {0,0,0,0};
 
    int padX = 1;
    int padY = 1;
 
    int dilationX = 1;
    int dilationY = 1;
 
    int strideX  = 2;
    int strideY  = 2;
 
    int width = 4;
    int height = 4;
 
    int kSizeX = 3;
    int kSizeY = 3;
 
    int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
    int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
 
    for(int i=0;i<outH;i++)
    {
        for(int j=0;j<outW;j++)
        {
            for(int m=0;m<kSizeY;m++)
            {
                for(int n=0;n<kSizeX;n++)
                {
                    float fVal = 0;  
                    //考虑边界强情况
                    if((n+j*strideX-padX)>-1&&(m+i*strideY-padY>-1)&&(n+j*strideX-padX)<=width&&(m+i*strideY-padY>-1)<=height) 
                    {
                        fVal = F[(m+i*strideY-padX)*width+(n+j*strideX-padY)];
                    }
                    O[i*outW+j]+=K[m*kSizeX+n]*fVal;
                }
            }
        }
    }
 
    for (int i = 0; i < outH; ++i)
    {
        for (int j = 0; j < outW; ++j)
        {
            std::cout<<O[i*outW+j]<<" ";
        }
        std::cout<<std::endl;
    }
}
（2）代码说明
按照正常计算输出规模公式计算的话，应该输出是4*4*1。但是考虑到边界墙问题。

if 语句块用来检查当前卷积核的 m 和 n 索引是否在输入特征图的边界内。这里考虑了填充（padding）的情况：

(n+j*strideX - padX) 计算了卷积核的左边界在输入特征图上的索引。
(m+i*strideY - padY) 计算了卷积核的上边界在输入特征图上的索引。
条件 > -1 确保索引不会是负数。
条件 <= width 和 <= height 确保索引不会超出输入特征图的边界。
5、输入4*4*2，卷积核3*3*2，步长1*1，padding为1*1，输出2*2*1


其中依旧考虑了边界墙问题。

（1）实现代码
void demo4()
{
    float F[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    float K[] = {1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9};
    float O[] = {0,0,0,0};
 
    int padX = 1;
    int padY = 1;
 
    int dilationX = 1;
    int dilationY = 1;
 
    int strideX  = 2;
    int strideY  = 2;
 
    int width = 4;
    int height = 4;
 
    int kSizeX = 3;
    int kSizeY = 3;
 
    int channel = 2;
 
    int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
    int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
 
    for (int c = 0; c < channel; ++c)
    {
        for(int i=0;i<outH;i++)
        {
            for(int j=0;j<outW;j++)
            {
                for(int m=0;m<kSizeY;m++)
                {
                    for(int n=0;n<kSizeX;n++)
                    {
                        float fVal = 0;
                        if((n+j*strideX-padX)>-1&&(m+i*strideY-padY>-1)&&(n+j*strideX-padX)<=width&&(m+i*strideY-padY>-1)<=height)
                        {
                            fVal = F[c*width*height + (m+i*strideY-padX)*width+(n+j*strideX-padY)];
                        }
                        O[i*outW+j]+=K[c*kSizeX*kSizeY+m*kSizeX+n]*fVal;
                    }
                }
            }
        }
    }
 
    for (int i = 0; i < outH; ++i)
    {
        for (int j = 0; j < outW; ++j)
        {
            std::cout<<O[i*outW+j]<<" ";
        }
        std::cout<<std::endl;
    }
}
6、输入4*4*1，卷积核3*3*1，卷积核个数2，步长1*1，padding为1*1，输出2*2*1


（1）实现代码
void demo5()
{
    float F[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    float K[] = {1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,
                 1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9
                };
    float O[] = {0,0,0,0,0,0,0,0};
 
    int padX = 1;
    int padY = 1;
 
    int dilationX = 1;
    int dilationY = 1;
 
    int strideX  = 2;
    int strideY  = 2;
 
    int width = 4;
    int height = 4;
 
    int kSizeX = 3;
    int kSizeY = 3;
 
    int channel = 2;
 
    int filters = 2;
 
    int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
    int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
 
    int outC = filters;
 
    for (int oc = 0; oc < outC; ++oc)
    {
        for (int c = 0; c < channel; ++c)
        {
            for(int i=0;i<outH;i++)
            {
                for(int j=0;j<outW;j++)
                {
                    for(int m=0;m<kSizeY;m++)
                    {
                        for(int n=0;n<kSizeX;n++)
                        {
                            float fVal = 0;
                            if((n+j*strideX-padX)>-1&&(m+i*strideY-padY>-1)&&(n+j*strideX-padX)<=width&&(m+i*strideY-padY>-1)<=height)
                            {
                                fVal = F[c*width*height + (m+i*strideY-padX)*width+(n+j*strideX-padY)];
                            }
                            O[oc*outH*outW+i*outW+j]+=K[oc*outC*kSizeX*kSizeY+c*kSizeX*kSizeY+m*kSizeX+n]*fVal;
                        }
                    }
                }
            }
        }
    }
 
    for (int oc = 0; oc < outC; ++oc)
    {
        for (int i = 0; i < outH; ++i)
        {
            for (int j = 0; j < outW; ++j)
            {
                std::cout<<O[oc*outH*outW+i*outW+j]<<" ";
            }
            std::cout<<std::endl;
        }
        std::cout<<std::endl<<std::endl;
    }
}
（2）代码说明
六个嵌套循环实现了卷积操作：

最外层循环遍历输出特征图的每个通道。
第二个循环遍历输入特征图的每个通道。
第三个和第四个循环遍历输出特征图的每个元素。
最内层两个循环遍历每个卷积核的元素。
在最内层循环中，首先检查当前卷积核的索引是否在输入特征图的边界内，如果是，则从输入特征图中取出相应的元素 fVal。

然后，将 fVal 与对应卷积核的元素相乘，并将结果累加到输出特征图的对应位置。

7、输入4*4*2，卷积核3*3*2，步长1*1，padding为1*1，膨胀系数2，输出2*2*2
void demo6()
{
    float F[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    float K[] = {1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,
                 1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9
                };
    float O[] = {0,0,0,0,0,0,0,0};
 
    int padX = 1;
    int padY = 1;
 
    int dilationX = 2;
    int dilationY = 2;
 
    int strideX  = 1;
    int strideY  = 1;
 
    int width = 4;
    int height = 4;
 
    int kSizeX = 3;
    int kSizeY = 3;
 
    int channel = 2;
 
    int filters = 2;
 
    int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
    int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
 
    int outC = filters;
 
    for (int oc = 0; oc < outC; ++oc)
    {
        for (int c = 0; c < channel; ++c)
        {
            for(int i=0;i<outH;i++)
            {
                for(int j=0;j<outW;j++)
                {
                    for(int m=0;m<kSizeY;m++)
                    {
                        for(int n=0;n<kSizeX;n++)
                        {
                            float fVal = 0;
                            if( ((n+j*strideX)*dilationX-padX)>-1 && ((m+i*strideY)*dilationY-padY)>-1&&
                               ((n+j*strideX)*dilationX-padX)<=width && ((m+i*strideY)*dilationY-padY>-1)<=height)
                            {
                                fVal = F[c*width*height + ((m+i*strideY)*dilationX-padX)*width+((n+j*strideX)*dilationY-padY)];
                            }
                            O[oc*outH*outW+i*outW+j]+=K[oc*outC*kSizeX*kSizeY+c*kSizeX*kSizeY+m*kSizeX+n]*fVal;
                        }
                    }
                }
            }
        }
    }
 
    for (int oc = 0; oc < outC; ++oc)
    {
        for (int i = 0; i < outH; ++i)
        {
            for (int j = 0; j < outW; ++j)
            {
                std::cout<<O[oc*outH*outW+i*outW+j]<<" ";
            }
            std::cout<<std::endl;
        }
        std::cout<<std::endl;
    }
}
三、可执行的卷积操作代码
#include <iostream>
 
void demo0()    //输入3*3*1，卷积核3*3*1，输出为1*1*1
{
    float F[] = {1,2,3,4,5,6,7,8,9};
    float K[] = {1,2,3,4,5,6,7,8,9};
    float O = 0;
 
    int width  = 3;
    int height = 3;
    int kSizeX = 3;
    int kSizeY = 3;
 
    for(int m=0;m<kSizeY;m++)
    {
        for(int n=0;n<kSizeX;n++)
        {
            O+=K[m*kSizeX+n]*F[m*width+n];
        }
    }
    std::cout<<O<<" ";
}
 
void demo1()    //输入4*4*1，卷积核3*3*1，步长为1*1，no padding，输出为1*1*1
{
    //计算公式
    // (height + 2 * paddingY - (dilationY * (kSizeY - 1) + 1)) / strideY + 1;
    // (width + 2 * paddingX - (dilationX * (kSizeX - 1) + 1)) / strideX + 1;
 
    float F[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    float K[] = {1,2,3,4,5,6,7,8,9};
    float O[] = {0,0,0,0};
 
    int padX = 0;
    int padY = 0;
 
    int dilationX = 1;
    int dilationY = 1;
 
    int strideX  = 1;
    int strideY  = 1;
 
    int width = 4;
    int height = 4;
 
    int kSizeX = 3;
    int kSizeY = 3;
 
    int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
    int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
 
    for(int i=0;i<outH;i++)
    {
        for(int j=0;j<outW;j++)
        {
            for(int m=0;m<kSizeY;m++)
            {
                for(int n=0;n<kSizeX;n++)
                {
                    O[i*outW+j]+=K[m*kSizeX+n]*F[(m+i)*width+(n+j)];
                    /* int inputIndex = (i * strideY + m) * width + (j * strideX + n);
                    O[i * outW + j] += K[m * kSizeX + n] * F[inputIndex]; */
                }
            }
        }
    }
 
    for (int i = 0; i < outH; ++i)
    {
        for (int j = 0; j < outW; ++j)
        {
            std::cout<<O[i*outW+j]<<" ";
        }
        std::cout<<std::endl;
    }
}
 
void demo2()
{
 
    float F[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    float K[] = {1,2,3,4};
    //float K[] = {1,2,3,4,5,6,7,8,9};
    float O[] = {0,0,0,0};
 
    int padX = 0;
    int padY = 0;
 
    int dilationX = 1;
    int dilationY = 1;
 
    int strideX  = 2;
    int strideY  = 2;
 
    int width = 4;
    int height = 4;
 
    int kSizeX = 2;
    int kSizeY = 2;
 
    int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
    int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
 
    for(int i=0;i<outH;i++)
    {
        for(int j=0;j<outW;j++)
        {
            for(int m=0;m<kSizeY;m++)
            {
                for(int n=0;n<kSizeX;n++)
                {
                    O[i*outW+j]+=K[m*kSizeX+n]*F[(m+i*strideY)*width+(n+j*strideX)];
                }
            }
        }
    }
 
    for (int i = 0; i < outH; ++i)
    {
        for (int j = 0; j < outW; ++j)
        {
            std::cout<<O[i*outW+j]<<" ";
        }
        std::cout<<std::endl;
    }
}
 
void demo3()
{
 
    float F[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    //float K[] = {1,2,3,4};
    float K[] = {1,2,3,4,5,6,7,8,9};
    float O[] = {0,0,0,0};
 
    int padX = 1;
    int padY = 1;
 
    int dilationX = 1;
    int dilationY = 1;
 
    int strideX  = 2;
    int strideY  = 2;
 
    int width = 4;
    int height = 4;
 
    int kSizeX = 3;
    int kSizeY = 3;
 
    int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
    int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
 
    for(int i=0;i<outH;i++)
    {
        for(int j=0;j<outW;j++)
        {
            for(int m=0;m<kSizeY;m++)
            {
                for(int n=0;n<kSizeX;n++)
                {
                    float fVal = 0;
                    //考虑边界强情况
                    if((n+j*strideX-padX)>-1&&(m+i*strideY-padY>-1)&&(n+j*strideX-padX)<=width&&(m+i*strideY-padY>-1)<=height)
                    {
                        fVal = F[(m+i*strideY-padX)*width+(n+j*strideX-padY)];
                    }
                    O[i*outW+j]+=K[m*kSizeX+n]*fVal;
                }
            }
        }
    }
 
    for (int i = 0; i < outH; ++i)
    {
        for (int j = 0; j < outW; ++j)
        {
            std::cout<<O[i*outW+j]<<" ";
        }
        std::cout<<std::endl;
    }
}
 
void demo4()
{
    float F[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    //float K[] = {1,2,3,4};
    float K[] = {1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9};
    float O[] = {0,0,0,0};
 
    int padX = 1;
    int padY = 1;
 
    int dilationX = 1;
    int dilationY = 1;
 
    int strideX  = 2;
    int strideY  = 2;
 
    int width = 4;
    int height = 4;
 
    int kSizeX = 3;
    int kSizeY = 3;
 
    int channel = 2;
 
    int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
    int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
 
    for (int c = 0; c < channel; ++c)
    {
        for(int i=0;i<outH;i++)
        {
            for(int j=0;j<outW;j++)
            {
                for(int m=0;m<kSizeY;m++)
                {
                    for(int n=0;n<kSizeX;n++)
                    {
                        float fVal = 0;
                        if((n+j*strideX-padX)>-1&&(m+i*strideY-padY>-1)&&(n+j*strideX-padX)<=width&&(m+i*strideY-padY>-1)<=height)
                        {
                            fVal = F[c*width*height + (m+i*strideY-padX)*width+(n+j*strideX-padY)];
                        }
                        O[i*outW+j]+=K[c*kSizeX*kSizeY+m*kSizeX+n]*fVal;
                    }
                }
            }
        }
    }
 
    for (int i = 0; i < outH; ++i)
    {
        for (int j = 0; j < outW; ++j)
        {
            std::cout<<O[i*outW+j]<<" ";
        }
        std::cout<<std::endl;
    }
}
 
void demo5()
{
 
    float F[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    //float K[] = {1,2,3,4};
    float K[] = {1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,
                 1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9
                };
    float O[] = {0,0,0,0,0,0,0,0};
 
    int padX = 1;
    int padY = 1;
 
    int dilationX = 1;
    int dilationY = 1;
 
    int strideX  = 2;
    int strideY  = 2;
 
    int width = 4;
    int height = 4;
 
    int kSizeX = 3;
    int kSizeY = 3;
 
    int channel = 2;
 
    int filters = 2;
 
    int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
    int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
 
    int outC = filters;
 
    for (int oc = 0; oc < outC; ++oc)
    {
        for (int c = 0; c < channel; ++c)
        {
            for(int i=0;i<outH;i++)
            {
                for(int j=0;j<outW;j++)
                {
                    for(int m=0;m<kSizeY;m++)
                    {
                        for(int n=0;n<kSizeX;n++)
                        {
                            float fVal = 0;
                            if((n+j*strideX-padX)>-1&&(m+i*strideY-padY>-1)&&(n+j*strideX-padX)<=width&&(m+i*strideY-padY>-1)<=height)
                            {
                                fVal = F[c*width*height + (m+i*strideY-padX)*width+(n+j*strideX-padY)];
                            }
                            O[oc*outH*outW+i*outW+j]+=K[oc*channel*kSizeX*kSizeY+c*kSizeX*kSizeY+m*kSizeX+n]*fVal;
                        }
                    }
                }
            }
        }
    }
 
    for (int oc = 0; oc < outC; ++oc)
    {
        for (int i = 0; i < outH; ++i)
        {
            for (int j = 0; j < outW; ++j)
            {
                std::cout<<O[oc*outH*outW+i*outW+j]<<" ";
            }
            std::cout<<std::endl;
        }
        std::cout<<std::endl<<std::endl;
    }
}
 
void demo6()
{
    // (height + 2 * paddingY - (dilationY * (kSizeY - 1) + 1)) / strideY + 1;
    // (width + 2 * paddingX - (dilationX * (kSizeX - 1) + 1)) / strideX + 1;
 
    float F[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    //float K[] = {1,2,3,4};
    float K[] = {1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,
                 1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9
                };
    float O[] = {0,0,0,0,0,0,0,0};
 
    int padX = 1;
    int padY = 1;
 
    int dilationX = 2;
    int dilationY = 2;
 
    int strideX  = 1;
    int strideY  = 1;
 
    int width = 4;
    int height = 4;
 
    int kSizeX = 3;
    int kSizeY = 3;
 
    int channel = 2;
 
    int filters = 2;
 
    int outH = (height+2*padY-(dilationY*(kSizeY-1)+1)) / strideY + 1;
    int outW = (width+2*padX-(dilationX*(kSizeX-1)+1)) / strideX + 1;
 
    int outC = filters;
 
    for (int oc = 0; oc < outC; ++oc)
    {
        for (int c = 0; c < channel; ++c)
        {
            for(int i=0;i<outH;i++)
            {
                for(int j=0;j<outW;j++)
                {
                    for(int m=0;m<kSizeY;m++)
                    {
                        for(int n=0;n<kSizeX;n++)
                        {
                            float fVal = 0;
                            if( ((n+j*strideX)*dilationX-padX)>-1 && ((m+i*strideY)*dilationY-padY)>-1&&
                                    ((n+j*strideX)*dilationX-padX)<=width && ((m+i*strideY)*dilationY-padY>-1)<=height)
                            {
                                fVal = F[c*width*height + ((m+i*strideY)*dilationX-padX)*width+((n+j*strideX)*dilationY-padY)];
                            }
                            O[oc*outH*outW+i*outW+j]+=K[oc*channel*kSizeX*kSizeY+c*kSizeX*kSizeY+m*kSizeX+n]*fVal;
                        }
                    }
                }
            }
        }
    }
 
    for (int oc = 0; oc < outC; ++oc)
    {
        for (int i = 0; i < outH; ++i)
        {
            for (int j = 0; j < outW; ++j)
            {
                std::cout<<O[oc*outH*outW+i*outW+j]<<" ";
            }
            std::cout<<std::endl;
        }
        std::cout<<std::endl;
    }
}
 
 
int main(int argc, char *argv[])
{
    //demo0();
    demo1();
    //demo2();
    //demo3();
    //demo4();
    //demo5();
    //demo6();
}
（1）将上述文件为my_code.cc源文件。

如果要使用不同类型的demo，可以直接在main函数中调用。

（2）然后在终端运行：

g++ -o my_code my_code.cc
此时已编译出可执行的二进制my_code。

（3）执行my_code文件

./my_code
最后说明：其实我个人觉得这种方式使用起来除了简单易懂，但在实际操作中并不可取。主要是所有的变量值都需要在demo()函数中手工赋值，耦合性和实用性较差。但是目前也没有更好的实测，等过阵子我的程序写完后，再和大家分享。
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/zhenz0729/article/details/139644768

用数据说话用数据决策
关注
深度解析：用C++实现简易版Faster R-CNN目标检测模型
m0_57781768的博客
06-02 67
Faster R-CNN是一种端到端的目标检测模型，由RPN（Region Proposal Network）和Fast R-CNN组成。RPN负责生成候选区域（Region Proposals），而Fast R-CNN则对这些候选区域进行分类和边界框回归。Faster R-CNN相比于早期的R-CNN和Fast R-CNN，有着更高的检测速度和精度。
C++卷积实现
04-03
使用Eigen库编写的C++卷积函数，详细介绍参考：http://www.cnblogs.com/yabin/p/6664011.html
浅谈卷积和C++实现
weixin_34074740的博客
04-03 1497
1 信号处理中的卷积 无论是信号处理、图像处理还是其他一些领域，我们经常会在一些相互关联的数据处理中使用卷积。卷积可以说是算法中一个非常重要的概念。这个概念最早起源于信号处理之中。 假设对于一个线性系统其在单位脉冲δ(t)的响应下，输出为h(t).那么在Aδ(t)的响应下输出为Ah(t).而所有的信号都可以用δ(t)乘以一个系数的和来表示。即 .于是对于线性系统而言，我们可以将当前及过去所有时刻...
C++ 三种卷积方法实现
07-06
算法思想一：参照 http://wenku.baidu.com/view/aa110412a21614791711282a.html 算法思想二：参照 http://wenku.baidu.com/link?url=b1PwOhUSBhwyJee43jUOyOG45-woddl-nO6bt7LHLmlUbJu8ZQ3fGXpxARNxF5-Pa_H8vrCg6xRhllM_LSvU19OG80U0kMQbiTWO-3StUSu 算法思想三：公式 z(i,j)=∑ ∑x(m,n)y(i-m,j-n)
图像处理之卷积操作（C++）
最新发布
qq_45045175的博客
04-11 712
C++实现卷积操作，探析了opencv内部卷积的实现方式
C++实现线形卷积的计算
04-02
卷积函数，实现线形卷积的计算
C++实现对图像进行卷积，自定义卷积和
04-02
在C++中实现CNN的卷积操作，通常会使用现有的深度学习框架，如TensorFlow、PyTorch或Caffe，它们提供C++接口来进行高效的卷积计算。 在提供的"convolutionprocessing"文件中，可能包含了实现以上步骤的源代码。通过...
卷积神经网 CNN C++ 实现
05-15
9. **框架集成**：虽然直接用C++编写CNN代码可以提供更高的控制，但也可以考虑集成现有的深度学习库，如TensorFlow、Caffe或MxNet，它们提供了C++接口，简化了CNN的实现过程。 10. **模型保存与加载**：训练完成后...
CNN.tar.gz_CNN_CNN 识别_MLP 层_cnn c++实现_xml 参数
09-23
卷积神经网络（CNN，Convolutional Neural Network）是一种深度学习模型，因其在图像处理、计算机视觉和自然语言处理等领域表现出色而广受关注。在本压缩包中，"CNN.tar.gz" 包含了一个CNN的实现，特别强调了CNN在...
C++实现CNN识别手写数字
01-10
在本文中，我们将深入探讨如何使用C++实现卷积神经网络（CNN）来识别手写数字，特别是基于经典的MNIST数据集。MNIST是机器学习领域一个常用的基准数据集，包含大量的手写数字图像，常用于训练和测试各种图像识别算法...
C++实现卷积
08-31
一个用C++实现时域卷积的代码，编译可以运行，可以参考看看
卷积神经网络C++实现
08-07
卷积神经网络的C++实现，附实现用的文档资源链接。 架构好，有注释，minitest手写数据集上的识别率0.98 可供参考
卷积神经网络 CNN 代码
08-27
收集的卷积神经网络 CNN 代码，包含C++ matlab c#
myCNN卷积神经网络源代码
08-16
CNN程序源代码，卷积神经网络可以编译。
简单的CNN示例代码,简单的CNN示例代码,
03-04
c++ 的简单的CNN示例代码。码。
C++卷积神经网络实例：tiny_cnn代码详解（2）——代码试运行
热门推荐
陈俊岭的程序员之路（公众号求关注，方便交流）
03-10 2万+
　　在这篇博客中主要是对tiny_cnn的工程代码进行调试运行，毕竟目前对于我来说这是一个相对陌生的代码文件，拿到手里首先想到的自然是检验一下这个代码的正确性，能够顺利运行得到预期的结果之后，再开始对代码进行深度的剖析。　　一、现在tiny_cnn　　在上一篇博客中已经提供了项目下载地址，这里只需下载之后再解压，得到如下文件：　　项目文件中主要包含代码和训练样本两部分，data文件夹中存放了测试程...
c++实现的cnn
YSM'wall
11-13 1万+
花了2,3天的时间写了c++版本的cnn（其实一天就）
C++ 卷积神经网络
qq_42877866的博客
01-03 2832
C++卷积神经网络
Fast R-CNN：深度学习目标检测的高效方法
该算法由Ross Girshick开发，实现了Python和C++版本（基于Caffe），并以MIT开源许可证发布在GitHub上。" Fast R-CNN是深度学习领域中的一个重要里程碑，它解决了R-CNN（Region-based Convolutional Neural Networks...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值