• 循环结构优化——针对具有多层嵌套的循环执行结构的优化
• 时间空间平衡——增加内存空间换取运算时间降低或者反过来的优化方法
• 运算精度和性能平衡——通过降低运算精度来提升运算速度并降低存储空间的方法
• 底层运算的快速实现算法——对于底层的乘除运算用等效的位操作提速
• 内存使用优化——通过调整运算次序或者复用内存，降低程序对嵌入式系统的最大内存需求

SVM（Support Vector Machine，支持向量机）是被广泛使用的分类算法，是神经网络热潮到来前应用最广泛的机器学习算法之一。SVM的数学描述一般是通过核空间的距离给出的，这里我们基于RBF（Radial Basis Function）核SVM的原理给出一个直觉上的解释，如果需要了解更加严格的理论分析，读者可以查阅本章参考文献。

SVM分类器根据物体的特征取值将其分为两类，图3-3给出了若干个物体样本在特征空间的位置，图中空心点和实心黑点分别表示两种不同的物体。

可以看出，空心点和实心黑点的分布位置具有一定的规律，从直觉上可以用图示虚线分离这两类点，在虚线上方的是第一类（空心点对应的类别），在虚线下方是第二类（实心黑点对应的类别）。SVM通过构建分类判别函数f(x)实现在两类物体的特征空间取不同的符号，比如在第一类物体特征空间（曲线上方）取值为正，在第二类物体特征空间（曲线下方）取值为负。在这个例子中，代表特征空间的点的坐标。

// 单通道卷积计算
void conv2d_f32(
    float *din,
    float *dout,
    int din_hgt,
    int din_wid,
    const float *ker,
    const int *shape)
{
    int k_hgt = shape[0], k_wid = shape[1];

    int dout_hgt = din_hgt - k_hgt + 1;
    int dout_wid = dout_wid - k_wid + 1;

    for (int h = 0; h < dout_hgt; h++)
    {
        for (int w = 0; w < dout_wid; w++)
        {
            for (int kh = 0; kh < k_hgt; kh++)
            {
                for (int kw = 0; kw < k_wid; kw++)
                {
                    dout[h][w] += din[h + kh][w + kw] * ker[kh][kw];
                }
            }
        }
    }
}
 

// 二维卷积层计算
void conv2d_f32(float *dout,       // 输出数据
                float *din,        // 输入数据
                int din_hgt,       // 输入数据（矩阵）高度
                int din_wid,       // 输入数据（矩阵）宽度
                const float *ker,  // 卷积核
                const float *bias, // 偏置
                const int *shape)  // 卷积核形状
{
    // 卷积核尺寸
    int num_cout = shape[0], num_cin = shape[1];
    int k_hgt = shape[2], k_wid = shape[3];

    // 输出数据尺寸
    int dout_hgt = (din_hgt - k_hgt + 1);
    int dout_wid = (din_wid - k_wid + 1);

    for (int cout = 0; cout < num_cout; cout++)
    {
        // 加上偏置
        for (int n = 0; n < dout_hgt * dout_wid; n++)
            dout[cout * dout_hgt * dout_wid + n] = bias[cout];

        // 对每个输入通道计算二维卷积
        for (int cin = 0; cin < num_cin; cin++)
        {
            // h和w是滑动窗位置
            for (int h = 0; h < dout_hgt; h++)
            {
                for (int w = 0; w < dout_wid; w++)
                {
                    // kh和kw是卷积核内的元素位置
                    for (int kh = 0; kh < k_hgt; kh++)
                    {
                        for (int kw = 0; kw < k_wid; kw++)
                        {
                            //  dout[cout][h][w] +=
                            //      din[cin][h+kh][w+kw] *
                            //      ker[cout][cin][kh][kw]
                            dout[cout * dout_hgt * dout_wid + h * dout_wid + w] +=
                                din[cin * din_hgt * din_wid + (h + kh) * din_wid + (w + kw)] *
                                ker[cout * num_cin * k_hgt * k_wid + cin * k_hgt * k_wid + kh * k_wid + kw];
                        }
                    }
                }
            }
        }
    }
    return;
}

