基于简单的BP神经网络实现中文分词_神经网络分词模型

1.BP神经网络

BP神经网络可以分为两个部分，BP和神经网络，BP是 Back Propagation 的简写 ，意思是反向传播。而神经网络，可以说是一类相对复杂的计算网络。 正向传播就是让信息从输入层进入网络，依次经过每一层的计算，得到最终输出层结果的过程。反向传播的信息是误差，也就是输出层的结果与输入信息x对应的真实结果之间的差距。 通过一次正向传播，和一次反向传播，我们就可以将网络的参数更新一次，所谓训练网络，就是让正向传播和反向传播不断的往复进行，不断地更新网络的参数，最终使网络能够逼近真实的关系。
理论上，只要网络的层数足够深，节点数足够多，可以逼近任何一个函数关系。但是这比较考验你的电脑性能，事实上，利用 BP 网络，能够处理的数据其实还是有限的，但是这并不影响 Bp 网络是一种高明的策略。
结合实现中文分词的模型解释：
（1）随机设下一个起始点，并固定下来，确保每一次运行时都有同一个起始点。
（2）加载模型需要的参数。
加载字表。字表的生成：对训练文本去重复，按照字频从高到低排序，并编号。
加载训练数据：未进行分词的句子。
加载标签：通过SBME来标识已进行过分词的训练数据。
加载学习率；轮次；一个字用多少维度的向量来表示；（原模型只有一个隐藏层，此处增加一层）第一个隐藏层的输出大小；第二个隐藏层的输出大小。
（3）加载模型
（4）模型预测
（5）评价预测准确率

2.模型具体参数以及主要部分代码实现

（1）模型具体参数
学习率——0.000015
轮次——5->8->10（效果不再有显著提升）
输出维度——4 （对每一个字预测SBME中的一个标签）
每一个字的向量维度——16
第一层输出维度——32
第一层输出维度——64
（2）模型实现部分
1.一个输入层:输入维度——字表大小，输出维度——字的向量维度16；
两个隐藏层：
2.第一层隐藏层：输入维度——字的向量维度16，输出维度——32；
3.第二层隐藏层：输入维度——32，输出维度——64；
4.做非线性变换，维度不变；
5.一个输出层：输入维度——64，输出维度——4；
6.使用softmax（）函数，将输出数据归一化，概率最大的数的下标即为预测值。

3.模型评价结果

（1）Accuracy，中文为准确率，指的是“预测正确的样本数÷样本数总数”。计算公式为：

（2）Precision，中文为精确率或者精度，指的是在我们预测为True的样本里面，有多少确实为True的。在信息检索领域，precision也被称为“查准率”。其公式为：

（3）Recall，中文是召回率，指的是，实际上为True的样本有多少被我们挑出来了。在信息检索领域，recall也被称为“查全率”。其公式为：

（4）Accuracy和Recall的调和指标：F1 Score

4.正式开始

先放上代码的框架：

1.训练样本 train.txt（文章末有链接）

可以看到是已经分好词的文本，一共有5000行。接下来我们就利用这个训练样本来训练我们的分词模型，目标是提取中文分词的规律，就像我们找一个数列的规律，不过这一次我们借助计算机的脑子。

2.训练样本的预处理

#WordsegBP/utils/ready_job.py
#generate train_data
#generate target_data
#generate vocal_table

import pickle as pkl
import time

def build_train_data(file_path):   #file_path = '../data/train.txt'
    with open(file_path,'r',encoding='utf-8') as f:
        lines = f.readlines()
    phrase_expel = []
    for i in lines:   #把读到的文件中的 引号 回车 和 空格 删掉
        t1 = i.replace('“  ','')
        t2 = t1.replace('\n','')
        t3 = t2.replace('  ','')
        phrase_expel.append(t3)

    with open('../data/generate_pkl/train_data.pkl', 'wb') as f: #把这个处理后的文件当作训练数据
        pkl.dump(phrase_expel, f)   #把文件写成pkl格式


