5月14日复盘
二、BiLSTM
1. 概述
双向长短期记忆网络（Bi-directional Long Short-Term Memory，BiLSTM）是一种扩展自长短期记忆网络（LSTM）的结构，旨在解决传统 LSTM 模型只能考虑到过去信息的问题。BiLSTM 在每个时间步同时考虑了过去和未来的信息，从而更好地捕捉了序列数据中的双向上下文关系。
BiLSTM 的创新点在于引入了两个独立的 LSTM 层，一个按正向顺序处理输入序列，另一个按逆向顺序处理输入序列。这样，每个时间步的输出就包含了当前时间步之前和之后的信息，进而使得模型能够更好地理解序列数据中的语义和上下文关系。
-
正向传递: 输入序列按照时间顺序被输入到第一个LSTM层。每个时间步的输出都会被计算并保留下来。
-
反向传递: 输入序列按照时间的逆序（即先输入最后一个元素）被输入到第二个LSTM层。与正向传递类似，每个时间步的输出都会被计算并保留下来。
-
合并输出: 在每个时间步，将两个LSTM层的输出通过某种方式合并（如拼接或加和）以得到最终的输出。
2. BILSTM模型应用背景
命名体识别
标注集
BMES标注集
分词的标注集并非只有一种，举例中文分词的情况，汉子作为词语开始Begin，结束End,中间Middle，单字Single，这四种情况就可以囊括所有的分词情况。于是就有了BMES标注集，这样的标注集在命名实体识别任务中也非常常见。
词性标注
在序列标注问题中单词序列就是x，词性序列就是y，当前词词性的判定需要综合考虑前后单词的词性。而标注集最著名的就是863标注集和北大标注集。
3. 代码实现
原生代码
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def tanh(x):
return np.tanh(x)
class GRU:
def __init__(self, input_size, hidden_size, output_size):
self.input_size = input_size
self.hidden_size = hidden_size
self.output_size = output_size
#权重矩阵和偏置
self.W_z = np.random.randn(hidden_size + input_size, hidden_size)
self.b_z = np.zeros((hidden_size,))
self.W_r = np.random.randn(hidden_size + input_size, hidden_size)
self.b_r = np.zeros((hidden_size,))
# ht候选
self.W = np.random.randn(hidden_size + input_size, hidden_size)
self.b = np.zeros((hidden_size,))
def forward(self, x, h_last):
"""
:param x: [s,dim]
:param h_last:
:return:
"""
# 初始化状态
h_prev = np.zeros((self.hidden_size,))
h_all = []
for i in range(x.shape[0]):
x_t = x[i]
x_t_h_prev = np.concatenate((x_t, h_prev), axis=0)
r_t = sigmoid(np.dot(x_t_h_prev, self.W_r) + self.b_r)
z_t = sigmoid(np.dot(x_t_h_prev, self.W_z) + self.b_z)
# h_prev = r_t * h_prev
h_t_input = np.concatenate((x_t, h_prev * r_t), axis=0)
h_t_candidate = tanh(np.dot(h_t_input, self.W) + self.b)
h_t = (1 - z_t) * h_prev + z_t * h_t_candidate
h_all.append(h_t)
return h_all
if __name__ == '__main__':
gru = GRU(input_size=2, hidden_size=5, output_size=1)
x = np.random.randn(3 , 2)
h_last = np.zeros((3,))
h_all = gru.forward(x, h_last)
print(h_all)
# ---------------------------------------------------------------------------
import numpy as np
# 创建一个包含两个二维数组的列表
inputs = [np.array([[0.1], [0.2], [0.3]]), np.array([[0.4], [0.5], [0.6]])]
# 使用 numpy 库中的 np.stack 函数。这会将输入的二维数组堆叠在一起，从而形成一个新的三维数组
inputs_3d = np.stack(inputs)
# 将三维数组转换为列表
list_from_3d_array = inputs_3d.tolist()
print(list_from_3d_array)
Pytorch
import torch
import torch.nn as nn
# 模型参数设置
batch_size = 10
sen_len = 6
hidden_size = 8
input_size = 3
output_size = hidden_size * 2 # 类别是隐藏层大小的两倍
# 初始化隐藏层状态
h_prev = torch.zeros(1, batch_size, hidden_size)
# RNN调用
model = nn.GRU(input_size, hidden_size, batch_first=True)
fc = nn.Linear(hidden_size, output_size) # 全连接层用于分类
# 初始化数据
x = torch.randn(10, 6, 3)
out, h_next = model(x, h_prev)
# 对每个时间步的输出进行分类
out = out.contiguous().view(-1, hidden_size) # 调整形状为 (batch_size * sen_len, hidden_size)
out = fc(out)
out = out.view(batch_size, sen_len, output_size) # 调整回 (batch_size, sen_len, output_size)
print("多对多输出:")
print(out.shape)
print(out)
print(h_next.shape)
print(h_next)
out, h_next = model(x, h_prev)
# 只对最后一个时间步的输出进行分类
final_out = h_next.squeeze(0) # 移除多余的维度，得到 (batch_size, hidden_size)
final_out = fc(final_out)
print("\n多对一输出:")
print(final_out.shape)
print(final_out)
print(h_next.shape)
print(h_next)
