浮点卷积winograd算法

最新推荐文章于 2022-12-26 19:10:55 发布
最新推荐文章于 2022-12-26 19:10:55 发布
阅读量685 收藏 3
点赞数 1
分类专栏： 卷积加速 文章标签： winograd
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20880415/article/details/103684596
版权

目录

winograd算法简介

知识直通车

winograd代码实例解析

winograd算法简介

现今的Winograd主要来源于1980年，由Shmuel Winograd提出减少FIR滤波器计算量的方法

Shmuel Winograd指出，对于输出个数为m，有r个参数的FIR滤波器，不需要m*r次乘法计算，而仅仅需要：

次乘法计算即可。

下面是一个F(2,3)的例子，即输出m=2个结果，参数r=3个：

可以看到，只需要4次乘法计算结果，发生在m1/m2/m3/m4的计算过程中，外加8次加法。注意，跟g相关的加减乘除可以在初始化时一口气算好，不占计算量。

扩展到二维：

上式中，g为参数，d为数据，G/B/A都是转换矩阵，Y是输出

具体的公式推荐大家直接看论文

对于不同的卷积核和输出大小，winograd的转换矩阵各自不同。本文专注于conv3x3_s1的介绍。

 

知识直通车

知乎文章：https://zhuanlan.zhihu.com/p/72149270

winograd论文：https://arxiv.org/abs/1509.09308

github实例代码(python)：https://github.com/Sejudyblues/cs194-winograd/blob/master/winograd.py

 

winograd代码实例解析

#include <stdio.h>
#include <assert.h>
#include <chrono>
using namespace std::chrono;

const float x[8][8] = {       // input X
    { 1.0,     0.0,    0.5,   0.0,   5.0,   0.4,   0.4,   0.8},    // X矩阵
    {-2.0,    -2.0,   -2.0,  -2.0,  -2.0,  -2.0,  -2.0,  -2.0},
    {-2.0,     2.0,    2.1,   3.5,   6.0,   2.0,   4.4,   2.0},
    { 1.0,     1.0,    1.0,   1.0,   1.0,   6.5,   1.4,   1.0},
    { 1.0,    -1.0,   -1.2,  -1.5,  -7.6,  -1.0,  -1.2,  -1.2},
    { 1.0,     1.0,    1.0,   1.7,   1.6,   4.4,   1.6,   1.5},
    { 1.0,    -1.0,   -3.5,  -6.0,  -1.3,  -1.0,  -1.6,  -7.0},
    { 0.0,     0.0,    0.0,   0.6,   0.2,   9.0,   0.4,   0.3}
};

const float weight[9] = {         // Weight w
    1.2, 0.63, 0.4,
    0.2,  0.5, 0.56,
    1.5,  0.3, 0.74
};

//U=GgG^T
const float ktm[8][3] = {       // Acutually Matrix G
    {   1.0f,        0.0f,        0.0f},    // G矩阵
    {-2.0f/9,     -2.0f/9,     -2.0f/9},
    {-2.0f/9,      2.0f/9,     -2.0f/9},
    {1.0f/90,     1.0f/45,     2.0f/45},
    {1.0f/90,    -1.0f/45,     2.0f/45},
    {1.0f/45,     1.0f/90,    1.0f/180},
    {1.0f/45,    -1.0f/90,    1.0f/180},
    {   0.0f,        0.0f,        1.0f}
};

