👨?🎓 博主介紹：大家好，我是可可卷，一個NLP領域的小小白~
📕 文章介紹：命名物體識別，即Named Entity Recognition(NER)，在比如QA，text summarization，machine translation等多項任務中均有涉及，今天我們將研究頂會文章Chinese NER using Lattice LSTM中的資料集，并嘗試自己手寫模型，領會stoa方案的魅力！
🎉歡迎關注💗點贊👍收藏??評論📝
🙏作者水平很有限，歡迎各位大佬指點，一起學習進步！

文章目錄

1 資料集介紹
- 1.1 資料集來源
- 1.2 資料集格式
- 1.3 資料集分析
- - 1.3.1 文本長度分布
  - 1.3.2 資料集劃分
  - 1.3.3 不同標簽樣本數
  - 1.3.4 資料集句長
2 統計學習演算法
- 2.1 Hidden Markov Model
- - 2.1.1 演算法原理
  - 2.1.2 程式代碼
  - 2.1.3 運行結果
- 2.2 Conditional Random Field
- - 2.2.1 演算法原理
  - 2.2.2 程式代碼
  - 2.2.3 運行結果
3 深度學習演算法
- 3.1 Bi-LSTM
- - 3.1.1 演算法原理
  - 3.1.2 程式代碼
  - 3.1.3 運行結果
- 3.2 Bi-LSTM+CRF
- - 3.2.1 演算法原理
  - 3.2.2 程式代碼
  - 3.2.3 運行結果
- 3.3 Bert+BiLSTM+CRF
- - 3.3.1 演算法原理
  - 3.3.2 訓練模型
  - 3.3.3 訓練結果
  - 3.3.4 模型結構
4 模型融合
- 4.1 融合策略
- 4.2 程式代碼
5 總結

1 資料集介紹

1.1 資料集來源

本次演算法實驗資料集用的是NLP頂會論文ACL 2018Chinese NER using Lattice LSTM中收集的簡歷資料，

1.2 資料集格式

目前，常用的序列標注方式有BIO和BIOES，其中BIO方式主要將物體X標注為B-X,I-X,O的格式，B-表示物體的起始位置，I-表示物體的中間或結尾，O-表示不屬于物體；而BIOES近似于BIO的改進，主要將多元物體X標注為B-X,I-X,E-X的格式，B-表示物體的起始位置，I-表示物體的中間或結尾；一元物體則標記為S-X,；O-X表示X不屬于物體，

本資料集采用BMEOS標注法，其中B-表示物體的起始位置，M-表示物體的中間，E表示物體的結尾；一元物體則標記為S-；O-表示不屬于物體，

# 資料集示例如下
高 B-NAME
勇 E-NAME
： O
男 O
， O
中 B-CONT
國 M-CONT
國 M-CONT
籍 E-CONT
， O
無 O
境 O
外 O
居 O
留 O
權 O
， O

1 O
9 O
6 O
6 O
年 O
出 O
生 O
， O
漢 B-RACE
族 E-RACE
， O
中 B-TITLE
共 M-TITLE
黨 M-TITLE
員 E-TITLE
， O
本 B-EDU
科 M-EDU
學 M-EDU
歷 E-EDU
， O
工 B-TITLE
程 M-TITLE
師 E-TITLE
、 O
美 B-ORG
國 M-ORG
項 M-ORG
目 M-ORG
管 M-ORG
理 M-ORG
協 M-ORG
會 E-ORG
注 B-TITLE
冊 M-TITLE
會 M-TITLE
員 E-TITLE
（ O
P B-TITLE
M M-TITLE
I M-TITLE
M M-TITLE
e M-TITLE
m M-TITLE
b M-TITLE
e M-TITLE
r E-TITLE
） O
、 O
注 B-TITLE
冊 M-TITLE
項 M-TITLE
目 M-TITLE
管 M-TITLE
理 M-TITLE
專 M-TITLE
家 E-TITLE
（ O
P B-TITLE
M M-TITLE
P E-TITLE
） O
、 O
項 B-TITLE
目 M-TITLE
經 M-TITLE
理 E-TITLE
， O

該資料集的所有類別如下：

