共计 8893 个字符，预计需要花费 23 分钟才能阅读完成。
Word2Vec 模型
Word2Vec 有两种训练方法：CBOW 和 Skip-gram。CBOW 的核心思想是上下文预测某个单词，Skip-gram 正好相反，输入单词，要求网络预测它的上下文。
如上图所示，一个单词表达成 word embedding 后，很容易找到词义相近的其它词汇。
word embedding 使用：句子中的单词以 one-hot 的形式作为输入，然后乘以学好的 word embedding 矩阵 Q，就直接取出单词对应的 word embedding 了。word embedding 矩阵 Q 其实就是网络 one-hot 层到 embedding 层映射的网络参数矩阵。所以，word embedding 等价于把 one-hot 层到 embedding 层的网络用预训练好的参数矩阵 Q 初始化了。不过，word embedding 只能初始化第一层网络参数，再高层就无能为力了。下游 NLP 任务使用 word embedding 的时候与图像类似，有两种方法，一种是 frozen：word embedding 层的网络参数固定不动；另一种是 fine-tuning，即：word embedding 这层参数使用新的训练集合训练。
word embedding 存在的问题
如图所示，多义词 bank 有两种含义，但是 word embedding 在对 bank 这个词进行编码的时候无法区分这两个含义。尽管上下文环境中出现的单词相同，但是在语言模型训练的时候，不论什么上下文的句子经过 word2vec，都是预测相同的单词 bank，而同一个单词占用的同一行的参数空间，这导致两种不同的上下文信息都会编码到相同的 word embedding 空间去。所以，word embedding 无法区分多义词的不同语义，这是它一个比较严重的问题。
Bert
Bert 采用 transformer 作为特征提取器，并采用双向语言模型。此外，Bert 预训练的数据规模非常庞大。
NLP 的四大类任务：
序列标注：中文分词，词性标注，命名实体识别，语义角色标注等。特点是，句子中的每个单词要求模型根据上下文给出一个分类类别。
分类任务：文本分类，情感计算。特点是，不管文章有多长，总体给出一个分类类别即可。
句子关系判断：问答，语义改写，自然语言推理等任务。特点是，给定两个句子，模型判断两个句子是否具有某种语义关系。
生成式任务：机器翻译，文本摘要，写诗造句，看图说话等。特点是，输入文本后，需要自主生成另外一种文字。
对于句子关系类任务，加上一个其实符号和终结符号，句子之间加上分隔符号即可。对输出来说，把第一个起始符号对应的 transformer 最后一层位置上串联一个 softmax 分类层。
对于分类问题，增加起始和终结符号，输出部分和句子关系类任务类似。
序列标注问题: 输入部分和单句分类问题一样，只需要输出部分 transformer 最后一层每个单词对应位置都进行分类即可。
从这里可以看出，NLP 四大类任务都可以比较方便的改造 bert 能够接受的方式，这意味着 bert 具有很强的普适性。
bert 构造双向语言模型
Masked 双向语言模型，随机选择语料中 15% 的单词，其中 80% 替换成 mask 标记，10% 随机替换另一个单词，10% 不做改动。Next Sentence Prediction，分两种情况选择句子，一种是在语料中选择真正顺序相连的两个句子；另一种方式是，第二个句子随机选择拼接到第一个句子的后面。要求模型做句子关系预测，判断第二个句子是不是真的第一个句子的后续句子。这么做的目的是，在很多 NLP 任务中是句子关系判断任务，单词预测颗粒度的训练到不了句子关系这个层级，增加这个任务有助于下游句子关系判断任务。由此可以看到，bert 的预训练是个多任务过程。
bert 输入部分处理
bert 输入是一个线性序列，两个句子通过分隔符分割，前后两端分别增加标识符号。每个单词有三个 embedding。
位置 embedding：NLP 中单词顺序是重要特征，需要对位置进行编码。
单词 embedding
句子 embedding：前面提到的训练数据都是由两个句子构成，那么每个句子有个句子整体的 embedding 对应每个单词。
三者叠加，就形成了 bert 的输入。
bert 输出处理
bert 评价
从模型或者方法的角度来看，bert 借鉴了 ELMO,GPT 以及 CBOW，主要提出了 masked 语言模型和 next sentence prediction。训练采用两阶段模型，第一阶段双向语言模型预训练，第二阶段采用具体任务 fine-tuning 或者做特征集成；第二是特征提取采用 transformer 作为特征提取器而不是 rnn 或 cnn。bert 最大的两点是效果好普适性强，几乎所有的 NLP 任务都可以套用 bert 这种两阶段解决思路。
案例实现：Predicting Movie Review Sentiment with BERT on TF Hub
bert 已经添加到 TF-Hub 模块，可以快速集成到现有项目中。bert 层可以替代之前的 elmo，glove 层，并且通过 fine-tuning，bert 可以同时提供精度，训练速度的提升。此案例中，我们将在 tensorflow 中使用 bert 训练一个模型用于判断电影评论的情绪是消极还是积极。
导入模块
from sklearn.model_selection import train_test_split
import pandas as pd
import tensorflow as tf
import tensorflow_hub as hub
from datetime import datetime
!pip install bert-tensorflow
import bert
from bert import run_classifier
from bert import optimization
from bert import tokenization
数据下载
# 读取文件，创建 dataframe
def load_directory_data(directory):
data={}
data[‘sentence’]=[]
data[‘sentiment’]=[]
for file_path in os.listdir(directory):
with tf.gfile.GFile(os.path.join(directory,file_path),’r’) as f:
data[‘sentence’].append(f.read())
data[‘sentiment’].append(re.match(‘\d+_(\d+)\.txt’,file_path).group(1))
return pd.DataFrame.from_dict(data)
# 添加新列，并打乱数据
def load_dataset(directory):
# 积极情绪文件
pos_df=load_directory_data(os.path.join(directory,’pos’))
# 消极情绪
neg_df=load_directory_data(os.path.join(directory,’neg’))
pos_df[‘polarity’]=1
neg_df[‘polarity’]=0
# sample 参数 frac，返回的比例，如：df 中有 10 行数据，想返回 30%，设置值为：0.3
return pd.concat([pos_df,neg_df]).sample(frac=1).reset_index(drop=True)
# 下载并加载数据
def download_and_load_datasets(force_download=False):
dataset=tf.keras.utils.get_file(
fname=’aclImdb.tar.gz’,
origin=’http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz’,
extract=True
)
train_df=load_dataset(os.path.join(os.path.dirname(dataset),’aclImdb’,’train’))
test_df=load_dataset(os.path.join(os.path.dirname(dataset),’aclImdb’,’test’))
return train_df,test_df
train,test=download_and_load_datasets()
# 去前 5000 个样本
train=train.sample(5000)
test=test.sample(5000)
DATA_COLUMN=’sentence’
LABEL_COLUMN=’polarity’
label_list=[0,1]
数据处理
我们需要将数据转换成 bert 能够处理的格式。我们首先创建 InputExample 构造函数：
test_a：我们要分类的数据，如：DATA_COLUMN
test_b：用于句子关系判断，如：问答，翻译等
label：数据标签
train_InputExample=train.apply(lambda x:bert.run_classifier.InputExample(
guid=None,
text_a=x[DATA_COLUMN],
text_b=None,
label=x[LABEL_COLUMN]
),axis=1)
test_InputExample=test.apply(lambda x:bert.run_classifier.InputExample(
guid=None,
text_a=x[DATA_COLUMN],
text_b=None,
label=x[LABEL_COLUMN]
),axis=1)
接下来，我们需要处理数据以适合 bert 进行训练。步骤依次如下：
单词全部小写
将文本转换成序列（如：‘sally says hi’-> [‘sally’,’says’,’hi’]）
将单词分解为 wordpieces（如：‘calling’->[‘call’,’##ing’]）
用 bert 提供的词汇文件进行单词索引映射
添加‘CLS’,’SEP’ 标记符
每次输入添加‘index’和‘segment’标记
# lowercase bert 版本
BERT_MODEL_HUB=’https://tfhub.dev/google/bert_uncased_L-12_H-768_A-12/1′
# 获取词表文件，小写数据处理
def create_tokenizer_from_hub_module():
with tf.Graph().as_default():
bert_module = hub.Module(BERT_MODEL_HUB)
tokenization_info = bert_module(signature=’tokenization_info’, as_dict=True)
with tf.Session() as sess:
vocab_file,do_lower_case=sess.run([tokenization_info[‘vocab_file’],tokenization_info[‘do_lower_case’]])
return bert.tokenization.FullTokenizer(
vocab_file=vocab_file,
do_lower_case=do_lower_case
)
tokenizer=create_tokenizer_from_hub_module()
# 序列最长
MAX_SEQ_LENGTH=128
# 将训练，测试数据特征转换成 bert 需要的格式
train_features=bert.run_classifier.convert_examples_to_features(train_InputExample,label_list,MAX_SEQ_LENGTH,tokenizer)
test_features=bert.run_classifier.convert_examples_to_features(test_InputExample,label_list,MAX_SEQ_LENGTH,tokenizer)
创建模型
def create_model(is_predicting,input_ids,input_mask,segment_ids,labels,num_labels):
# 创建分类模型
bert_module=hub.Module(
BERT_MODEL_HUB,
trainable=True
)
bert_inputs=dict(
input_ids=input_ids,
input_mask=input_mask,
segment_ids=segment_ids
)
bert_outputs=bert_module(
inputs=bert_inputs,
signature=’tonkens’,
as_dict=True
)
output_layer=bert_outputs[‘pooled_output’]
hidden_size=output_layer.shape[-1].value
output_weights=tf.get_variable(
‘output_weights’,[num_labels,hidden_size],
initializer=tf.truncated_normal_initializer(stddev=0.02)
)
output_bias=tf.get_variable(
‘output_bias’,[num_labels],initializer=tf.zeros_initializer()
)
with tf.variable_scope(‘loss’):
# dropout 用于防止过拟合，仅训练时使用
output_layer=tf.nn.dropout(output_layer,keep_prob=0.9)
logits=tf.matmul(output_layer,output_weights,transpose_b=True)
logits=tf.nn.bias_add(logits,output_bias)
log_prob=tf.nn.log_softmax(logits,axis=-1)
# 将标签转为 one-hot 格式
one_hot_labels=tf.one_hot(labels,depth=num_labels)
predcited_labels=tf.squeeze(tf.argmax(log_prob,axis=-1))
if is_predicting:
return (predcited_labels,log_prob)
per_example_loss=-tf.reduce_sum(one_hot_labels*log_prob,axis=-1)
loss=tf.reduce_mean(per_example_loss)
return (loss,predcited_labels,log_prob)
创建 InputFn
def model_fn_builder(num_labels,learning_rate,num_train_steps,num_warmup_steps):
def model_fn(features,labels,mode,params):
input_idx=features[‘input_idx’]
input_mask=features[‘input_mask’]
segment_ids=features[‘segment_ids’]
lable_ids=features[‘labels_ids’]
is_predicting=(mode == tf.estimator.ModeKeys.PREDICT)
if not is_predicting:
(loss,predicted_labels,log_probs)=create_model(
is_predicting,input_idx,input_mask,segment_ids,lable_ids,num_labels
)
train_op = bert.optimization.create_optimizer(
loss, learning_rate, num_train_steps, num_warmup_steps, use_tpu=False)
def metric_fn(label_ids,predicted_labels):
accuracy=tf.metrics.accuracy(labels=lable_ids,predictions=predicted_labels)
f1_score = tf.contrib.metrics.f1_score(
label_ids,
predicted_labels)
auc = tf.metrics.auc(
label_ids,
predicted_labels)
recall = tf.metrics.recall(
label_ids,
predicted_labels)
precision = tf.metrics.precision(
label_ids,
predicted_labels)
true_pos = tf.metrics.true_positives(
label_ids,
predicted_labels)
true_neg = tf.metrics.true_negatives(
label_ids,
predicted_labels)
false_pos = tf.metrics.false_positives(
label_ids,
predicted_labels)
false_neg = tf.metrics.false_negatives(
label_ids,
predicted_labels)
return {
“eval_accuracy”: accuracy,
“f1_score”: f1_score,
“auc”: auc,
“precision”: precision,
“recall”: recall,
“true_positives”: true_pos,
“true_negatives”: true_neg,
“false_positives”: false_pos,
“false_negatives”: false_neg
}
eval_metrics=metric_fn(lable_ids,predicted_labels)
if mode == tf.estimator.ModeKeys.TRAIN:
return tf.estimator.EstimatorSpec(
mode=mode,
loss=loss,
train_op=train_op
)
else:
return tf.estimator.EstimatorSpec(
mode=mode,
loss=loss,
eval_metric_ops=eval_metrics
)
else:
(predicted_labels, log_probs) = create_model(
is_predicting, input_idx, input_mask, segment_ids, lable_ids, num_labels)
predictions = {
‘probabilities’: log_probs,
‘labels’: predicted_labels
}
return tf.estimator.EstimatorSpec(mode, predictions=predictions)
return model_fn
参数配置
BATCH_SIZE=32
LEARNING_RATE=2e-5
NUM_TRAIN_EPOCHS=3
WARMUP_PROPORTION=0.1
SAVE_CHECKEPOINTS_STEPS=500
SAVE_SUMMARY_STEPS=100
# 计算 train，warmup 总训练步数
num_train_steps=int(len(train_features)/BATCH_SIZE*NUM_TRAIN_EPOCHS)
num_warmup_steps=int(num_train_steps*WARMUP_PROPORTION)
# 设置模型保存路径 / 次数，图信息保存次数
run_config=tf.estimator.RunConfig(
model_dir=OUTPUT_DIR,
save_checkpoints_steps=SAVE_CHECKEPOINTS_STEPS,
save_summary_steps=SAVE_SUMMARY_STEPS
)
模型训练，验证
modle_fn=model_fn_builder(
num_labels=len(label_list),
learning_rate=LEARNING_RATE,
num_train_steps=num_train_steps,
num_warmup_steps=num_train_steps
)
estimator=tf.estimator.Estimator(
model_fn=modle_fn,
config=run_config,
params={‘batch_size’:BATCH_SIZE}
)
train_input_fn=bert.run_classifier.input_fn_builder(
features=train_features,
seq_length=MAX_SEQ_LENGTH,
is_training=True,
drop_remainder=False
)
estimator.train(input_fn=train_input_fn,max_steps=num_train_steps)