int main()
{
    //w^T
    const float* k0 = weight;
    const float* k1 = weight+3;
    const float* k2 = weight+6;

    //U^T = G.g^T.G^T

    float tmp[8][3];    // tmp = G.g^T
    for(int i=0; i<8; i++)
    {
        tmp[i][0] = k0[0] * ktm[i][0] + k0[1] * ktm[i][1] + k0[2] * ktm[i][2];
        tmp[i][1] = k1[0] * ktm[i][0] + k1[1] * ktm[i][1] + k1[2] * ktm[i][2];
        tmp[i][2] = k2[0] * ktm[i][0] + k2[1] * ktm[i][1] + k2[2] * ktm[i][2];
    }
    
    //U^T = tmp.G^T
    float U[64];
    for (int j=0; j<8; j++)
    {
        float* tmpp = &tmp[j][0];

        for (int i=0; i<8; i++)
        {
            U[j*8 + i] = tmpp[0] * ktm[i][0] + tmpp[1] * ktm[i][1] + tmpp[2] * ktm[i][2];
        }
    }
//         const float itm[8][8] = {
//             {1.0f,  0.0f, -5.25f,  0.00f,  5.25f,  0.00f, -1.0f, 0.0f},
//
//             {0.0f,  1.0f,  1.00f, -4.25f, -4.25f,  1.00f,  1.0f, 0.0f},
//             {0.0f, -1.0f,  1.00f,  4.25f, -4.25f, -1.00f,  1.0f, 0.0f},
//
//             {0.0f,  0.5f,  0.25f, -2.50f, -1.25f,  2.00f,  1.0f, 0.0f},
//             {0.0f, -0.5f,  0.25f,  2.50f, -1.25f, -2.00f,  1.0f, 0.0f},
//
//             {0.0f,  2.0f,  4.00f, -2.50f, -5.00f,  0.50f,  1.0f, 0.0f},
//             {0.0f, -2.0f,  4.00f,  2.50f, -5.00f, -0.50f,  1.0f, 0.0f},
//
//             {0.0f, -1.0f,  0.00f,  5.25f,  0.00f, -5.25f,  0.0f, 1.0f}
//         };

        // 0 = r00 - r06 + (r04 - r02) * 5.25
        // 7 = r07 - r01 + (r03 - r05) * 5.25

        // 1 = (r02 + r06 - r04 * 4.25) + (r01 - r03 * 4.25 + r05)
        // 2 = (r02 + r06 - r04 * 4.25) - (r01 - r03 * 4.25 + r05)

        // 3 = (r06 + r02 * 0.25 - r04 * 1.25) + (r01 * 0.5 - r03 * 2.5 + r05 * 2)
        // 4 = (r06 + r02 * 0.25 - r04 * 1.25) - (r01 * 0.5 - r03 * 2.5 + r05 * 2)

        // reuse r04 * 1.25
        // reuse r03 * 2.5
        // 5 = (r06 + (r02 - r04 * 1.25) * 4) + (r01 * 2 - r03 * 2.5 + r05 * 0.5)
        // 6 = (r06 + (r02 - r04 * 1.25) * 4) - (r01 * 2 - r03 * 2.5 + r05 * 0.5)

    //V^T = B^T.d^T.B
    float tempv[8][8];
    for (int m=0; m<8; m++)
    {
        const float *r0 = &x[m][0];

        tempv[0][m] = r0[0] - r0[6] + (r0[4] - r0[2]) * 5.25f;
        tempv[7][m] = r0[7] - r0[1] + (r0[3] - r0[5]) * 5.25f;

        float tmp12a = (r0[2] + r0[6] - r0[4] * 4.25f);
        float tmp12b = (r0[1] + r0[5] - r0[3] * 4.25f);

        tempv[1][m] = tmp12a + tmp12b;
        tempv[2][m] = tmp12a - tmp12b;

        float tmp34a = (r0[6] + r0[2] * 0.25f - r0[4] * 1.25f);
        float tmp34b = (r0[1] * 0.5f - r0[3] * 2.5f + r0[5] * 2.f);

        tempv[3][m] = tmp34a + tmp34b;
        tempv[4][m] = tmp34a - tmp34b;

        float tmp56a = (r0[6] + (r0[2] - r0[4] * 1.25f) * 4.f);
        float tmp56b = (r0[1] * 2.f - r0[3] * 2.5f + r0[5] * 0.5f);

        tempv[5][m] = tmp56a + tmp56b;
        tempv[6][m] = tmp56a - tmp56b;
    }

    float V[64];
    for (int m=0; m<8; m++)
    {
        const float* tmp0 = tempv[m];

        V[m*8] = tmp0[0] - tmp0[6] + (tmp0[4] - tmp0[2]) * 5.25f;
        V[m*8+7] = tmp0[7] - tmp0[1] + (tmp0[3] - tmp0[5]) * 5.25f;

        float tmp12a = (tmp0[2] + tmp0[6] - tmp0[4] * 4.25f);
        float tmp12b = (tmp0[1] - tmp0[3] * 4.25f + tmp0[5]);

        V[m*8+1] = tmp12a + tmp12b;
        V[m*8+2] = tmp12a - tmp12b;

        float tmp34a = (tmp0[6] + tmp0[2] * 0.25f - tmp0[4] * 1.25f);
        float tmp34b = (tmp0[1] * 0.5f - tmp0[3] * 2.5f + tmp0[5] * 2.f);

        V[m*8+3] = tmp34a + tmp34b;
        V[m*8+4] = tmp34a - tmp34b;

        float tmp56a = (tmp0[6] + (tmp0[2] - tmp0[4] * 1.25f) * 4.f);
        float tmp56b = (tmp0[1] * 2.f - tmp0[3] * 2.5f + tmp0[5] * 0.5f);

        V[m*8+5] = tmp56a + tmp56b;
        V[m*8+6] = tmp56a - tmp56b;
    }

    //Matrix M^T=U^T.V^T
    float tempResult[64];
    for(int n=0;n<64;n++)
    {
        tempResult[n] = V[n]*U[n]; 
    }

//         const float otm[6][8] = {
//             {1.0f,  1.0f,   1.0f,   1.0f,   1.0f,  32.0f, 32.0f, 0.0f},
//             {0.0f,  1.0f,  -1.0f,   2.0f,  -2.0f,  16.0f,-16.0f, 0.0f},
//             {0.0f,  1.0f,   1.0f,   4.0f,   4.0f,   8.0f,  8.0f, 0.0f},
//             {0.0f,  1.0f,  -1.0f,   8.0f,  -8.0f,   4.0f, -4.0f, 0.0f},
//             {0.0f,  1.0f,   1.0f,  16.0f,  16.0f,   2.0f,  2.0f, 0.0f},
//             {0.0f,  1.0f,  -1.0f,  32.0f, -32.0f,   1.0f, -1.0f, 1.0f}
//         };

        // 0 = r0 + (r1 + r2) + (r3 + r4)     + (r5 + r6) * 32
        // 1 =      (r1 - r2) + (r3 - r4) * 2 + (r5 - r6) * 16
        // 2 =      (r1 + r2) + (r3 + r4) * 4 + (r5 + r6) * 8
        // 3 =      (r1 - r2) + (r3 - r4) * 8 + (r5 - r6) * 4
        // 4 =      (r1 + r2) + (r3 + r4) * 16+ (r5 + r6) * 2
        // 5 = r7 + (r1 - r2) + (r3 - r4) * 32+ (r5 - r6)

    //R = A^T.M.A
    float* pTempR = tempResult;
    float r[6][8];
    for (int m=0; m<8; m++)
    {
        float tmp024a = pTempR[1] + pTempR[2];
        float tmp135a = pTempR[1] - pTempR[2];

        float tmp024b = pTempR[3] + pTempR[4];
        float tmp135b = pTempR[3] - pTempR[4];

        float tmp024c = pTempR[5] + pTempR[6];
        float tmp135c = pTempR[5] - pTempR[6];

        r[0][m] = pTempR[0] + tmp024a + tmp024b + tmp024c * 32;
        r[2][m] = tmp024a + tmp024b * 4 + tmp024c * 8;
        r[4][m] = tmp024a + tmp024b * 16 + tmp024c + tmp024c;

        r[1][m] = tmp135a + tmp135b + tmp135b + tmp135c * 16;
        r[3][m] = tmp135a + tmp135b * 8 + tmp135c * 4;
        r[5][m] = pTempR[7] + tmp135a + tmp135b * 32 + tmp135c;

        pTempR+=8;
    }

    float result[64]; 
    float* pr = result;
    for (int m=0; m<6; m++)
    {
        const float* tmp0 = r[m];

        float tmp024a = tmp0[1] + tmp0[2];
        float tmp135a = tmp0[1] - tmp0[2];

        float tmp024b = tmp0[3] + tmp0[4];
        float tmp135b = tmp0[3] - tmp0[4];

        float tmp024c = tmp0[5] + tmp0[6];
        float tmp135c = tmp0[5] - tmp0[6];

        pr[0+6*m] = tmp0[0] + tmp024a + tmp024b + tmp024c * 32;
        pr[2+6*m] = tmp024a + tmp024b * 4 + tmp024c * 8;
        pr[4+6*m] = tmp024a + tmp024b * 16 + tmp024c + tmp024c;

        pr[1+6*m] = tmp135a + tmp135b + tmp135b + tmp135c * 16;
        pr[3+6*m] = tmp135a + tmp135b * 8 + tmp135c * 4;
        pr[5+6*m] = tmp0[7] + tmp135a + tmp135b * 32 + tmp135c;
    }

    float output[36];
    int stride_h = 1;
    int stride_w = 1;
    for(int h=0;h<6;h++)
    {
        int src_h = stride_h*h;
        for(int w=0;w<6;w++)
        {
            float sum = 0;
            int src_w = stride_w*w;
            for(int k_h=0;k_h<3;k_h++)
            {
                for(int k_w=0;k_w<3;k_w++)
                {
                    sum+=x[k_h+src_h][k_w+src_w]*weight[3*k_h+k_w];
                }
            }
            output[h*6+w] = sum;
        }
    }

    for(int i=0;i<36;i++)
        printf("%f==%f \n",output[i],result[i]);

    return 0;
}

 

