复杂函数建模

前面我们研究的梯度下降法分类，是简单的对每类中每个子词的分数进行求和，统计分数最大的类别并不断调整分数来提高准确率。
我们可以修改函数模型，用更加复杂的函数代替sum()，来达到更好的学习效果。

def compute_instance(model, lin):
    
    rs = {}
    _max_score, _max_class = -inf, None
    for _class, v in model.items(): #对模型中的每一类和类型的词典 v:{word: freq}
        rs[_class] = _s = sum(v.get(_word, 0.0) for _word in lin) #这个类的分数即为该类中所有子词分数之和
        if _s > _max_score:
            _max_score = _s
            _max_class = _class
        #获取分数最高的类别
        
    return rs, _max_class, _max_score

采用梯度下降法计算机进行预测时，我们的corpus中每一行数据对应15类都有一个分数，取分数最大的_max_class作为预测类别，返回的rs存放着每个类别的分数，相当于一个向量。由分析得出，在计算机中是通过函数来判断的。

表示层

之前我们每个词在每个类上初始化一个分数，也就是说用15个分数来表示一个词。
现在我们要更丰富的表示一个词，用一个向量k表示。k可以是很大的数 eg. k>100. 维度64

例如假设我们一共有8000个词，我们可以建立一个8000*64的矩阵，为每个单元初始化一个初值。则拼接成则个矩阵的每个行向量就代表这个子词。

特征生成：函数计算 （神经网络层）

根据已有的特征合并学习新的特征。例如一个人的特征：1.爱吃肉或菜；2.爱吃甜口或辣口。我们将特征1和2合并可以得到新的特征，能推断出更丰富信息例如他爱吃哪道菜。（爱吃菜and辣口----麻婆豆腐）

pytorch向量计算

用向量初始化权重与特征，做内积可以得到新的权重：

>>> import torch
>>> a = torch.randn(4)
>>> a
tensor([ 0.9045,  0.2413, -0.2746, -0.9162])
>>> b = torch.randn(4)
>>> (a*b).sum()		#a*b的和，做数乘
tensor(-2.1851)
>>> a*b
tensor([-1.3204, -0.3658, -0.2360, -0.2630])
>>> b.unsqueeze(1)	#将b转化为列向量
tensor([[-1.4598],
        [-1.5161],
        [ 0.8592],
        [ 0.2870]])
>>> a.unsqueeze(0)	#将a转化为行向量
tensor([[ 0.9045,  0.2413, -0.2746, -0.9162]])
>>> a.unsqueeze(0).mm(b.unsqueeze(1))	#求a和b的内积
tensor([[-2.1851]])	#结果为一个一维向量
>>> c=torch.randn(4)
>>> torch.cat([b.unsqueeze(1),c.unsqueeze(1)],dim=1)	#将b和c转化为列向量后拼接起来
tensor([[-1.4598,  0.3766],
        [-1.5161, -0.1238],
        [ 0.8592, -0.7182],
        [ 0.2870, -1.8328]])
>>> c.unsqueeze(1)
tensor([[ 0.3766],
        [-0.1238],
        [-0.7182],
        [-1.8328]])
>>> a.unsqueeze(0).mm(torch.cat([b.unsqueeze(1),c.unsqueeze(1)],dim=1))	#将行向量a分别与列向量b，c拼接起来的矩阵做乘法
tensor([[-2.1851,  2.1872]])
>>> (a*b).sum()
tensor(-2.1851)
>>> (a*c).sum()			#做数乘的值即为结果矩阵中每一项的值
tensor(2.1872)

>>> w = torch.randn(4,5)	#初始化4行5列的权重矩阵
>>> w
tensor([[ 0.6165,  0.8714,  1.8304, -2.2638,  0.8837],
        [-0.3679, -0.9885, -2.0797, -0.9804, -0.6806],
        [-1.4536,  1.0211, -0.4079, -0.4373, -0.9353],
        [-1.0958, -1.1655,  1.1883, -1.8312, -0.2542]])
>>> a.unsqueeze(0).mm(w)	#将a变成行向量与权重矩阵w做乘法就会得到五个特征
tensor([[ 1.8721,  1.3370,  0.1771, -0.4864,  1.1249]])

激活函数

