在 上一节 中，我们知道对偶函数的极大化与最大熵模型的极大似然估计是等价的，因此，我们可以通过求解最大熵模型的极大似然估计问题来求解对偶函数的极大化问题，进而求解原始优化问题，这也是本节介绍的改进的迭代尺度法的思路。而拟牛顿法可通过直接求解的方式得到最优化的最大熵模型。

改进的迭代尺度法

在 上一节 中我们得到的最大熵模型的对数似然函数为：

$$\mathcal{L}(w)=\Sigma_{x,y}\widetilde{P}(x,y)\Sigma_{i=1}^nw_if_i(x, y)-\Sigma_x\widetilde{P}(x)logZ_w(x)$$

其中，$Z_w(x)=\Sigma_yexp(\Sigma_{i=1}^nw_if_i(x, y))$。

将最大熵原理应用在分类问题上，就得到了最大熵模型，而为了讲述最大熵原理，我们首先介绍熵的概念。

熵以及最大熵原理

熵的概念

设 $X$ 为可取有限个不确定值的离散型随机变量，它的概率分布为：

$$P(X=x_i)=p_i$$

则该随机变量 $X$ 的熵定义为：

$$H(P)=-\Sigma_xp_ilogp_i$$

特别地，令 $0log0=0$。上式中对数底为 $2$ 时，熵的单位为比特（bit），对数底为 $e$ 时，熵的单位为纳特（nat）。随机变量的熵反映了随机变量取值的不确定性程度。熵的取值范围如下：

$$0 \leq H(P) \leq log|X|$$

上式中，$|X|$ 代表随机变量 $X$ 的取值个数。当随机变量的概率分布为均匀分布时，其熵取得最大值。

logistic 回归模型用于分类问题，它是概率模型，同时属于对数线性模型。这是什么意思呢？概率模型，说明最后学到的模型形式是 $P(Y|X=x)$，其中 $X$ 是特征，$Y$ 是类别。对数线性模型，说明与学得的模型 $P(Y|X=x)$ 有关的某种对数形式与输入特征 $x$ 存在着某种线性关系。针对 logistic 回归模型，这种线性关系表现在 $P(Y|X=x)$ 的某种对数形式与函数 $w \cdot x + b$（$w$ 为权重参数，$b$ 为偏置参数）相等。事实上，基于这两点，我们可以推导出 logistic 回归模型的数学形式。

首先，我们从最简单的用于二分类的二项 logistic 回归模型说起，之后推广到用于多分类的多项 logistic 回归模型。

二项 logistic 回归模型

对于二分类问题，设分类标签 $Y \in \{1, 0\}$。我们首先观察一下线性函数 $w \cdot x + b$，$w$ 和 $b$ 是需要学习的参数，对它们的取值范围不加任何限制，也就是说，其取值范围为 $(-\infty, +\infty)$，而 $P(Y|X=x) \in [0, 1]$，将一个 $[0, 1]$ 范围内的数映射到 $(-\infty, +\infty)$ 范围上，需要经过某种变换，在这里，我们使用对数几率变换，即 logit 变换。

拉格朗日对偶常用于带约束条件的最优化问题上，为了系统讲述这种方法的思想，我们首先引入一个带约束条件的最优化问题：

$$\quad min_xf(x) \\ s.t.\quad c_i(x) \leq 0 \quad (i=1, 2, …, k) \\ \quad h_j(x)=0 \quad (j=1, 2, …, l)$$

其中，$f(x)、c_i(x)、h_j(x)$ 分别是定义在 $x \in \mathbb{R}^n$ 上的连续可微函数。对于此类带约束条件的优化问题，一般我们考虑使用拉格朗日乘子法解决，首先引入拉格朗日乘子 $\alpha_i(\alpha_i \geq 0), \beta_j$，构造广义拉格朗日函数如下：

$$L(x, \alpha, \beta)=f(x)+\Sigma_{i=1}^{k} \alpha_i \cdot c_i(x)+\Sigma_{j=1}^l \beta_j \cdot h_j(x)$$

本文首先从一个不带约束条件的最优化问题出发，导出用以解决此类问题的牛顿法，接着针对牛顿法涉及的计算复杂问题，阐述在此基础上改进得到的拟牛顿法的思路。

牛顿法

我们首先引入如下最优化问题：

$$min_{x\in{\mathbb{R}^n}}f(x)$$

