NLP入门——前馈词袋分类模型的搭建、训练与预测

模型的搭建

线性层

>>> import torch
>>> from torch import nn
>>> class DBG(nn.Module):
...     def forward(self,x):
...             print(x.size())
...             return x
... 
>>> tmod = nn.Sequential(nn.Linear(3,4),DBG(),nn.Linear(4,5),DBG())
>>> tmod(torch.randn(2,3))
torch.Size([2, 4])
torch.Size([2, 5])
tensor([[-0.0408,  0.3847,  0.0409, -0.6591, -0.0459],[-0.0791,  0.2998,  0.3464, -0.7436, -0.2738]],grad_fn=<AddmmBackward0>)

通过以上代码,输入一个2x3的矩阵,在第一个线性层会变化为一个2x4的矩阵,随后使用DBG类输出当前矩阵的形状。在第二次线性层的变换后,矩阵变成2x5。

设置丢弃率

>>> import torch
>>> from torch import nn
>>> h = torch.randn(5)
>>> td = nn.Dropout(0.2) 
>>> td(h)
tensor([-0.7068,  0.8269, -1.1000, -0.2249,  0.0000])
>>> h
tensor([-0.5654,  0.6615, -0.8800, -0.1799,  0.7755])

我们设置丢弃率为0.2,结果打印丢弃后的张量,发现张量的第五个值被舍弃为0,但其他的值均发生了变化。
原因是丢弃值置0后向量的模长会发生很大变化,在我们线性层输入计算特征值时,模长的变化会造成结果的变化,在测试时我们是用原始不丢弃值的张量测试的,为了平衡丢弃前后张量的模长相近,Dropout函数对丢弃后的张量的其余值做了缩放。

>>> h/0.8
tensor([-0.7068,  0.8269, -1.1000, -0.2249,  0.9693])
>>> td(h)
tensor([-0.7068,  0.8269, -1.1000, -0.2249,  0.0000])

我们丢弃率是0.2,Dropout函数就用其余值/0.8后保留。因此Dropout函数做了两件事:1.按照给定概率p丢掉值。2.用剩下其余值/(1-p),从而保持前后模长一致。

>>> td.eval()
Dropout(p=0.2, inplace=False)
>>> td.training #eval()函数使此值为False,不丢弃
False
>>> td(h)
tensor([-0.5654,  0.6615, -0.8800, -0.1799,  0.7755])
>>> td.train()
Dropout(p=0.2, inplace=False)
>>> td.training #train()函数使此值为True,丢弃
True
>>> td(h)
tensor([-0.7068,  0.0000, -1.1000, -0.2249,  0.0000])

以上是Dropout函数的两种模式。

归一化层

在神经网络训练中,可能产生张量的某些参数值过大或过小,这样的极端值不利于产生合适的预测值。在优化过程中,如果我们设置学习率很小,则很小的参数值就变化很慢;如果学习率过大,则大的参数值变化过慢。
因此我们需要用nn.LayerNorm来进行归一化处理:
在这里插入图片描述
归一化的公式如上,E(x)是向量的均值。 x − E [ x ] x-E[x] xE[x]的作用是将向量移到0的附近:

>>> a = torch.randn(5)*100
>>> a
tensor([ -61.7625,   16.2004, -117.4248,   84.3843,  -54.4913])
>>> m = a.mean(-1,keepdim=True)
>>> m
tensor([-26.6188])
>>> a-m
tensor([-35.1437,  42.8192, -90.8060, 111.0031, -27.8725])
>>> (a-m).mean(-1)
tensor(0.)

分母上 V a r [ x ] Var[x] Var[x]是标准差,有可能为0,因此加一个很小的数来避免除以0异常。

>>> s=a.std(-1,keepdim=True)#标准差
>>> s
tensor([78.1231])
>>> h=(a-m)/(s+1e-5)
>>> h
tensor([-0.4499,  0.5481, -1.1623,  1.4209, -0.3568])

模型代码