{'B-CONT', 'E-PRO', 'M-CONT', 'S-NAME', 'E-CONT', 'B-PRO', 'M-LOC', 'E-FOOD', 'E-TITLE', 'M-ORG', 'B-ORG', 'M-TITLE', 'B-TITLE', 'B-RACE', 'B-EDU', 'B-FOOD', 'M-EDU', 'M-NAME', 'S-RACE', 'E-LOC', 'E-RACE', 'S-ORG', 'M-PRO', 'M-FOOD', 'E-NAME', 'E-EDU', 'B-LOC', 'E-ORG', 'B-NAME', 'M-RACE', 'O'}

1.3 資料集分析

1.3.1 文本長度分布

在這里插入圖片描述
由上圖可以發現，簡歷資料集以短句居多，有一定比例中長句，長句較少，因此在后序訓練時可以更加注重短句的背景關系關系，

1.3.2 資料集劃分

在這里插入圖片描述
依據10：1：1的比例將資料集劃分成訓練集、驗證集、測驗集，

1.3.3 不同標簽樣本數

在這里插入圖片描述
分析上圖，發現標簽分布不平衡，其中S-ORG，B-LOC的比例較高，而其他標簽的比例較低，有一定訓練難度，

1.3.4 資料集句長

在這里插入圖片描述

通過箱線圖與小提琴圖，我們可以清晰地發現，訓練集、驗證集、測驗集的資料集句長分布保存一致，

2 統計學習演算法

2.1 Hidden Markov Model

2.1.1 演算法原理

隱馬爾可夫模型描述由一個隱藏的馬爾科夫鏈隨機生成不可觀測的狀態隨機序列，再由各個狀態生成一個觀測而產生觀測隨機序列的程序，隱馬爾可夫模型由初始狀態分布，狀態轉移概率矩陣以及觀測概率矩陣所確定，
命名物體識別本質上可以看成是一種序列標注問題，在使用HMM解決命名物體識別這種序列標注問題的時候，我們所能觀測到的是字組成的序列（觀測序列），觀測不到的是每個字對應的標注（狀態序列），

2.1.2 程式代碼

import torch