若 $f(x)$ 在其定义域内具有二阶连续偏导数，在其定义域内任取一点 $x^{(k)}$，将 $f(x)$ 在点 $x^{(k)}$ 处进行二阶泰勒展开，得：

$$f(x)=f(x^{(k)})+g_k^T(x-x^{(k)})+\frac{1}{2}(x-x^{(k)})^TH_k(x-x^{(k)})$$

其中，${g_k}=\nabla_{x^{(k)}}f(x^{(k)})$，$H_k=(\frac{\partial^2 f(x^{(k)})}{\partial x_i \partial x_j})_{n \times n}$，该矩阵 $H_k$ 称为 Hessian 矩阵，当 $x \to x^{(k)}$ 时上式成立（即在 $x^{(k)}$ 的小邻域内成立）。由以上引入的最优化问题，我们需要得到 $x^{(k)}$ 小邻域内的极小值，而 $f(x)$ 在 $x^{(k)}$ 小邻域内取得极值的必要条件是 $\nabla_{x}f(x)=0$，在上式中令 $\nabla_{x}f(x)=0$，得：

朴素贝叶斯算法主要解决什么问题？它是怎么解决这类问题的？如何证明这种解决方法是有效的？本节将从这三方面详细介绍朴素贝叶斯算法的相关内容。

朴素贝叶斯算法主要解决什么问题

朴素贝叶斯算法主要用来处理分类问题，也就是说，我们给算法某个对象的输入特征（通常是向量形式），算法能够根据这个输入特征判断含有这种特征的对象属于预先定义的哪一类。我们所熟悉的垃圾邮件分类问题是朴素贝叶斯算法的典型应用场景。为方便下文论述，我们首先对使用朴素贝叶斯算法解决分类问题进行数学建模，设分类问题的输入空间 $\chi \subseteq \mathbb{R}^n$，输出空间 $\mathbb{y} = ${$c_1, c_2, …, c_K$}$ $，即输入空间定义为 $n$ 维实数向量的子空间，输出空间包含了 $K$ 个预先定义的类别。某一特定问题的输入 $x \in \chi$，输出 $y \in \mathbb{y}$，即朴素贝叶斯算法建立了一个从某个对象提取的特征向量（这里的特征向量和线性代数里面的特征向量是不同的概念，这里指的是能反映该对象特征的向量）到该对象所属类别的一个映射。

1 . gerattr、setattr 与 __getattr__、__setattr__。

• result = obj.name 会调用 buildin 函数 getattr(obj, 'name')，如果该属性找不到，会调用 obj.__getattr__('name')，没有实现 __getattr__ 或者 __getattr__ 也无法处理的就会 raise AttributeError;
• obj.name = value 会调用 buildin 函数 setattr(obj, 'name', value)，如果 obj 对象实现了 __setattr__ 方法，setattr 会直接调用 obj.__setattr__('name', value)。

nn.Module 实现了自定义的 __setattr__ 函数，当执行 module.name = value 时，会在 __setattr__ 中判断 value 是否为 Parameter 或 nn.Module 对象，如果是则将这些对象加到 _parameters 和 _modules 这两个字典中，而如果是其他类型的对象，如 Variable、list、dict 等，则调用默认的操作，将这个值保存在 __dict__ 中。

Input:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import torch as t
from torch import nn

module = nn.Module()
module.param = nn.Parameter(t.ones(2, 2))
print(module._parameters)

submodule1 = nn.Linear(2, 2)
submodule2 = nn.Linear(2, 2)
module_list = [submodule1, submodule2]
# 对于 list 对象，调用 buildin 函数，保存在 __dict__ 中
module.submodules = module_list
print('_modules: ', module._modules)
print("__dict__['submodules']:", module.__dict__.get('submodules'))

module_list = nn.ModuleList(module_list)
module.submodules = module_list
print('ModuleList is instance of nn.Module: ', isinstance(module_list, nn.Module))
print('_modules: ', module._modules)
print("__dict__['submodules']: ", module.__dict__.get('submodules'))

Output:

因 _modules 和 _parameters 中的 item 未保存在 dict 中，所以默认的 getattr 方法无法获取它，因而 nn.Module 实现了自定义的 __getattr__ 方法，如果默认的 getattr 无法处理，就调用自定义的 __getattr__ 方法，尝试从 _modules、_parameters 和 _buffers 这三个字典中获取。

Input:

1
2
3
4
5
6
7
8
9
10
11