def build_target(file_path):  #生成目标文件
    with open(file_path,'r',encoding='utf-8') as f:
        tmp = f.readlines()  #tmp为每一行的数据

    t = []
    for i in tmp: #删掉引号和回车，这里不删空格，空格是分词的标志
        t1 = i.replace('“  ','')
        t2 = t1.replace('\n','')
        t.append(t2)

    sum_list = []
    for i in t:
        sum_ = ''
        for j in i.split():  #以空格为分割，一个词一个词的提取
            if len(j) == 1: #如果词的长度为1 ，就标记为S -single
                sum_ += 'S'
                continue
            else:
                sum_ += 'B' #如果长度不为1，标记为一个词的开始 begin
                for k in range(1, len(j)):
                    if k == len(j) - 1: #如果是这个词的最后一个，就标记为end
                        sum_ += 'E'
                    else:
                        sum_ += 'M'  #其他情况就是middle
        sum_list.append(sum_)

    with open('../data/generate_pkl/target.pkl', 'wb') as f:
        pkl.dump(sum_list, f)

def build_vocab_dict(file_path):  #'../data/train_data.pkl'
    vocab_dic = {}
    with open(file_path, 'rb') as f:
        z = pkl.load(f)
        for line in z:
            for hang in line:  #统计词频，按照词多到少排列
                vocab_dic[hang] = vocab_dic.get(hang, 0) + 1
        vocab_dic_sorted = sorted(vocab_dic.items(), key=lambda x: x[1], reverse=True)

    vocab_dic2 = {word_count[0]: idx for idx, word_count in enumerate(vocab_dic_sorted)}
    with open('../data/generate_pkl/vocab.pkl', 'wb') as f:
        pkl.dump(vocab_dic2, f)


if __name__ == '__main__':
    build_train_data('../data/train.txt')
    time.sleep(5)
    build_target('../data/train.txt')
    build_vocab_dict('../data/generate_pkl/train_data.pkl')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

运行后得到如下三个pkl文件：

3.简单的BP神经网络构建，由于这里比较简洁，就没有单独在一个文件夹models里面放这个模型，而是直接写在main里面了。

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import pickle as pkl
from tqdm import tqdm

class Config(object):
    #parameters settings
    def __init__(self):
        self.vocab = pkl.load(open('../data/generate_pkl/vocab.pkl', 'rb'))  # 读取词表
        self.train_data = pkl.load(open('../data/generate_pkl/train_data.pkl', 'rb'))  # 读取训练数据
        self.target = pkl.load(open('../data/generate_pkl/target.pkl', 'rb'))  # 读取标签

        self.learning_rate = 0.000015  # 学习率
        self.epoch = 5  # epoch次数

        self.output_size = 4
        self.embed_dim = 16
        self.hout1 = 32
        self.hout2 = 64

class Model(nn.Module):
    def __init__(self, output_size, vocab_size, embed_dim,hout1,hout2):
        super(Model, self).__init__()
        #把每一个字都表示为embed_dim维的字向量
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        #隐藏层为全连接层
        self.hid_layer1 = nn.Linear(embed_dim, hout1)
        self.hid_layer2 = nn.Linear(hout1, hout2)
        self.out_layer = nn.Linear(hout2, output_size)

    #self指的是上面的初始化模型参数，in_layer指的是待分词的句子的张量表示
    def forward(self, in_layer):
        #将in_layer张量中的每一个元素（字的序号）都变成一个embed_dim维的张量
        emd = self.embedding(in_layer)
        #将每个字从一个embed_dim维变为hout1维的向量，神经元的出现（w，b）
        h_out1 = self.hid_layer1(emd)
        #将每个字从一个hout1维变为hout2维的向量，神经元的增加（w‘，b’）
        h_out2 = self.hid_layer2(h_out1)
        #非线性变换
        out_ = F.relu(h_out2)
        #将hout2维变为output_size维
        out_ = self.out_layer(out_)
        #每一个字都会得到到一个 为BMES的概率，最大的即为所预测的
        out_ = F.softmax(out_, dim=1)
        return out_

