深度学习（十一）——Winograd（1）

最新推荐文章于 2024-06-10 17:39:23 发布

antkillerfarm

最新推荐文章于 2024-06-10 17:39:23 发布

阅读量2.2w

点赞数 5

分类专栏：深度学习文章标签：深度学习

本文链接：https://blog.csdn.net/antkillerfarm/article/details/78769624

版权

深度学习专栏收录该内容

47 篇文章 55 订阅

订阅专栏

https://antkillerfarm.github.io/

Winograd（续）

基本思想

下文的大部分内容摘自Parhi的书《VLSI Digital Signal Processing Systems: Design and Implementation》

Keshab K. Parhi，Indian Institute of Technology Kharagpur本科（1982年）+宾夕法尼亚大学硕士（1984年）+UCB博士（1988年）。明尼苏达大学教授。

Fast Convolution

我们这里以一个简单的例子，介绍一下Fast Convolution的基本思想。

复数运算

(a + j b) (c + d j) = e + j f

$(a+jb)(c+dj)=e+jf$ 可以写成如下的矩阵形式：

[e f] = [c d - d c] [a b]

$\begin{bmatrix} e \\ f \\ \end{bmatrix}= \begin{bmatrix} c & -d \\ d & c \\ \end{bmatrix} \begin{bmatrix} a \\ b \\ \end{bmatrix}$

上式包含了4个乘法和2个加法。

我们知道，乘法和加法在硬件实现上的时间复杂度一般是不一样的，乘法运算所需的时间通常远大于加法所需的时间。因此，用廉价运算代替昂贵运算就成为了加速运算的一种方法。

具体到上面的例子：