##网络
class mnist_c(nn.Module):
    def __init_(self):
        super(mnist_c, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 5, 1)
        self.conv2 = nn.Conv2d(32, 32, 5, 1)
        self.dropout = nn.Dropout2d(0.4)
        self.fc1 = nn.Linear(512, 1024)
        self.fc2 = nn.Linear(1024, 10)

    # 浮点训练和推理
    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = F.max_pool2d(x, 2)
        x = self.conv2(x)
        x = F.relu(x)
        x = F.max_pool2d(x, 2)
        x = torch.flatten(x, 1)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.dropout(x)
        x = self.fc2(x)
        return x

上面的代码中，函数forward定义了神经网络的具体运算，相比之前的图3-15，上面的代码多了一个dropout运算（倒数第三行），这一运算用于在训练过程中将部分运算结果置零，这样能够提高神经网络训练效果，在神经网络推理运算中，dropout层的运算被直接跳过。

单精度能够表示的数值范围是

在IEEE754标准中，还定义了几种特殊的浮点数二进制形式，它们对应的数值不能用之前给出的公式计算。比如：“正无穷大”INF，它对应的二进制形式中E部分的位全为1，对应的M部分的所有位都是零；“无效数”NAN，它对应的二进制形式中E部分的位全为1，对应的M部分的位非全零。

之前的讨论给出了从二进制计算浮点数值的公式，这个公式是针对“规范化”的浮点数的。在应用中，大多数浮点数属于“规范化”浮点数，并适用于之前给出的公式。但IEEE754标准还定义了一类“非规范化”的数，这类浮点数的指数部分E全零，计算“非规范化”浮点数对应的公式和之前不同，具体如下。

• 单精度浮点数数值（非规范化）：

• 双精度浮点数数值（非规范化）：

“非规范化”浮点数能够表示的最小正数小于“规范化”浮点数的。由于“非规范化”浮点数存储尾数的有效数字减小，因此这一简化过程会损失一些计算精度。

对于纯软件实现的浮点运算的嵌入式系统（不带有浮点协处理器的嵌入式处理器），标准数学运算函数库的API在运算过程中尽量使用“规范化”形式存储的浮点数，但这一过程会占用一定的运算时间，对于速度有严格要求的应用，为了进一步降低预算时间，允许部分浮点数的运算使用非规范化的表示形式。对于拥有硬件浮点运算单元的处理器，硬件往往被优化成只针对“规范化”浮点数运算，对于这类系统，使用非规范化的浮点数运算需要额外的软件协助，反而会降低运算速度。

最常见的循环卷积优化是使用频域变换的方式实现的。前面介绍循环卷积时，提到可以用多项式表示循环卷积过程，基于频域变换的快速卷积算法可以通过多项式解释。考虑两个长度同为N的序列

其中：

令，于是有

式（5-19）表明x(p)和h(p)分别是序列

在频点nω的离散傅里叶变换。取ω=2π/N，“自动”满足

根据 y(p) 的多项式形式，可见此时可以通过 x(p)h(p) 的离散傅里叶反变换得到。于是我们可以用两次离散傅里叶变换和一次离散傅里叶反变换实现循环卷积，如下面的Python代码所示。

import numpy as np

# 生成循环卷积的测试序列x和h
N = 20
x = np.random.randint(-10, 10, N).astype(float)
h = np.random.randint(-10, 10, N).astype(float)

fx = np.fft.fft(x)  # 序列x的DFT
fh = np.fft.fft(h)  # 序列h的DFT

fy = fx * fh

y = np.fft.ifft(fy)  # 序列x和h的循环卷积结果

基于傅里叶变换的循环卷积可以写成下面的矩阵方程形式：

其中 W 是离散傅里叶变换矩阵（注意，该变换矩阵有几种不同的表示形式，相差一个比例因子N或者√N，本书使用定义使得W是酉矩阵）：

上面公式中代表W的共轭，符号⊙代表两个向量逐元素相乘，比如[1 2]⊙[10 100]=[10 200]；(Wx)和(Wh)分别看成数据序列x和h的“频域”表示，而乘以的运算代表频域到时域的反变换运算。这一变换过程如图5-5所示。

• 5.3.1 基于卷积核低秩分解的二维快速卷积
• 5.3.2 矩形卷积核近似卷积
• 5.3.3 分段线性卷积核近似
• 5.3.4 卷积核的分段近似
• 5.3.5 基于IIR滤波器的近似卷积
• 5.3.6 基于卷积核低秩近似的二维近似快速卷积
• 5.3.7 基于二维矩形卷积核的近似快速卷积