class HMM(object):
    def __init__(self, N, M):
        self.N = N  # N: 狀態數，這里對應存在的標注的種類
        self.M = M  # M: 觀測數，這里對應有多少不同的字

        # 狀態轉移概率矩陣
        self.A = torch.zeros(N, N)
        # 觀測概率矩陣
        self.B = torch.zeros(N, M)
        # 初始狀態概率
        self.Pi = torch.zeros(N)

    def train(self, word_lists, tag_lists, word2id, tag2id):    # word2id: 將字映射為ID; tag2id: 將標注映射為ID
        # 使用極大似然估計的方法來估計隱馬爾可夫模型的引數

        # 估計轉移概率矩陣
        for tag_list in tag_lists:
            seq_len = len(tag_list)
            for i in range(seq_len - 1):
                current_tagid = tag2id[tag_list[i]]
                next_tagid = tag2id[tag_list[i+1]]
                self.A[current_tagid][next_tagid] += 1

        self.A[self.A == 0.] = 1e-10    # 將未出現元素設定一個小數
        self.A = self.A / self.A.sum(dim=1, keepdim=True)

        # 估計觀測概率矩陣
        for tag_list, word_list in zip(tag_lists, word_lists):
            assert len(tag_list) == len(word_list)
            for tag, word in zip(tag_list, word_list):
                tag_id = tag2id[tag]
                word_id = word2id[word]
                self.B[tag_id][word_id] += 1

        self.B[self.B == 0.] = 1e-10
        self.B = self.B / self.B.sum(dim=1, keepdim=True)

        # 估計初始狀態概率
        for tag_list in tag_lists:
            init_tagid = tag2id[tag_list[0]]
            self.Pi[init_tagid] += 1

        self.Pi[self.Pi == 0.] = 1e-10
        self.Pi = self.Pi / self.Pi.sum()

    def test(self, word_lists, word2id, tag2id):
        pred_tag_lists = []
        for word_list in word_lists:
            pred_tag_list = self.decoding(word_list, word2id, tag2id)
            pred_tag_lists.append(pred_tag_list)
        return pred_tag_lists

    def decoding(self, word_list, word2id, tag2id):
        """
        使用維特比演算法，其本質是用動態規劃解隱馬爾可夫模型預測問題（求概率最大路徑）
        """

        # 對數化防止下溢
        A = torch.log(self.A)
        B = torch.log(self.B)
        Pi = torch.log(self.Pi)

        # 初始化維位元矩陣viterbi
        seq_len = len(word_list)
        viterbi = torch.zeros(self.N, seq_len)

        # backpointer[i,j]: 標注序列的第j個標注為i時，第j-1個標注的id
        backpointer = torch.zeros(self.N, seq_len).long()


        start_wordid = word2id.get(word_list[0], None)
        Bt = B.t()
        if start_wordid is None:    
            bt = torch.log(torch.ones(self.N) / self.N)  # 如果字不再字典里，則假設狀態的概率分布是均勻的
        else:
            bt = Bt[start_wordid]                        # 否則從觀測概率矩陣中取bt
        viterbi[:, 0] = Pi + bt
        backpointer[:, 0] = -1

        # 遞推公式：viterbi[tag_id, step] = max(viterbi[:, step-1]* self.A.t()[tag_id] * Bt[word])
        for step in range(1, seq_len):
            wordid = word2id.get(word_list[step], None)
            if wordid is None:
               
                bt = torch.log(torch.ones(self.N) / self.N)
            else:
                bt = Bt[wordid]
            for tag_id in range(len(tag2id)):
                max_prob, max_id = torch.max(
                    viterbi[:, step-1] + A[:, tag_id],
                    dim=0
                )
                viterbi[tag_id, step] = max_prob + bt[tag_id]
                backpointer[tag_id, step] = max_id

        # 最優路徑的概率
        best_path_prob, best_path_pointer = torch.max(
            viterbi[:, seq_len-1], dim=0
        )

        # 求最優路徑
        best_path_pointer = best_path_pointer.item()
        best_path = [best_path_pointer]
        for back_step in range(seq_len-1, 0, -1):
            best_path_pointer = backpointer[best_path_pointer, back_step]
            best_path_pointer = best_path_pointer.item()
            best_path.append(best_path_pointer)

        # 將序列tag_id轉化為tag
        id2tag = dict((id_, tag) for tag, id_ in tag2id.items())
        tag_list = [id2tag[id_] for id_ in reversed(best_path)]

        return tag_list

2.1.3 運行結果

在這里插入圖片描述

2.2 Conditional Random Field

2.2.1 演算法原理

條件隨機場（CRF）是NER目前的主流模型，它的目標函式不僅考慮輸入的狀態特征函式，而且還包含了標簽轉移特征函式，CRF為一個位置進行標注的程序中可以利用豐富的內部及背景關系特征資訊，有效克服了HMM模型面臨的問題，

在這里插入圖片描述

(圖2.2 線性鏈條件隨機場)

2.2.2 程式代碼

from sklearn_crfsuite import CRF

# 抽取單個字的特征
def word2features(sent, i):
    word = sent[i]
    prev_word = "<s>" if i == 0 else sent[i-1]
    next_word = "</s>" if i == (len(sent)-1) else sent[i+1]
    features = {
        'w': word,                  # 當前詞
        'w-1': prev_word,           # 前一個詞
        'w+1': next_word,           # 后一個詞
        'w-1:w': prev_word+word,    # 前一個詞+當前詞
        'w:w+1': word+next_word,    # 當前詞+后一個詞
        'bias': 1
    }
    return features


# 抽取序列特征
def sent2features(sent):
    return [word2features(sent, i) for i in range(len(sent))]


class CRFModel(object):
    def __init__(self,
                 algorithm='lbfgs',
                 c1=0.1,
                 c2=0.1,
                 max_iterations=100,
                 all_possible_transitions=False
                 ):

        self.model = CRF(algorithm=algorithm,
                         c1=c1,
                         c2=c2,
                         max_iterations=max_iterations,
                         all_possible_transitions=all_possible_transitions)

    def train(self, sentences, tag_lists):
        features = [sent2features(s) for s in sentences]
        self.model.fit(features, tag_lists)

    def test(self, sentences):
        features = [sent2features(s) for s in sentences]
        pred_tag_lists = self.model.predict(features)
        return pred_tag_lists