{a c - b d = a (c - d) + d (a - b) a d + b c = b (c + d) + d (a - b)

$\begin{cases} ac − bd = a ( c − d ) + d ( a − b )\\ ad + bc = b ( c + d ) + d ( a − b ) \\ \end{cases}$

这个公式包含了3个乘法和5个加法，也就是说我们用3个加法替代了1个乘法，显然只要1个乘法所需的时间大于3个加法的时间，这样的变换就是有意义的。

上式可以写成如下的矩阵形式：

[e f] = [100111] \cdot ⎡ ⎣ ⎢ c - d 00 0 c + d 0 00 d ⎤ ⎦ ⎥ \cdot ⎡ ⎣ ⎢ 101 01 - 1 ⎤ ⎦ ⎥ \cdot [a b] = C \cdot H \cdot D \cdot x

$\begin{bmatrix} e \\ f \\ \end{bmatrix}= \begin{bmatrix} 1 & 0 & 1 \\ 0 & 1 & 1 \\ \end{bmatrix}\cdot \begin{bmatrix} c-d & 0 & 0 \\ 0 & c+d & 0 \\ 0 & 0 & d \\ \end{bmatrix}\cdot \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 1 & -1\\ \end{bmatrix}\cdot \begin{bmatrix} a \\ b \\ \end{bmatrix}=C \cdot H \cdot D \cdot x$

这里的H是对角矩阵。

Fast Convolution算法主要有基于Lagrange插值的Cook-Toom算法和基于中国剩余定理（Chinese remainder theorem）的Winograd算法。

向量卷积与多项式乘法

在继续介绍之前，我们首先看一下向量卷积与多项式乘法之间的关系。

我们首先来看一个简单的多项式乘法的例子：

(x 2 + 2 x + 2) (3 x + 2) = 3 x 3 + (2 \times 3 + 1 \times 2) x 2 + 10 x + 4

$(x^2+2x+2)(3x+2)=3x^3+\color{red}{(2\times 3+1\times 2)}x^2+10x+4$

上式中红色的部分是有意保留下来没有合并的同类项，是不是感觉上和卷积运算十分类似呢？

我们知道矩阵的定义，除了最原始的线性方程定义之外，还有线性向量空间定义。而多项式可以看做是 ${1,x,x^2,\dots}$ 为基的空间向量，因此用多项式表示矩阵或者卷积运算，是一种很自然的方式。

这是有限离散域的Convolution定义：

(f * g) [n] = \sum m = - M M f [n - m] g [m]

$(f * g)[n]=\sum_{m=-M}^M f[n-m]g[m]$

注：这里的Convolution和DL领域的Convolution的定义略有不同，后者实际上是数学上的Cross-correlation运算，但稍加变化，就可以变为前者。

由多项式乘法的规则和Convolution定义可得：（这里以2x2的Convolution为例）

令 $h(p)=h_0+h_1p,x(p)=x_0+x_1p,s(p)=h(p)x(p)=s_0+s_1p+s_2p^2$ ，则 $s(p)$ 的系数 $s_i$ 正好为i点的卷积值 $Conv_i(h,x)$ 。

上述事实用矩阵可表示为：

⎡ ⎣ ⎢ s 0 s 1 s 2 ⎤ ⎦ ⎥ = ⎡ ⎣ ⎢ h 0 h 1 0 0 h 0 h 1 ⎤ ⎦ ⎥ \cdot [x 0 x 1]

$\begin{bmatrix} s_0 \\ s_1 \\ s_2 \\ \end{bmatrix}= \begin{bmatrix} h_0 & 0 \\ h_1 & h_0 \\ 0 & h_1 \\ \end{bmatrix}\cdot \begin{bmatrix} x_0 \\ x_1 \\ \end{bmatrix}$

向量卷积与多项式乘法的这个性质，在数值计算领域应用的比较广泛。Matlab中多项式的乘法计算，实际上就是计算一个卷积。

如果令p=10，则多项式乘法就变成了大整数乘法，因此卷积运算在大整数乘法中，也有很重要的地位。

参见：

http://www.cnblogs.com/larch18/p/4569495.html

向量卷积与多项式乘法

http://blog.sina.com.cn/s/blog_455c7a6001010t3h.html

卷积和与多项式乘法的关系

Cook-Toom algorithm

Andrei Leonovich Toom，俄国数学家。

Stephen Cook，1939年生，密歇根大学本科（1961年）+哈佛硕博（1962年、1966年）。多伦多大学教授，图灵奖获得者（1982年）。

Cook的生平虽然让我感兴趣，然而我更感兴趣的却是他的导师王浩。
王浩，1921年~1995年，数理逻辑学家，山东人。西南联大本科（1943年）+清华硕士（1945年）+哈佛博士（1948年）。先后执教于哈佛大学、牛津大学和洛克菲勒大学。英国皇家学会会员。IJCAI第一届“数学定理机械证明里程碑奖”获得者。
鉴于这是一个大路货的名字，这里特给出百度百科的网址：
https://baike.baidu.com/item/王浩/22564

这里仍以上述2x2的Convolution为例，讲述一下Cook-Toom算法的步骤。

β 0 = 0, h (β 0) = h 0, x (β 0) = x 0

$\beta_0=0, h(\beta_0)=h_0, x(\beta_0)=x_0$

β 1 = 1, h (β 1) = h 0 + h 1, x (β 1) = x 0 + x 1

$\beta_1=1, h(\beta_1)=h_0+h_1, x(\beta_1)=x_0+x_1$

β 2 = - 1, h (β 2) = h 0 - h 1, x (β 2) = x 0 - x 1

$\beta_2=-1, h(\beta_2)=h_0-h_1, x(\beta_2)=x_0-x_1$

接着计算 $s(\beta_i)$ ；

s (β 0) = h (β 0) x (β 0), s (β 1) = h (β 1) x (β 1), s (β 2) = h (β 2) x (β 2)

$s(\beta_0)=h(\beta_0)x(\beta_0),s(\beta_1)=h(\beta_1)x(\beta_1),s(\beta_2)=h(\beta_2)x(\beta_2)$

有了3个已知点，就可以应用Lagrange插值了（Lagrange插值的内容可参见《机器学习（一）》）：

s (p) = s (β 0) ( p - β 1 ) ( p - β 2 ) ( β 0 - β 1 ) ( β 0 - β 2 ) + s (β 1) ( p - β 0 ) ( p - β 2 ) ( β 1 - β 0 ) ( β 1 - β 2 ) + s (β 2) ( p - β 0 ) ( p - β 1 ) ( β 2 - β 0 ) ( β 2 - β 1 ) = s (β 0) + p (s ( β 1 ) - s ( β 2 ) 2) + p 2 (- s (β 0) + s ( β 1 ) + s ( β 2 ) 2) = s 0 + p s 1 + p 2 s 2

$\begin{align}s(p)&=s(\beta_0)\frac{(p-\beta_1)(p-\beta_2)}{(\beta_0-\beta_1)(\beta_0-\beta_2)}+s(\beta_1)\frac{(p-\beta_0)(p-\beta_2)}{(\beta_1-\beta_0)(\beta_1-\beta_2)}+s(\beta_2)\frac{(p-\beta_0)(p-\beta_1)}{(\beta_2-\beta_0)(\beta_2-\beta_1)} \\&=s(\beta_0)+p\left(\frac{s(\beta_1)-s(\beta_2)}{2}\right)+p^2\left(-s(\beta_0)+\frac{s(\beta_1)+s(\beta_2)}{2}\right) \\&=s_0+ps_1+p^2s_2 \end{align}$

上式用矩阵形式可表示为：

⎡ ⎣ ⎢ s 0 s 1 s 2 ⎤ ⎦ ⎥ = ⎡ ⎣ ⎢ 10 - 1 011 0 - 1 1 ⎤ ⎦ ⎥ \cdot ⎡ ⎣ ⎢ s (β 0) s (β 1) / 2 s (β 2) / 2 ⎤ ⎦ ⎥ = ⎡ ⎣ ⎢ 10 - 1 011 0 - 1 1 ⎤ ⎦ ⎥ \cdot ⎡ ⎣ ⎢ h (β 0) 00 0 h (β 1) / 2 0 00 h (β 2) / 2 ⎤ ⎦ ⎥ \cdot ⎡ ⎣ ⎢ x (β 0) x (β 1) x (β 2) ⎤ ⎦ ⎥ = ⎡ ⎣ ⎢ 10 - 1 011 0 - 1 1 ⎤ ⎦ ⎥ \cdot ⎡ ⎣ ⎢ h 0 00 0 (h 0 + h 1) / 2 0 00 (h 0 - h 1) / 2 ⎤ ⎦ ⎥ \cdot ⎡ ⎣ ⎢ 111 01 - 1 ⎤ ⎦ ⎥ \cdot [x 0 x 1]

$\begin{align} \begin{bmatrix} s_0 \\ s_1 \\ s_2 \\ \end{bmatrix} &=\begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & -1 \\ -1 & 1 & 1 \\ \end{bmatrix}\cdot \begin{bmatrix} s(\beta_0) \\ s(\beta_1)/2 \\ s(\beta_2)/2 \\ \end{bmatrix} \\&=\begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & -1 \\ -1 & 1 & 1 \\ \end{bmatrix}\cdot \begin{bmatrix} h(\beta_0) & 0 & 0 \\ 0 & h(\beta_1)/2 & 0 \\ 0 & 0 & h(\beta_2)/2 \\ \end{bmatrix}\cdot \begin{bmatrix} x(\beta_0) \\ x(\beta_1) \\ x(\beta_2) \\ \end{bmatrix} \\&=\begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & -1 \\ -1 & 1 & 1 \\ \end{bmatrix}\cdot \begin{bmatrix} h_0 & 0 & 0 \\ 0 & (h_0+h_1)/2 & 0 \\ 0 & 0 & (h_0-h_1)/2 \\ \end{bmatrix}\cdot \begin{bmatrix} 1 & 0 \\ 1 & 1 \\ 1 & -1 \\ \end{bmatrix}\cdot \begin{bmatrix} x_0 \\ x_1 \\ \end{bmatrix} \end{align}$

表面看起来这里多了2个除法，似乎计算量更大了，但是：

1.除以2，对于2进制的计算机来说是个简单运算。

2.如果大量卷积运算的其中一方不变的话，例如CNN中的kernel，这些运算都可以在预处理阶段计算。

Cook-Toom algorithm的缺点在于：当卷积核较大时，增加的加法数量以远超核大小的速度增长，最终会导致增加的加法所耗费的时间甚至超过节省下来的乘法所耗费的时间。