#NNModel.py
#encoding: utf-8from torch import nnclass BoWLayer(nn.Module):def __init__(self, isize, hsize, dropout,norm_residual=True,**kwargs):super(BoWLayer, self,).__init__()   ##调用父类的初始化函数self.net = nn.Sequential(nn.Linear(isize, hsize),nn.ReLU(inplace=True), #设置relu激活函数,inplace=True在原始张量上进行nn.Dropout(p=dropout, inplace=False),#设置丢弃率防止过拟合,同时创建一个新的张量nn.Linear(hsize, isize, bias=False), nn.Dropout(p=dropout, inplace=True))self.normer = nn.LayerNorm(isize) #做归一化self.norm_residual = norm_residual #设置变量存储做判断def forward(self, input):_ = self.normer(input) #稳定之后的结果 return (_ if self.norm_residual else input) + self.net(_)#如果参数初始化做的好,就用LayerNorm后的值,否则用原始值class NNBoW(nn.Module):def __init__(self, vcb_size, nclass, isize, hsize, dropout,nlayer, **kwargs):super(NNBoW, self).__init__()self.emb = nn.Embedding(vcb_size, isize,padding_idx=0)                          #<pad>的索引为0self.drop = nn.Dropout(p=dropout, inplace=True) #embedding后dropoutself.nets = nn.Sequential(*[BoWLayer(isize, hsize, dropout)for _ in range(nlayer)])self.classifier = nn.Linear(isize, nclass)self.normer = nn.LayerNorm(isize)self.out_normer = nn.LayerNorm(isize)# input: (bsize, seql) 句数、句长def forward(self, input):mask = input.eq(0) #找到<pad>的位置# mask: (bsize, seql)out = self.emb(input)# out: (bsize, seql, isize)out = out.masked_fill(mask.unsqueeze(-1), 0.0) #将out中<pad>的位置置为0out = self.drop(out)out = out.sum(1) #对序列求和,在第一维度求和 #求和后out: (bsize, seql, isize) -> out: (bsize, isize)out = self.normer(out) #使用归一化,使模长均匀out = self.nets(out) #特征提取out = self.out_normer(out) #特征提取后,分类前再做一次归一化out = self.classifier(out) #分类产生参数#out: (bsize, isize) -> out: (bsize, nclass)return out

模型的训练

从h5文件中取值

我们上节存储h5文件时,特别存储了nword的Dataset,来保存总词数以及总类别数:

:~/nlp/tnews$ h5ls -d train.h5/nword
nword                    Dataset {2}Data:15379, 15

如果我们直接写是无法得到其中的具体值的

>>> from h5py import File as h5File
>>> t_data = h5File("train.h5","r")
>>> t_data["nword"]
<HDF5 dataset "nword": shape (2,), type "<i4">

我们如果从中取值,要这样写t_data["nword"][()],传一个空的tuple,表示取所有值。

>>> t_data["nword"][()]
array([15379,    15], dtype=int32)
>>> type(t_data["nword"][()])
<class 'numpy.ndarray'>

我们可以看到,取出的类型为numpy的ndarray,我们需要使用tolist()转成list后取出。

>>> vsize,nclass=t_data["nword"][()].tolist()
>>> vsize,nclass
(15379, 15)

损失函数优化