2.2.3 運行結果

在這里插入圖片描述

3 深度學習演算法

3.1 Bi-LSTM

3.1.1 演算法原理

通過依靠神經網路超強的非線性擬合能力，LSTM在訓練時將樣本通過高維空間中的復雜非線性變換，學習到從樣本到標注的函式，之后使用這個函式為指定的樣本預測每個token的標注，
而雙向長短期有著比普通LSTM更好的捕捉序列之間的依賴關系的能力，能更好地用于捕捉背景關系關系，

在這里插入圖片描述

3.1.2 程式代碼

import torch
import torch.nn as nn
from torch.nn.utils.rnn import pad_packed_sequence, pack_padded_sequence
from torchinfo import summary
import pickle


class BiLSTM(nn.Module):
    def __init__(self, vocab_size, emb_size, hidden_size, out_size):
        super(BiLSTM, self).__init__()
        self.embedding = nn.Embedding(vocab_size, emb_size)
        self.bilstm = nn.LSTM(emb_size, hidden_size,
                              batch_first=True,
                              bidirectional=True)

        self.lin = nn.Linear(2*hidden_size, out_size)

    def forward(self, sents_tensor, lengths):
        emb = self.embedding(sents_tensor)
        packed = pack_padded_sequence(emb, lengths, batch_first=True)
        rnn_out, _ = self.bilstm(packed)
        rnn_out, _ = pad_packed_sequence(rnn_out, batch_first=True)

        scores = self.lin(rnn_out) 

        return scores

3.1.3 運行結果

在這里插入圖片描述

3.2 Bi-LSTM+CRF

3.2.1 演算法原理

Bi-LSTM:

優點是能夠根據目標（比如識別物體）自動提取觀測序列的特征
缺點是無法學習到狀態序列（輸出的標注）之間的關系(比如B類標注后面不會再接一個B類標注，而通常接M類標注或E類標注)

CRF:

優點就是能對隱含狀態建模，學習狀態序列的特點
缺點是需要手動提取序列特征

Bi-LSTM+CRF：在Bi-LSTM后面再加一層CRF，以獲得兩者的優點

3.2.2 程式代碼

from itertools import zip_longest
from copy import deepcopy

import torch
import torch.nn as nn
import torch.optim as optim


class BiLSTM_CRF(nn.Module):
    def __init__(self, vocab_size, emb_size, hidden_size, out_size):
        super(BiLSTM_CRF, self).__init__()
        self.bilstm = BiLSTM(vocab_size, emb_size, hidden_size, out_size)

        # 轉移矩陣,初始化為均勻分布
        self.transition = nn.Parameter(torch.ones(out_size, out_size) * 1/out_size)


    def forward(self, sents_tensor, lengths):
        emission = self.bilstm(sents_tensor, lengths)

        # 計算CRF scores
        batch_size, max_len, out_size = emission.size()
        crf_scores = emission.unsqueeze(
            2).expand(-1, -1, out_size, -1) + self.transition.unsqueeze(0)

        return crf_scores

    
    def decode(self, test_sents_tensor, lengths, tag2id):
        
        start_id = tag2id['<start>']
        end_id = tag2id['<end>']
        pad = tag2id['<pad>']
        tagset_size = len(tag2id)

        crf_scores = self.forward(test_sents_tensor, lengths)
        device = crf_scores.device
        B, L, T, _ = crf_scores.size()
		
		# 使用維特比演算法進行解碼
		tagids = viterbi(B, L, T, device)

        return tagids

3.2.3 運行結果

在這里插入圖片描述

3.3 Bert+BiLSTM+CRF

3.3.1 演算法原理

BERT中蘊含了大量的通用知識，利用預訓練好的BERT模型，再用少量的標注資料進行FINETUNE是一種快速的獲得效果不錯的NER的方法，
因此，通常可以采用Bert+BiLSTM+CRF的模型結構，以期獲取更高的預測精度，

在這里插入圖片描述

3.3.2 訓練模型