def model_eval(model_out, true_label):
    confusion_matrix = torch.zeros([2, 2], dtype=torch.long)
    predict_label = torch.argmax(model_out, 1)
    accuracy = []
    precision = []
    recall = []
    f_1 = []
    for l in range(4):
        tp_num, fp_num, fn_num, tn_num = 0, 0, 0, 0
        for p, t in zip(predict_label, true_label):
            if p == t and t == l:
                tp_num += 1
            if p == l and t != l:
                fp_num += 1
            if p != l and p != t:
                fn_num += 1
            if p != l and p == t:
                tn_num += 1
        accuracy.append((tp_num + tn_num) / (tp_num + tn_num + fp_num + fn_num))
        try:
            prec = tp_num / (tp_num + fp_num)
        except:
            prec = 0.0
        try:
            rec = tp_num / (tp_num + fn_num)
        except:
            rec = 0
        precision.append(prec)
        recall.append(rec)
        if prec == 0 and rec == 0:
            f_1.append(0)
        else:
            f_1.append((2 * prec * rec) / (prec + rec))
    ave_acc = torch.tensor(accuracy, dtype=torch.float).mean()
    ave_prec = torch.tensor(precision, dtype=torch.float).mean()
    ave_rec = torch.tensor(recall, dtype=torch.float).mean()
    ave_f1 = torch.tensor(f_1, dtype=torch.float).mean()
    return ave_acc, ave_prec, ave_rec, ave_f1

#建议注释掉这一个函数，因为test_  有可能会和内置函数重名了，改个名字也行~
def test_(model_):
    text = '这是一个最好的时代。'
    hang_ = []
    for wd in text:
        hang_.append(Config().vocab[wd])
    test_tensor = torch.tensor(hang_, dtype=torch.long)
    res = model_(test_tensor)
    res = res.detach().numpy()
    [print(np.argmax(r)) for r in res]
    print(res)

if __name__ == '__main__':
    #设置参数的起点
    torch.manual_seed(1)
    config = Config()
    voc_size = len(config.vocab)

    train_data_list = []
    for lin in config.train_data:
        hang = []
        for word in lin:
            hang.append(config.vocab[word])
        #将列表类型转变为张量类型
        train_data_list.append(torch.tensor(hang, dtype=torch.long))

    target_dict = {'B': 0,
                   'M': 1,
                   'E': 2,
                   'S': 3}

    target_list = []
    for lin in config.target:
        hang = []
        for tag in lin:
            hang.append(target_dict[tag])
        target_list.append(torch.tensor(hang, dtype=torch.long))
    #现在 train_data_list target_list 里面的元素都是张量，它们是由张量构成的列表

    model = Model(config.output_size, voc_size, config.embed_dim,config.hout1,config.hout2)
    #model __init__()函数已经生效了
    losses = []
    acc = []
    rec = []
    prec = []
    f1 = []
    optimizer = torch.optim.SGD(model.parameters(), lr=config.learning_rate)
    #model.parameters()这里的参数就是__init__()函数里面的
    loss_f = nn.CrossEntropyLoss()
    #实现进度条式输出
    for i in tqdm(range(config.epoch)):
        for j, k in enumerate(train_data_list):
            optimizer.zero_grad()
            #开始forward的作用，预测句子k的标签
            out = model(k)
            #计算交叉熵损失
            loss = loss_f(out, target_list[j])
            #误差反向传播
            loss.backward()
            #参数向前更新
            optimizer.step()
            #模型评价
            acc_, prec_, rec_, f1_ = model_eval(out, target_list[j])
            acc.append(acc_.item())
            prec.append(prec_.item())
            rec.append(rec_.item())
            f1.append(f1_.item())
            # print('acc: ' + str(acc_.item()) + '\tprec: ' + str(prec_.item()) +'\trec: ' + str(rec_.item()) + '\tf1: ' + str(f1_.item()))
            losses.append(loss.item())
        #保存当前的模型参数
        torch.save(model, './cut.bin')
        print('\nacc: ' + str(torch.tensor(acc).mean().item()) + '\tprec: ' + str(torch.tensor(prec).mean().item())
          +'\trec: ' + str(torch.tensor(rec).mean().item()) + '\tf1: ' + str(torch.tensor(f1).mean().item()))
    #对模型的测试，可以直观地看出分词效果
    test_(model)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

4.输出结果：

对应的标识为EEEESESES。即分词为 这 |是 |一|个 |最好| 的| 时| 代 。不是完全正确的，甚至有很明显的缺陷，效果不好。
保存的模型在modules/文件夹中——cut.bin。
资源：
train.txt：
链接：https://pan.baidu.com/s/1VcYQW4it5XtDwApL1r59_Q
提取码：2933