使用torch.nn.CrossEntropyLoss:
CLASStorch.nn.CrossEntropyLoss(weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean', label_smoothing=0.0)
在这里插入图片描述

>>> import torch
>>> a=torch.randn(4)
>>> a
tensor([0.7171, 0.0033, 1.3289, 1.5256])
>>> a.softmax(-1)
tensor([0.1793, 0.0878, 0.3305, 0.4024])
>>> p=a.softmax(-1)
>>> p.sum()
tensor(1.0000)
>>> _ = a.exp()
>>> _
tensor([2.0485, 1.0033, 3.7768, 4.5980])
>>> _/_.sum(-1,keepdim=True)
tensor([0.1793, 0.0878, 0.3305, 0.4024])

softmax函数是将输入的分数先求指数后再除以求指数后的和。经过softmax函数之后,再对结果值求负对数。由于经过softmax函数后张量中的值均是0到1的分数,则分数越接近于1,求负对数后值越接近于0。

>>> p
tensor([0.1793, 0.0878, 0.3305, 0.4024])
>>> -p.log()
tensor([1.7188, 2.4327, 1.1071, 0.9103])

在以上代码中,p[-1]值最大,则取负对数后值就越小。

label_smoothing参数的设置

若我们有四个类别{0, 1, 2, 3},softmax函数处理后得到的[P1, P2, P3, P4]. 若正确的类别是2。则交叉熵损失函数得到的分数为: − l o g ( P 2 ) -log(P_2) log(P2).
我们设置 label_smoothing=0.1,则会分配权重:
W 2 = 1 − 0.1 = 0.9 W_2 = 1 - 0.1 = 0.9 W2=10.1=0.9,
W 0 = W 1 = W 3 = 0.1 / 3 = 1 30 W_0 = W_1 = W_3=0.1/3 = \frac{1}{30} W0=W1=W3=0.1/3=301
则 label_smoothing = 0.1得到的分数为:
l s l o s s = 1 30 ∗ s u m ( − l o g ( P 0 P 1 P 3 ) + 0.9 ∗ ( − l o g ( P 2 ) ) ) ls loss = \frac{1}{30} * sum(-log(P_0P_1P_3)+0.9*(-log(P_2))) lsloss=301sum(log(P0P1P3)+0.9(log(P2)))
如果我们只使用CrossEntropyLoss,我们可能会使模型向一个极端方向走,容易忽略其他参数的影响。而设置label_smoothing,它会分配权重来承认正确类别足够重要,但也不能忽视其他类别。

学习率调度

class StepLR(LRScheduler):

def __init__(self, optimizer, step_size, gamma=0.1, last_epoch=-1, verbose="deprecated"):self.step_size = step_sizeself.gamma = gammasuper().__init__(optimizer, last_epoch, verbose)def get_lr(self):if not self._get_lr_called_within_step:warnings.warn("To get the last learning rate computed by the scheduler, ""please use `get_last_lr()`.", UserWarning)if (self.last_epoch == 0) or (self.last_epoch % self.step_size != 0):return [group['lr'] for group in self.optimizer.param_groups]return [group['lr'] * self.gammafor group in self.optimizer.param_groups]

我们需要写两个函数分别用来初始化和更新当前学习率。我们用初始学习率除以步数开根号来做学习率的下降:

#lrsch.py
#encoding: utf-8from torch.optim.lr_scheduler import _LRScheduler
from math import sqrtclass SqrtDecayLR(_LRScheduler):#base_lr / sqrt(step)def __init__(self, optimizer, base_lr, min_lr=1e-8, step=1,last_epoch=-1, **kwargs):self.base_lr, self.min_lr, self._step = base_lr, min_lr, step#设置最小的学习率super().__init__(optimizer, last_epoch)def get_lr(self):_lr = max(self.base_lr / sqrt(self._step), self.min_lr)self._step += 1#每次计算学习率return [_lr for _ in range(len(self.base_lrs))]

训练模型

#train.py
#encoding: utf-8import torch
from torch import nn
from NNModel import NNBoW #导入模型
from h5py import File as h5File #读训练数据
from math import sqrt
from random import shuffle #使输入数据乱序,使模型更均衡
from lrsch import SqrtDecayLRtrain_data = "train.h5"
dev_data = "dev.h5"     #之前已经张量转文本的h5文件
isize = 64              
hsize = isize * 2       #设置初始参数
dropout = 0.3           #设置丢弃率
nlayer = 4              #设置层数
gpu_id = -1             #设置是否使用gpu
lr = 1e-3               #设置初始学习率
max_run = 512           #设置训练轮数
early_stop = 16         #设置早停轮数def init_model_parameters(modin): #初始化模型参数with torch.no_grad():         #不是训练不用求导for para in modin.parameters():if para.dim() > 1:          #若维度大于1,说明是权重参数_ = 1.0 / sqrt(para.size(-1))para.uniform_(-_,_)     #均匀分布初始化for _m in modin.modules():      #遍历所有小模型if isinstance(_m, nn.Linear):#如果小模型是linear类型if _m.bias is not None: #初始化bias_m.bias.zero_()elif isinstance(_m, nn.LayerNorm):#初始化LayerNorm参数_m.weight.fill_(1.0)_m.bias.zero_()return modindef train(train_data, tl, model, lossf, optm, cuda_device):model.train() #设置模型在训练的模式src_grp, tgt_grp = train_data["src"], train_data["tgt"] #从输入数据中取出句子和标签_l = 0.0  #_l用来存当前loss_t = 0    #_t用来存句子数for _id in tl:seq_batch = torch.from_numpy(src_grp[_id][()])seq_o = torch.from_numpy(tgt_grp[_id][()])      #取出句子和标签转化成torch类型if cuda_device is not None:seq_batch = seq_batch.to(cuda_device, non_blocking=True)seq_o = seq_o.to(cuda_device, non_blocking=True) #将数据放在同一gpu上seq_batch, seq_o = seq_batch.long(), seq_o.long()    #数据转换为long类型out = model(seq_batch)          #获得模型结果loss = lossf(out, seq_o)        #获得损失函数_l += loss.item()               #获得浮点数_t += seq_batch.size(0)         #累加获得当前句数loss.backward()                 #反向传播求导optm.step()                     #参数的更新optm.zero_grad(set_to_none=True)#清空梯度return _l / _t #返回当前lossdef eva(vd, nd, model, lossf, cuda_device):model.eval()    #设置模型在验证方式src_grp, tgt_grp = vd["src"], vd["tgt"]_loss = 0.0_t = _err = 0 #_err记录错误的句数with torch.no_grad():  #禁用求导,节省计算开销for i in range(nd):_ = str(i)  #获取字符串形式的keyseq_batch = torch.from_numpy(src_grp[_][()])seq_o = torch.from_numpy(tgt_grp[_][()])    #取句子和标签if cuda_device is not None:seq_batch = seq_batch.to(cuda_device, non_blocking=True)seq_o = seq_o.to(cuda_device, non_blocking=True)    #放在同一设备上seq_batch, seq_o = seq_batch.long(), seq_o.long()       #数据类型转换out = model(seq_batch)loss = lossf(out, seq_o)_loss += loss.item()    #loss累加_t += seq_batch.size(0) #记录数据总量_err += out.argmax(-1).ne(seq_o).int().sum().item() #argmax获取最大值的位置,当做预测的类别位置#ne()判断和正确类别是否不等,不等为T相等为F,转成0和1后累加得到的值就是错的总数model.train()   #模型恢复为训练方式return _loss / _t, float(_err) / _t *100.0 #返回平均的loss和错误率def save_model(modin, fname): #保存模型所有内容 权重、偏移、优化torch.save({name: para.cpu() for name, para inmodel.named_parameters()}, fname)t_data = h5File(train_data, "r")
d_data = h5File(dev_data, "r") #以读的方式打开训练以及验证数据vcb_size, nclass = t_data["nword"][()].tolist() #将返回的numpy的ndarray转为list
#在我们的h5文件中存储了nword:(总词数,总类别数)model = NNBoW(vcb_size, nclass, isize, hsize, dropout, nlayer)
model = init_model_parameters(model) #在cpu上初始化模型
lossf = nn.CrossEntropyLoss(reduction='sum', label_smoothing=0.1)
#设置损失函数优化,由于句长不一致,我们使用sum而非mean方式if (gpu_id >= 0) and torch.cuda.is_available(): #如果使用gpu且设备支持cudacuda_device = torch.device("cuda", gpu_id)  #配置gputorch.set_default_device(cuda_device)
else:cuda_device = Noneif cuda_device is not None:                     #如果要用gpumodel.to(cuda_device)                       #将模型和损失函数放在gpu上lossf.to(cuda_device)optm = torch.optim.Adam(model.parameters(), lr=lr, 
betas=(0.9, 0.98), eps=1e-08)
#使用model.parameters()返回模型所有参数,
lrm = SqrtDecayLR(optm, lr) #将优化器和初始学习率传入tl = [str(_) for _ in range(t_data["ndata"][()].item())] #获得字符串构成的训练数据的list
nvalid = d_data["ndata"][()].item()min_loss, min_err = eva(d_data, nvalid, model, lossf,
cuda_device)
print("Init dev_loss %.2f, error %.2f" % (min_loss, min_err,))#打印一下初始状态namin = 0
for i in range(1, max_run + 1):shuffle(tl)         #使数据乱序_tloss = train(t_data, tl, model, lossf, optm,cuda_device)  #获取每轮训练的损失_dloss, _derr = eva(d_data, nvalid, model, lossf, cuda_device)  #获取每轮验证的损失和错误率print("Epoch %d: train loss %.2f, dev loss %.2f, error %.2f"%(i, _tloss, _dloss, _derr)) #打印日志_save_model = False    #模型的保存,保存在验证集上表现最好的模型if _dloss < min_loss:_save_model = Truemin_loss = _dlossif _derr < min_err:_save_model = Truemin_err = _derr    #保存在loss和err指标上最好的模型if _save_model:        #如果需要保存模型save_model(model, "eva.pt")namin = 0else:namin += 1if namin >= early_stop: #早停逻辑breaklrm.step() #每轮训练后更新学习率t_data.close()
d_data.close() #最后关闭这两个文件