了解到kashgari是一個簡單而強大的NLP框架，其內包括cnnmodel、blstm模型、cnnlstm模型、avcnnmodel、KMaxnn模型、RCNN模型等序列（文本）分類模型以及cnnlstm模型、blstm模型、BLSTMCRFModel等序列（文本）標簽模型，同時提供GPU支持/多GPU支持，因此選擇了kashgari庫進行Bert模型的預訓練以及微調

from kashgari.tasks.labeling import BiLSTM_CRF_Model
import kashgari
from kashgari.embeddings.bert_embedding import  BertEmbedding
import warnings
warnings.filterwarnings('ignore')


bert_embed = BertEmbedding(r'\\chinese_L-12_H-768_A-12',
                           sequence_length=100)

model = BiLSTM_CRF_Model(bert_embed)
model.fit(train_x,
          train_y,
          x_validate=valid_x,
          y_validate=valid_y,
          epochs=5,
          batch_size=512)
model.save('ner.h5')

model.evaluate(test_x, test_y)

3.3.3 訓練結果

由于模型訓練時間過長（一個epoch需要400s），難以有效地進行fine tune，因此模型的效果并不十分理想，
在這里插入圖片描述

下面是模型訓練5個epoch的結果，可以發現，模型的精度一直在提高，并沒有達到收斂，這說明模型的潛力值得進一步挖掘，
在這里插入圖片描述

3.3.4 模型結構

請添加圖片描述

4 模型融合

4.1 融合策略

考慮到Bert+BiLSTM+CRF結構由于機器的原因，遠未發揮應有的效果，因此只將前4個模型進行融合，
融合策略為：voting

4.2 程式代碼

def flatten_lists(lists):
    flatten_list = []
    for l in lists:
        if type(l) == list:
            flatten_list += l
        else:
            flatten_list.append(l)
    return flatten_list

# 模型融合
def ensemble_evaluate(results, targets):
    for i in range(len(results)):
        results[i] = flatten_lists(results[i])

    # voting
    pred_tags = []
    for result in zip(*results):
        ensemble_tag = Counter(result).most_common(1)[0][0]
        pred_tags.append(ensemble_tag)

    targets = flatten_lists(targets)
    return targets

##4.3 融合結果
請添加圖片描述

在這里插入圖片描述
由模型精度比較圖可以發現，HMM的預測精度最低，BiLSTM次低，CRF表現中等，Essemble表現次好，BiLSTM表現最好，

5 總結

HMM認為每個字是獨立的，并且標注 t a g i tag_i tagi?只與上一個標注 t a g i ? 1 tag_{i-1} tagi?1?有關，這個假設是非常局限的，因此也導致了HMM 的預測精度不夠理想，
CRF克服了HMM的上述缺點，通過手動提取特征的方式，關注了每個字的背景關系關系，因此預測精度有了一定的上升，
通過軟投票的方式，我們在Essemble程序中對前4個模型進行了融合，我們發現Essemble的預測精度略低于BiLSTM+CRF，這可以認為是其他模型拖累了整體的精度

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/419999.html

標籤：AI

上一篇：《繁凡的深度學習筆記》第 2 章回歸問題與神經元模型（DL筆記整理系列）

下一篇：大資料分析-零基礎學Tableau+超詳細講解+示例練習（八）

【頂會學習計劃】萬字吃透NER

文章目錄

1 資料集介紹

1.1 資料集來源

1.2 資料集格式

1.3 資料集分析

1.3.1 文本長度分布

1.3.2 資料集劃分

1.3.3 不同標簽樣本數

1.3.4 資料集句長

2 統計學習演算法

2.1 Hidden Markov Model

2.1.1 演算法原理

2.1.2 程式代碼

2.1.3 運行結果

2.2 Conditional Random Field

2.2.1 演算法原理

2.2.2 程式代碼

2.2.3 運行結果

3 深度學習演算法

3.1 Bi-LSTM

3.1.1 演算法原理

3.1.2 程式代碼

3.1.3 運行結果

3.2 Bi-LSTM+CRF

3.2.1 演算法原理

3.2.2 程式代碼

3.2.3 運行結果

3.3 Bert+BiLSTM+CRF

3.3.1 演算法原理

3.3.2 訓練模型

3.3.3 訓練結果

3.3.4 模型結構

4 模型融合

4.1 融合策略

4.2 程式代碼

5 總結