如果我们输入的向量是v，构建出的矩阵L，为了提取多种特征，我们对其进行矩阵乘法运算，乘以不同的权重矩阵W_i：
$$L\ast W_1\ast W_2\ast W_3\ast ...\ast W_n$$
但由于乘法的结合律，上面的式子等价于
$$L\ast W_x,W_x=W_1\ast W_2\ast W_3\ast ...\ast W_n$$
我们原本的n个变化W_1~W_n变为一个权重矩阵W_x，仅相当于做了一次变换，我们为了提取多重复杂特征而乘不同的权重矩阵的目的并没有实现。
为了解决由乘法的结合律带来的影响，我们使用非线性函数做激活函数，上面的式子变为：
$$act(...act(act(act(L\ast W_1)\ast W_2)\ast W_3)\ast ...\ast W_n)$$
常见的激活函数有$ReLU$激活函数。$ReLU$ 函数的特点是，当输入小或等于0，则返回0，当输入大于0时，则返回输入值，公式如下所示。
$relu(x)=\{\begin{array}{ll}0,& x\le 0\\ x,& x>0\end{array}$
$relu(x)=max(x,0)$，则此函数中阈值为0发生变化。但如果我们想让函数发生偏移，使其阈值发生变化，则我们需要设置偏移量b_i:
$$act(...act(act(act(L\ast W_1+b_1)\ast W_2+b_2)\ast W_3+b_3)\ast ...\ast W_n+b_n)$$

>>> bias = torch.randn(5) #初始化偏差
>>> bias
tensor([ 1.1344, -0.1908, -1.1020,  0.2254, -1.5253])
>>> a.unsqueeze(0).mm(w)+bias #L*W_1+b_1
tensor([[ 1.0301,  0.5540, -1.7541, -0.0260, -2.1016]])
>>> (a.unsqueeze(0).mm(w)+bias).relu()
tensor([[1.0301, 0.5540, 0.0000, 0.0000, 0.0000]])

在调用relu()函数后，小于0的部分都被置为0，大于0则保留。

解析分类：分类器

假设有k个（k>10）向量，每个向量是64维的，在神经网络层可能会分为 n * 128 的向量，分类器作用是将128维的向量变换为15维（我们预测的文本共有15个类）。

>>> w2 = torch.randn(5,8)
>>> (a.unsqueeze(0).mm(w)+bias).relu().mm(w2)+torch.randn(8)
tensor([[-1.6464, -0.0626, -0.9157, -0.1282, -3.2316, -0.4933, -0.6772,  0.7208]])

我们若分为8类，则建立一个5x8的矩阵，并设置一个偏移量，长度应该与分类数一致。如上，得到的向量最大的一项是-0.0626，因此判定为第二类。

链式求导与反向传播

多元函数求导链式法则：
$$\frac{df(g(x))}{dx}=\frac{df(g(x))}{g(x)}\ast \frac{dg(x)}{dx}$$
则对于：$act(act(act(L\ast W_1+b_1)\ast W_2+b_2)\ast W_3+b_3)$
设$f(g(x))=act(L\ast W_1+b_1)$,$h=g(x)=L\ast W_1+b_1$
有$$\frac{df(h)}{dx}=\frac{df(h)}{h}\ast \frac{dg(x)}{dx}$$

>>> a.unsqueeze(0).mm(w)+bias
tensor([[ 1.0301,  0.5540, -1.7541, -0.0260, -2.1016]])
>>> (a.unsqueeze(0).mm(w)+bias).relu()
tensor([[1.0301, 0.5540, 0.0000, 0.0000, 0.0000]])
>>> torch.tensor([1,1,0,0,0])
tensor([1, 1, 0, 0, 0])

最终tensor([1, 1, 0, 0, 0])即为$f(h)/h$的导数值。

运算速度对比

我们对比Python单线程程序和pytorch运算向量数乘的时间差别：

#encoding: utf-8

from random import uniform
import torch
from time import time

vsize = 16384   #设置一维向量的长度
nrun = 1280     #设置算多少轮

a = [uniform(-1.0,1.0) for _ in range(vsize)] #初始化向量
b = [uniform(-1.0,1.0) for _ in range(vsize)]

c = torch.tensor(a) #初始化tensor张量
d = torch.tensor(b)

def dot(a, b):  #求a与b的内积，python实现
    _s = 0.0
    for au, bu in zip(a,b):
        _s += au * bu
    return _s
 
_st = time()
for _ in range(nrun):
    rs = dot(a,b)
_et = time()
print("Python运算时间：%f"%(_et - _st))
 
_st = time()
for _ in range(nrun):
    rs = c.dot(d)
_et = time()
print("pytorch运算时间：%f"%(_et - _st))

:~/nlp/tnews$ python test_torch.py 
Python运算时间：0.434339
pytorch运算时间：0.007864

我们可以看到，时间相差50倍左右，因此用pytorch进行向量运算速度明显更快。

向量a乘m* n矩阵速度优于乘n个m*1列向量

#encoding: utf-8

from random import uniform
import torch
from time import time

bsize = 1
vsize = 512     
osize = 768
nrun = 1280

a = torch.randn(bsize,vsize)    #a为1*512向量
w = torch.randn(vsize,osize)    #w为512*768向量
w1 = w.narrow(1, 0, osize // 2) #w1为w的前半部分矩阵
w2 = w.narrow(1, osize // 2, osize // 2) #w2为后半部分
#narrow(dim,start,length) 传参均为整数，分别代表(维度，起始索引，区间长度)
#a*w结果为bsize * osize 的矩阵

_st = time()
for _ in range(nrun): 
    _rs = a.mm(w)               #a乘以矩阵（一起乘）
_et = time()
print(_et - _st)
 
_st = time()
for _ in range(nrun):           #a分别乘以前半个、后半个矩阵
    _rs = a.mm(w1) 
    _rs = a.mm(w2)
_et = time()
print(_et - _st)

:~/nlp/tnews$ python test_batch.py 
合并算时间：0.023270
分开算时间：0.060520

我们可以看到合并计算速度明显优于分开计算。