在命令行输入python train.py运行文件,我们可以看到:
在这里插入图片描述
训练进行了22轮出现早停,在训练集上验证的错误率在48%左右。

模型的解码

解码首先我们需要对验证集做排序:

#sorti.py
#encoding: utf-8
import sysdef handle(srcf, srts, max_len=1048576):# {length: {(src, label)}}  外层dict,中层set,内层tupledata = {}with open(srcf, "rb") as fsrc:for ls in fsrc:ls = ls.strip()if ls:ls = ls.decode("utf-8")_ = len(ls.split()) #获取句子的分词个数if _ <= max_len:if _ in data:   #若已有这个长度在data中if ls not in data[_]: #去重,重复的跳过data[_].add(ls)   #不重复的添加else:data[_] = set([ls])   #转化成set去重ens = "\n".encode("utf-8")with open(srts, "wb") as fsrc: #写入for _l in sorted(data.keys()):  #按照句子长度从小到大排lset = data[_l] #取出句长对应的setfsrc.write("\n".join(lset).encode("utf-8")) #在每个句子间插入换行符fsrc.write(ens) #每个句子后插入换行if __name__ == "__main__":handle(*sys.argv[1:3])

在命令行执行:

:~/nlp/tnews$ python sorti.py src.dev.bpe.txt src.dev.bpe.txt.srt