print(getattr(module, 'training'))  # 等价于 module.training
# error
# print(module.__getattr__('training'))

module.attr1 = 2
print(getattr(module, 'attr1'))
# error
# print(module.__getattr__('attr1'))

# 即 module.param，会调用 module.__getattr__('param')
print(getattr(module, 'param'))

Output:

1 . nn 中的大多数 layer，在 nn.functional 中都有一个与之相对应的函数，nn.functional 中的函数和 nn.Module 的主要区别在于，用 nn.Module 实现的 layers 是一个特殊的类，都是由 class layer(nn.Module) 定义，会自动提取可学习的参数，而 nn.functional 中的函数更像是纯函数，由 def function(input) 定义。

Input:

1
2
3
4
5
6
7
8
9
10
11
12

import torch as t
from torch import nn

input = t.randn(2, 3)
model = nn.Linear(3, 4)
output1 = model(input)
output2 = nn.functional.linear(input, model.weight, model.bias)
print(output1 == output2)

b = nn.functional.relu(input)
b2 = nn.ReLU()(input)
print(b == b2)

Output:

如果模型有可学习的参数，最好用 nn.Module，否则既可以用 nn.Module 也可以使用 nn.functional，二者在性能上没有太大差异。但 dropout 操作虽然没有可学习的参数，但还是建议使用 nn.Dropout 而不是 nn.functional.dropout，因为 dropout 在训练和测试两个阶段的行为有所差异，使用 nn.Module 对象能够通过 model.eval 操作加以区分。

在模型中搭配使用 nn.Module 和 nn.functional：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

from torch import nn
from torch.nn import functional as F


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = F.pool(F.relu(self.conv1(x)), 2)
        x = F.pool(F.relu(self.conv2(x)), 2)
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

对于不具备可学习参数的层（激活层、池化层等），将它们用函数代替，这样则可以不用放置在构造函数 __init__ 中。

1 . PyTorch 实现了如今最常用的三种循环神经网络（RNN）：RNN(vanilla RNN)、LSTM 和 GRU，此外还有对应的三种 RNNCell，RNN 和 RNNCell 层的区别在于前者能够处理整个序列，而后者一次只处理序列中一个时间点的数据，前者封装更完备更易于使用，后者更具灵活性。实际上 RNN 层的一种后端实现方式就是调用 RNNCell 来实现的。

1
2
3
4
5
6
7
8
9
10
11
12
13

import torch as t
from torch import nn

t.manual_seed(1000)
# 输入：batch_size=3，序列长度都为 2，序列中每个元素占 4 维
input = t.randn(2, 3, 4)
# lstm 输入向量 4 维，隐藏元 3，1 层
lstm = nn.LSTM(4, 3, 1)
# 初始状态：1 层，batch_size=3，3 个隐藏元
h0 = t.randn(1, 3, 3)
c0 = t.randn(1, 3, 3)
out, hn = lstm(input, (h0, c0))
print(out)

1
2
3
4
5
6
7
8
9
10
11

t.manual_seed(1000)
input = t.randn(2, 3, 4)
# 一个 LSTMCell 对应的层数只能是一层
lstm = nn.LSTMCell(4, 3)
hx = t.randn(3, 3)
cx = t.randn(3, 3)
out = []
for i_ in input:
    hx, cx = lstm(i_, (hx, cx))
    out.append(hx)
t.stack(out)

词向量在自然语言中应用十分普及，PyTorch 同样提供了 Embedding 层。

1
2
3
4
5
6
7
8

# 有 4 个词，每个词用 5 维的向量表示
embedding = nn.Embedding(4, 5)
# 可以用训练好的词向量初始化 embedding
embedding.weight.data = t.arange(0, 20).view(4, 5)

input = t.arange(3, 0, -1).long()
output = embedding(input)
print(output)

1 . 图像的卷积操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import torch as t
from torch import nn
from PIL import Image
from torchvision.transforms import ToTensor, ToPILImage

to_tensor = ToTensor()
to_pil = ToPILImage()
lena = Image.open('path to your image')

# 输入是一个 batch，batch_size=1
input = to_tensor(lena).unsqueeze(0)

# 锐化卷积核
kernel = t.ones(3, 3)/-9
kernel[1][1] = 1
conv = nn.Conv2d(1, 1, (3, 3), 1, bias=False)
conv.weight.data = kernel.view(1, 1, 3, 3)

out = conv(input)
to_pil(out.data.squeeze(0))