WTHunt
关注
专栏目录
卷积神经网络参数和浮点计算量的公式
acrith
10-23 1315
本文是对卷积神经网络模型参数量和浮点运算量的计算推导公式和方法：
Winograd快速卷积算法论文的配套胶片
10-20
Winograd快速卷积算法论文的配套胶片，看完基本可以理解论文中主要思想，以及整体思路。
Winograd算法实现卷积原理
LuchangLi 的专栏
05-21 3137
Fast Algorithms for Convolutional Neural Networks Winograd算法实现卷积原理
Winograd 卷积计算
TH_NUM的博客
06-07 402
winograd的论文：https://arxiv.org/pdf/1509.09308.pdf [论文PPT] https://www.slideshare.net/embeddedvision/even-faster-cnns-exploring-the-new-class-of-winograd-algorithms-a-presentation-from-a...
winograd卷积实践
LuchangLi 的专栏
11-28 1993
winograd卷积实践
基于Winograd算法的卷积基本原理
qq_36665989的博客
08-07 1683
   Winograd算法是一种快速卷积算法，用于减少卷积运算中的乘法数量，代价是适当增加加法数量。首次将Winograd算法用于神经网络卷积运算的文章为参考文献[1]。    本文将基于该文章和几篇博文，介绍其基本原理。 1.一维卷积F(2,3)F(2,3)F(2,3)    首先以卷积F(2,3)F(2,3)F(2,3)为例介绍Winograd算法如何实现一维卷积。F(2,3)F(2,3)F(2,3)表示卷积核大小为3×13\times13×1，被卷积的向量大小为2+3−1=42+3-1=42+3−1=