查看排序后的.srt文件:
在这里插入图片描述
可以看到已经按照句子长度(即分词个数)升序排序并存储。

存储为h5文件

#mktesth5.py
#encoding: utf-8
import sys
from h5py import File as h5File
import numpy
from vcb import load_vcb
#导入加载词典的函数def batch_loader(fsrc, max_tokens = 2048, **kwargs):#返回一批一batch的数据,设置每个batch最多存放2048个子词ri = []mlen = n = 0    #n记录当前收集了多少条句子,mlen记录当前收集的句子长度with open(fsrc, "rb") as fs:for ls in fs:ls = ls.strip() if ls:ls =ls.decode("utf-8").split()_l = len(ls)            #当前行中的分词个数_mlen = max(_l, mlen)   #当前行或当前batch中句子的长度_n = n + 1if (_n * _mlen) > max_tokens: #如果把添加了这句话的 句数*分词数量 大于最大值则不能放if ri:       #如果ri,rt不为空yield ri, mlen  #返回ri,rt和原来的句子长度ri, mlen, n = [ls], _l, 1 #返回后重新初始化,将本句加入新的batchelse: #如果不超过当前长度,则将此句添加到batch中ri.append(ls)mlen, n = _mlen, _n #更新句子长度与句子数量if ri: #最后若仍然有数据,则返回为一个新的batchyield ri, mlendef batch_mapper(fsrc, vcbs, **kwargs): #将分词变索引for ri, mlen in batch_loader(fsrc, **kwargs):yield [[vcbs[_word] for _word in _s if _word  in vcbs]for _s in ri], mlen#遍历每个batch中的句子,返回每个batch中每个分词的个数、标签、batch长度def pad_batch(lin, mlen, pad_id = 0):#补<pad>的函数rs = []for lu in lin: #每个batch中的每句_d = mlen - len(lu) #当前此句需要补<pad>的个数if _d > 0:lu.extend([pad_id for _ in range(_d)])#extend函数用来拼接两个列表。补_d个<pad>的索引0rs.append(lu)return rs #返回的是均已对齐的每个batchdef batch_padder(fsrc, vcbs, **kwargs):for ri, mlen in batch_mapper(fsrc, vcbs, **kwargs):yield pad_batch(ri, mlen) #返回的是每个已补齐的batch,以及batch中的标签def handle(fsrc, fvcbs, frs, **kwargs):vcbs = load_vcb(fvcbs, vanilla = False)with h5File(frs, "w", libver = 'latest', track_order = False) as h5f:#libver使用最新的,track_order表示无需记录顺序src_grp = h5f.create_group("src", track_order=False)    #创建两个组,分别放句子和标签 for i, ri in enumerate(batch_padder(fsrc, vcbs, **kwargs)):ri = numpy.array(ri, dtype = numpy.int32) #转化成numpy数组并设置数据类型,target的数据很小,所以我们只需要int16存储src_grp.create_dataset(str(i), data=ri, compression="gzip",compression_opts=9, shuffle=True ) #设置压缩存储节省空间,压缩等级设置为最大压缩代价9h5f["nword"] = numpy.array([len(vcbs)], dtype=numpy.int32) #存储总词数、总标签数h5f["ndata"] = numpy.array([i + 1], dtype=numpy.int32) #存储总batch数if __name__ == "__main__":handle(*sys.argv[1:4])

