本文主要是介绍NLP入门——复杂函数建模与链式求导,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
复杂函数建模
前面我们研究的梯度下降法分类,是简单的对每类中每个子词的分数进行求和,统计分数最大的类别并不断调整分数来提高准确率。
我们可以修改函数模型,用更加复杂的函数代替sum(),来达到更好的学习效果。
def compute_instance(model, lin):rs = {}_max_score, _max_class = -inf, Nonefor _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 ∗ W 1 ∗ W 2 ∗ W 3 ∗ . . . ∗ W n L*W_1*W_2*W_3*...*W_n L∗W1∗W2∗W3∗...∗Wn
但由于乘法的结合律,上面的式子等价于
L ∗ W x , W x = W 1 ∗ W 2 ∗ W 3 ∗ . . . ∗ W n L*W_x,W_x=W_1*W_2*W_3*...*W_n L∗Wx,Wx=W1∗W2∗W3∗...∗Wn
我们原本的n个变化W_1~W_n变为一个权重矩阵W_x,仅相当于做了一次变换,我们为了提取多重复杂特征而乘不同的权重矩阵的目的并没有实现。
为了解决由乘法的结合律带来的影响,我们使用非线性函数做激活函数,上面的式子变为:
a c t ( . . . a c t ( a c t ( a c t ( L ∗ W 1 ) ∗ W 2 ) ∗ W 3 ) ∗ . . . ∗ W n ) act(...act(act(act(L*W_1)*W_2)*W_3)*...*W_n) act(...act(act(act(L∗W1)∗W2)∗W3)∗...∗Wn)
常见的激活函数有 R e L U ReLU ReLU激活函数。 R e L U ReLU ReLU 函数的特点是,当输入小或等于0,则返回0,当输入大于0时,则返回输入值,公式如下所示。
r e l u ( x ) = { 0 , x ≤ 0 x , x > 0 relu(x) = \begin{cases} 0, & \text{} x \leq 0 \\ x, & \text{} x \ >0 \end{cases} relu(x)={0,x,x≤0x >0
r e l u ( x ) = m a x ( x , 0 ) relu(x) = max(x,0) relu(x)=max(x,0),则此函数中阈值为0发生变化。但如果我们想让函数发生偏移,使其阈值发生变化,则我们需要设置偏移量b_i:
a c t ( . . . a c t ( a c t ( a c t ( L ∗ W 1 + b 1 ) ∗ W 2 + b 2 ) ∗ W 3 + b 3 ) ∗ . . . ∗ W n + b n ) act(...act(act(act(L*W_1+b_1)*W_2+b_2)*W_3+b_3)*...*W_n+b_n) act(...act(act(act(L∗W1+b1)∗W2+b2)∗W3+b3)∗...∗Wn+bn)
>>> 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,因此判定为第二类。
链式求导与反向传播
多元函数求导链式法则:
d f ( g ( x ) ) d x = d f ( g ( x ) ) g ( x ) ∗ d g ( x ) d x \frac{d f(g(x))}{dx} = \frac{df(g(x))}{g(x)}*\frac{dg(x)}{dx} dxdf(g(x))=g(x)df(g(x))∗dxdg(x)
则对于: a c t ( a c t ( a c t ( L ∗ W 1 + b 1 ) ∗ W 2 + b 2 ) ∗ W 3 + b 3 ) act(act(act(L*W_1+b_1)*W_2+b_2)*W_3+b_3) act(act(act(L∗W1+b1)∗W2+b2)∗W3+b3)
设 f ( g ( x ) ) = a c t ( L ∗ W 1 + b 1 ) f(g(x)) = act(L*W_1+b_1) f(g(x))=act(L∗W1+b1), h = g ( x ) = L ∗ W 1 + b 1 h=g(x)=L*W_1+b_1 h=g(x)=L∗W1+b1
有 d f ( h ) d x = d f ( h ) h ∗ d g ( x ) d x \frac{d f(h)}{dx} = \frac{df(h)}{h}*\frac{dg(x)}{dx} dxdf(h)=hdf(h)∗dxdg(x)
>>> 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 f(h)/h f(h)/h的导数值。
运算速度对比
我们对比Python单线程程序和pytorch运算向量数乘的时间差别:
#encoding: utf-8from random import uniform
import torch
from time import timevsize = 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.0for au, bu in zip(a,b):_s += au * bureturn _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-8from random import uniform
import torch
from time import timebsize = 1
vsize = 512
osize = 768
nrun = 1280a = 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
我们可以看到合并计算速度明显优于分开计算。
这篇关于NLP入门——复杂函数建模与链式求导的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!