Winograd卷积原理
hey-yahei
08-22 3757
原文链接：Winograd卷积原理 | Hey~YaHei! Winograd算法最早于1980年由Shmuel Winograd在《Arithmetic complexity of computations(1980)》中提出，主要用来减少FIR滤波器的计算量。 该算法类似FFT，将数据映射到另一个空间上，用加减运算代替部分乘法运算，在“加减运算速度远高于乘法运算”的前提下达到明显的加速效果（与...
【论文学习】快速卷积方法——Winograd 变换
Lingyun
05-12 3800
论文：Fast Algorithms for Convolutional Neural Networks 本博客关注于论文中Winograd 变换部分 在1D，2D和多维度中，最小算法需要等于输入数量的多次乘法。 换句话说，为了计算F（m，r），我们必须访问m + r-1个数据值的间隔，并且为了计算F（m×n，r×s），我们必须访问（m + r- 1）×（n + s-1）数...
浅探Winograd量化
hey-yahei
08-23 956
原文链接：浅探Winograd量化 | Hey~YaHei! 上一篇文章《Winograd卷积原理 | Hey~YaHei!》已经介绍过Winograd卷积的基本原理，但终究是理论上的推导，在实际应用的时候其实有些耐人寻味的地方：数学推导假设的是无限的精度和数值范围，但实际计算机的运算精度与数值范围都是有限的，不过按照论文《Fast algorithms for convolutional neu...
winograd 算法
05-11
winograd 算 法 的 代 码
winograd_winogrid_
10-02
AI的winograd算法源代码和测试程序，包括论文
winograd-fr
03-08
Wino相关
Winograd快速卷积相关研究综述
qq_61890005的博客
12-26 491
其中Winograd卷积因大幅减少了卷积中乘法操作且占用内存更小而迅速成为小卷积核的卷积算子上快速卷积实现的首选。但目前相关工作聚焦于算法的一般化、拓展和各类体系结构上的实现,还没有研究者对Winograd卷积算法作系统性的总结。首先阐述了Winograd最小滤波算法及Winograd卷积的引入,介绍了Winograd卷积的一般化与拓展,并对比了现有实现之间的差异;对各类体系结构上的实现和优化进行了分类总结,比较了各平台上实现可用的通用优化方法,并介绍了Winograd卷积的实际应用;
Winograd
qq_36783816的博客
11-12 1725
Paper 卷积神经网络中的Winograd快速卷积算法 流行的推理框架（加速器），如NCNN、NNPACK等，可以看到，对于卷积层，大家不约而同地采用了Winograd快速卷积算法，该算法出自CVPR 2016的一篇 paper：Fast Algorithms for Convolutional Neural Networks。 Winograd算法 原理 原理：用非耗时运算操作（如加法）替...
ncnn使用winograd的卷积实现条件及基本流程
qingsong1001的专栏
12-28 2361
NCNN的winograd卷积使用条件是： kernel为3x3，stride为1x1,kernel的扩展系数为1x1 输入和输出的channel个数大于等于32，小于等于128  bottom_blob padding后的blob 的width和height小于等于120 Winograd的卷积实现主要有如下几个步骤： 把kernel data进行扩充为8x8，并重新排列； 把bott...
Winograd大白话
Xiaozhou's Blog
07-20 9805
Winograd大白话
三种思路实现Winograd卷积, 配上代码的保姆级教程
hsqyc的博客
04-25 4331
三种思路实现Winograd卷积, 配上代码你一定能看得懂 前言 一般我们实现卷积的时候大多采用的方案是im2col+gemm, 除此之外, 还有一种加速方案, 就是Winograd卷积, 目前几乎在所有推理框架里都能找到其实现. Winograd卷积出自一篇2016CVPR论文. 网上相关的博客挺多的, 但是都几乎只是几个公式配几个图, 看完后似懂非懂, 没有对应代码总是会感觉少了点什么, 想去看各个推理框架的代码吧, 又对应不上, 看不懂. 本人经过一段时间的硬啃, 最终实现了Winograd多个思路的
winograd
B1009的博客
07-10 1027
使用winograd算法改进深度可分离卷积
最新发布
04-05
Winograd算法是一种优化卷积运算的算法，通过将卷积运算转换为一系列小矩阵乘法运算来加速计算。深度可分离卷积是一种卷积神经网络中常用的卷积运算，它可以减少参数数量和计算量，提高模型效率和速度。在深度可分离卷积中使用Winograd算法可以进一步提高计算效率，具体方法如下： 1. 将深度可分离卷积拆分为深度卷积和逐点卷积两个部分。 2. 对于深度卷积部分，将输入和卷积核分别转换为Winograd域中的小矩阵，进行矩阵乘法运算，再将结果转换回空间域。 3. 对于逐点卷积部分，不需要使用Winograd算法，直接在空间域中进行计算。 4. 将深度卷积和逐点卷积的结果相加得到最终输出。 使用Winograd算法改进深度可分离卷积可以减少计算量和内存使用，提高模型效率和速度。但需要注意的是，Winograd算法对于小尺寸卷积核和小批量大小效果不佳，因此需要根据具体情况选择是否使用。
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值