在命令行执行:

:~/nlp/tnews$ python mktesth5.py src.dev.bpe.txt.srt src.vcb test.h5

查看存储后的h5文件,可以看到验证集的总词数为15379,总batch数为78:

:~/nlp/tnews$ h5ls test.h5 
ndata                    Dataset {1}
nword                    Dataset {1}
src                      Group
:~/nlp/tnews$ h5ls -d test.h5/ndata
ndata                    Dataset {1}Data:78
:~/nlp/tnews$ h5ls -d test.h5/nword
nword                    Dataset {1}Data:15379

模型的预测

#predict1.py
#encoding: utf-8import sys
import torch
from NNModel import NNBoW               #读模型
from h5py import File as h5File         #读文件
from vcb import load_vcb, reverse_vcb   #获取词表isize = 64
hsize = isize * 2
dropout = 0.3
nlayer = 4
gpu_id = -1         #模型的初始化参数test_data = sys.argv[1]
test_file = h5File(test_data, "r")            #读验证集
vcb_size = test_file["nword"][()].tolist()[0] #获取总词数tgt_vcb = reverse_vcb(load_vcb(sys.argv[2], vanilla=True))
nclass = len(tgt_vcb)                         #获取总类别数model = NNBoW(vcb_size, nclass, isize, hsize, dropout, nlayer)
model_file = sys.argv[-1]       #获取模型
with torch.no_grad():           #避免求导_ = torch.load(model_file)  #加载词典for name, para in model.named_parameters():if name in _:para.copy_(_[name]) #从词典里取出name的参数if (gpu_id >= 0) and torch.cuda.is_available():cuda_device = torch.device("cuda", gpu_id)torch.set_default_device(cuda_device)
else:cuda_device = Noneif cuda_device is not None:model.to(cuda_device)       #判断是否使用cudasrc_grp = test_file["src"]
ens = "\n".encode("utf-8")
with torch.no_grad(), open(sys.argv[3],"wb") as f: #解码避免求导,将预测标签按行写入文件for _ in range(test_file["ndata"][()].item()):#每个batch上遍历seq_batch = torch.from_numpy(src_grp[str(_)][()])if cuda_device is not None:seq_batch = seq_batch.to(cuda_device, non_blocking=True)seq_batch = seq_batch.long()    #s数据类型转换out = model(seq_batch).argmax(-1).tolist() #将每个batch的预测下标转列表out = "\n".join([tgt_vcb[_i] for _i in out])       #将预测下标转为对应的类别,类别间按行隔开f.write(out.encode("utf-8"))f.write(ens)                #每个batch间还应有换行test_file.close()

我们将预测类别存入out.txt,eva.pt是模型文件。在命令行输入:

:~/nlp/tnews$ python predict1.py test.h5 tgt.vcb out.txt eva.pt 
:~/nlp/tnews$ less out.txt

在这里插入图片描述
请注意此时,我们存储预测的类别是对验证集排序后每句预测的类别,我们要对比原验证集的标签,需要将顺序恢复:

#restore.py
#encoding: utf-8
#python restore.py srti.txt srtp.txt srci.txt rs.txtimport sysdef load(srcf, tgtf):rs = {}with open(srcf, "rb") as fsrc,open(tgtf, "rb") as ftgt:for ls, lt in zip(fsrc, ftgt):ls, lt = ls.strip(), lt.strip()if ls and lt:ls, lt =ls.decode("utf-8"), lt.decode("utf-8")rs[ls] = lt #将每句话及其对应的预测类别存入字典rsreturn rsdef lookup(srcf, rsf, mapd):ens = "\n".encode("utf-8")with open(srcf, "rb") as frd,open(rsf, "wb") as fwrt:for line in frd:line = line.strip()if line:line = line.decode("utf-8")fwrt.write(mapd[line].encode("utf-8"))#按照排序前文件的顺序将预测的类别写入新文件fwrt.write(ens)     if __name__ == "__main__":lookup(*sys.argv[3:5], load(*sys.argv[1:3]))#将load处理后的字典传入lookup中

在命令行执行:

:~/nlp/tnews$ python restore.py src.dev.bpe.txt.srt out.txt src.dev.bpe.txt pred.dev.txt
:~/nlp/tnews$ less pred.dev.txt 

在这里插入图片描述

计算准确率

利用我们前面写的脚本来预测准确率,在命令行执行:

:~/nlp/tnews$ python acc.py pred.dev.txt tgt.dev.s.txt 
51.59
:~/nlp/tnews$ python acc.py pred/pred.learnw.dev.txt tgt.dev.s.txt 
46.92

相较于前面的将函数做非线性变换前的模型,我们前馈词袋分类模型预测准确率上升了5个百分点。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/pingmian/41083.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

C语言实战 | Flappy Bird游戏

Flappy Bird游戏是由一名越南游戏制作者独自开发的&#xff0c;曾经风靡全球。游戏规则非常简单&#xff0c;玩家必须控制一只小鸟&#xff0c;跨越由各种长度的水管所组成的障碍物&#xff0c;如果撞上管道游戏就结束&#xff0c;如图11.11所示。 ■ 图11.11Flappy Bird 游戏 …

使用AES加密数据传输的iOS客户端实现方案

在现代应用开发中&#xff0c;确保数据传输的安全性是至关重要的。本文将介绍如何在iOS客户端中使用AES加密数据传输&#xff0c;并与服务器端保持加密解密的一致性。本文不会包含服务器端代码&#xff0c;但会解释其实现原理。 加密与解密的基本原理 AES&#xff08;Advance…

Mysql8.0.36 Centos8环境安装

下载安装包 官网地址&#xff1a;MySQL :: Download MySQL Community Server (Archived Versions) 可以直接下载后再传到服务器&#xff0c;也可以在服务器采用wget下载。如下&#xff1a; wget https://downloads.mysql.com/archives/get/p/23/file/mysql-8.0.36-linux-glib…

【单片机毕业设计选题24047】-基于阿里云的工地环境监测系统

系统功能: 基于STM32完成 主机&#xff08;阿里云以及oled屏显示位置一&#xff09;&#xff1a;烟雾检测&#xff0c;温湿度检测&#xff0c;噪声检测&#xff0c;且用OLED屏显示&#xff0c;设置阈值&#xff0c;超过报警&#xff08;蜂鸣器&#xff09;。 从机&#xff0…

(四)共享模型之内存

本章内容 上一章讲解的 Monitor 主要关注的是访问共享变量时&#xff0c;保证临界区代码的原子性 这一章我们进一步深入学习共享变量在多线程间的【可见性】问题与多条指令执行时的【有序性】问题 Java 内存模型 JMM 即 Java Memory Model&#xff0c;它定义了主存、工作内存…

firewalld(3)zone配置

简介 前面文章我们已经介绍了firewalld的安装&#xff0c;配置文件介绍、简单的规则查询&#xff0c;本篇文章主要介绍zone的配置。前面我们介绍了firewalld默认的zone和不同zone的功能&#xff0c;下面我们就直接进入zone的具体配置使用。 配置zone的方式 图形配置工具…

浅析基于量子成像的下一代甚高灵敏度图像传感器技术

高灵敏度探测成像是空间遥感应用中的一个重要技术领域&#xff0c;如全天时对地观测、空间暗弱目标跟踪识别等应用&#xff0c;对于甚高灵敏度图像传感器的需求日益强烈。随着固态图像传感器技术水平的不断提高&#xff0c;尤其背照式及埋沟道等工艺的突破&#xff0c;使得固态…

马拉松报名小程序的设计

管理员账户功能包括&#xff1a;系统首页&#xff0c;个人中心&#xff0c;用户管理&#xff0c;赛事信息管理&#xff0c;赛事报名管理&#xff0c;活动商城管理&#xff0c;留言板管理&#xff0c;系统管理 微信端账号功能包括&#xff1a;系统首页&#xff0c;赛事信息&…

手动访问mongo和ES插入和查询

1、手动访问mongo 1.1、mongo连接数据库 1.2、mongo插入和查询 db.hmf_test.insert( { "aoeId": "1", "aoeAes": "吴秀梅", "aoeSm4": "北京xx网络技术有限公司.", "aoeSm4_a": "…

2pc 3pc

2pc&3pc问题 本质&#xff1a; 2pcTM超时机制 3pc加入事务询问机制RM超时机制 事务询问机制&#xff1a;减少阻塞 RM超时机制&#xff1a;避免死锁 2pc 3pc 参考&#xff1a; https://juejin.im/post/5aa3c7736fb9a028bb189bca#heading-1 https://blog.csdn.net/xj1…

Spring Boot 文件上传和下载指南:从基础到进阶

文章目录 引言1. 环境配置2. 文件上传2.1 配置文件上传路径2.2 创建上传服务2.3 创建上传控制器 3. 文件下载3.1 创建下载服务3.2 创建下载控制器 4. 前端页面4.1 文件上传页面4.2 文件下载页面 5. 技术分析结论 &#x1f389;欢迎来到SpringBoot框架学习专栏~ ☆* o(≧▽≦)o …

iOS多target时怎么对InfoPlist进行国际化

由于不同target要显示不同的App名称、不同的权限提示语&#xff0c;国际化InfoPlist文件必须创建名称为InfoPlist.strings的文件&#xff0c;那么多个target时怎么进行国际化呢&#xff1f;步骤如下&#xff1a; 一、首先我们在项目根目录创建不同的文件夹对应多个不同的targe…

1-2 什么是自然语言处理

1-2 什么是自然语言处理 主目录点这里 自然语言处理是计算机学科、人工智能与语言学领域的一个交叉学科&#xff0c;主要研究如何让计算机能够理解、处理、生成和模拟人类语言的能力&#xff0c;从而实现与人类进行自然语言对话的能力。 如上图&#xff0c;你好通过自然语言处…

笔记:SpringBoot+Vue全栈开发

笔记&#xff1a;SpringBootVue全栈开发 1. 开发环境热部署2. SpringBoot RestController的使用3. SpringBoot实现文件上传4. 配置拦截器5. Restful服务Swagger6. 使用MyBatis-Plus进行数据库操作7. 多表查询、条件查询及分页查询 1. 开发环境热部署 使用spring-boot-devtools…

opencv第一课-cnblog

opencv第一课 创建窗口 import timeimport cv2 #创建窗口 cv2.namedWindow(window,cv2.WINDOW_NORMAL)#cv2.WINDOW_AUTOSIZE自动大小&#xff0c;不允许修改窗口大小#更改窗口的大小 cv2.resizeWindow(window,800,600)#展示名字为window的窗口 cv2.imshow(window,0)key cv2.w…

vue中如何使用echarts和echarts-gl实现三维折线图和三维柱状图

一、vue中使用三维折线图 效果图&#xff1a; 二、使用步骤 1.引入库 安装echarts 在package.json文件中添加 "dependencies": {"echarts": "^5.1.2""echarts-gl": "^1.1.1",// "echarts-gl": "^2.0.8…

『古籍自有答案』古风H5案例赏析

「古籍自有答案」&#xff0c;一部由新京报与字节跳动公益联合打造的古风H5&#xff0c;以诗意盎然的开篇引领用户穿梭于千年文脉。 part1. 创意定位 "人生有惑问先贤&#xff0c;先贤答案存古籍"&#xff0c;在这里&#xff0c;每一个灵魂的探问&#xff0c;都能在…

拥抱 AGI:PieDataCS 引领云原生数据计算系统新范式

自2023年后&#xff0c;人工智能技术进入了一个更为成熟和广泛应用的阶段&#xff0c;人工通用智能&#xff08;AGI&#xff09;这一概念也成为了科技界和产业界热议的焦点。本文将结合 AGI 时代背景&#xff0c;从架构设计到落地实践&#xff0c;详细介绍拓数派云原生数据计算…

中职院校专业群的生成机制研究

摘要&#xff1a; 随着国内产业升级转型步伐的加快和职业教育质量提升的要求&#xff0c;中等职业院校&#xff08;中职院校&#xff09;的专业群建设成为促进教育与产业深度融合、实现内涵式发展的关键。本文采用案例分析法&#xff0c;探讨中职院校专业群生成机制&#xff0c…

Linux手动安装JDK1.8

1、下载要安装的jdk安装包文件 官网下载地址&#xff1a;https://www.oracle.com/cn/java/technologies/downloads/ 2、上传jdk安装包至要安装服务器 3、在要安装jdk位置使用命令解压安装包 安装路径: /usr/local/java 解压安装包&#xff0c;解压命令 tar -zxvf /install…