https://www.toutiao.com/a6662254496954974723/
过去的几年里，在NLP（自然语言处理）领域，我们已经见证了多项令人难以置信的突破，如ULMFiT、ELMo、Facebook的PyText以及谷歌的BERT等等。
这些技术大大推进了NLP的前沿性研究，尤其是语言建模。只要给出前几个单词的顺序，我们就可以预测下一个句子。
但更重要的是，机器也找到了长期无法实现推测语句的关键因素。
那就是：语境！
对语境的了解打破了阻碍NLP技术进步的障碍。而今天，我们就来讨论这样的一个库：Flair。
至今为止，单词要么表示为稀疏矩阵，要么表示为嵌入式词语，如GLoVe，Bert和ELMo。但是，事物总有改进的空间，Flair就愿意更正不足。
在本文中，首先我们将了解Flair是什么以及其背后的概念。然后将深入讨论使用Flair实现NLP任务。
一. 什么是Flair库？
Flair是由Zalando Research开发的一个简单的自然语言处理（NLP）库。 Flair的框架直接构建在PyTorch上，PyTorch是最好的深度学习框架之一。 Zalando Research团队还为以下NLP任务发布了几个预先训练的模型：
1. 名称-实体识别（NER）：它可以识别单词是代表文本中的人，位置还是名称。
2. 词性标注（PoS）：将给定文本中的所有单词标记为它们所属的“词性”。
3. 文本分类：根据标准对文本进行分类（标签）。
4. 培训定制模型：制作我们自己的定制模型。
所有的这些模型，看起来很有前景。但真正引起我注意的是，当我看到Flair在NLP中超越了几项最先进成绩的时候。看看这个目录：
注意：F1评分主要是用于分类任务的评估指标。在评估模型时，它通常用于机器学习项目中的精度度量。F1评分考虑了现有项目的分布。
二. Flair库的优势是什么？
Flair库中包含了许多强大的功能，以下是最突出的一些方面：
· 它包括了最通用和最先进的单词嵌入方式，如GloVe，BERT，ELMo，字符嵌入等。凭借Flair API技术，使用起来非常容易。
· Flair的界面允许我们组合不同的单词嵌入并嵌入文档，显著优化了结果。
· 'Flair 嵌入'是Flair库提供的签名嵌入。它由上下文字符串嵌入提供支持，我们将在下一节中详细了解这一概念。
· Flair支持多种语言，并有望添加新语种。
三. 用于序列标记的上下文字符串嵌入简介
在处理NLP任务时，上下文语境非常重要。通过先前字符预测下一个字符，这一学习过程构成了序列建模的基础。
上下文字符串的嵌入，是通过熟练利用字符语言模型的内部状态，来产生一种新的嵌入类型。简单来说，它通过字符模型中的某些内部原则，使单词在不同的句子中可以具有不同的含义。
注意：语言和字符模型是单词/字符的概率分布，因此每个新单词或新字符都取决于前面的单词或字符。
有两个主要因素驱动了上下文字符串的嵌入：
1. 这些单词被理解为字符（没有任何单词的概念）。也就是说，它的工作原理类似于字符嵌入。
2. 嵌入是通过其周围文本进行语境化的。这意味着根据上下文，相同的单词可以有不同的嵌入意义。很像自然的人类语言，不是吗？在不同的情况下，同一个词可能有不同的含义。
让我们看个例子来理解这个意思：
· 案例1：读一本书（Reading a book）
· 案例2：请预订火车票（Please book a train ticket）
说明：
· 在案例1中，book是一个名词
· 在案例2中，book是动词
语言是如此奇妙而复杂的东西啊！
四. 使用Flair在Python中执行NLP任务
是时候让Flair进行测试了！我们已经了解了这个神奇图书馆的全部内容。现在让我们亲眼看看它在机器上是如何运行的。
我们将使用Flair在Python中执行以下所有NLP任务：
1.使用Flair对嵌入的文本分类
2.词性标记（PoS）与NLTK库的比较
建立环境
我们将使用Google Colaboratory运行我们的代码。Colab最棒的一点就是它免费提供GPU支持！这极大地方便了学习模型的深度培训。
为什么使用Colab？
· 完全免费
· 具有相当不错的硬件配置
· 你的Web浏览器上都有，即使是硬件过时的旧机器也可以运行
· 连接到你的Google云端硬盘
· 很好地与Github集成
你只需要一个稳定的互联网连接。
关于数据集
我们将努力研究Twitter Sentiment Analysis（推特敏感度分析）的实践问题。
而这一挑战带来的问题是：
这项任务的目的是检测推文中的仇恨言论。为了简单起见，如果它带有相关的种族主义或性别歧视情绪，我们则判断这条推文包含仇恨言论。因此，这项任务是将带有种族主义或性别歧视地推文与其他推文分类。
1.使用Flair嵌入进行文本分类
第1步：将数据导入Colab的本地环境：
# Install the PyDrive wrapper & import libraries.
# This only needs to be done once per notebook.
!pip install -U -q PyDrive
from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
from google.colab import auth
from oauth2client.client import GoogleCredentials
# Authenticate and create the PyDrive client.
# This only needs to be done once per notebook.
auth.authenticate_user()
gauth = GoogleAuth()
gauth.credentials = GoogleCredentials.get_application_default()
drive = GoogleDrive(gauth)
# Download a file based on its file ID.
# A file ID looks like: laggVyWshwcyP6kEI-y_W3P8D26sz
file_id = '1GhyH4k9C4uPRnMAMKhJYOqa-V9Tqt4q8' ### File ID ###
data = drive.CreateFile({'id': file_id})
#print('Downloaded content "{}"'.format(downloaded.GetContentString()))
你可以在驱动器中数据集文件的可共享链接中找到文件ID。
将数据集导入Colab笔记本：
import io
Import pandas as pd
data = pd.read_csv(io.StringIO(data.GetContentString()))
data.head()
已从数据中删除所有表情符号和符号，并且字符已转换为小写。
第2步：安装Flair
# download flair library #
import torch
!pip install flair
import flair
简要介绍一下Flair数据类型
这个库的对象有两种类型—句子和标记对象。一个句子持有一个文本句子，基本上是标记列表：
from flair.data import Sentence
# create a sentence #
sentence = Sentence('Blogs of Analytics Vidhya are Awesome.')
# print the sentence to see what’s in it. #
print(Sentence)
第3步：准备文本以使用Flair
#extracting the tweet part#
text = data['tweet']
## txt is a list of tweets ##
txt = text.tolist()
print(txt[:10])
第4步：使用Flair嵌入单词
## Importing the Embeddings ##
from flair.embeddings import WordEmbeddings
from flair.embeddings import CharacterEmbeddings
from flair.embeddings import StackedEmbeddings
from flair.embeddings import FlairEmbeddings
from flair.embeddings import BertEmbeddings
from flair.embeddings import ELMoEmbeddings
from flair.embeddings import FlairEmbeddings
### Initialising embeddings (un-comment to use others) ###
#glove_embedding = WordEmbeddings('glove')
#character_embeddings = CharacterEmbeddings()
flair_forward = FlairEmbeddings('news-forward-fast')
flair_backward = FlairEmbeddings('news-backward-fast')
#bert_embedding = BertEmbedding()
#elmo_embedding = ElmoEmbedding()
stacked_embeddings = StackedEmbeddings( embeddings = [
flair_forward-fast,
flair_backward-fast
])
你会注意到，我们刚刚使用了一些上面最流行的单词嵌入。你可以删除评论'＃'以使用所有嵌入。
现在你可能会问，到底什么是“堆叠嵌入”？在这里，我们可以结合多个嵌入来构建一个功能强大的单词表示模型，不需要太复杂。很像合唱，不是吗？
我们使用Flair的堆叠嵌入只是为了减少本文中的计算时间。使用你喜欢的任何组合可以随意地使用这个和其他嵌入。
测试堆叠嵌入：
# create a sentence #
sentence = Sentence(‘ Analytics Vidhya blogs are Awesome .')
# embed words in sentence #
stacked.embeddings(sentence)
for token in sentence:
print(token.embedding)
# data type and size of embedding #
print(type(token.embedding))
# storing size (length) #
z = token.embedding.size()[0]
第5步：将文本矢量化
我们将使用两种方法展示这一点。
· 在推文中嵌入词的意思
我们将在这种方法中计算以下内容：
对于每个句子：
1.为每个单词生成单词嵌入
2.计算每个单词嵌入的平均值以获取句子嵌入
from tqdm import tqdm ## tracks progress of loop ##
# creating a tensor for storing sentence embeddings #
s = torch.zeros(0,z)
# iterating Sentence (tqdm tracks progress) #
for tweet in tqdm(txt):
# empty tensor for words #
w = torch.zeros(0,z)
sentence = Sentence(tweet)
stacked_embeddings.embed(sentence)
# for every word #
for token in sentence:
# storing word Embeddings of each word in a sentence #
w = torch.cat((w,token.embedding.view(-1,z)),0)
# storing sentence Embeddings (mean of embeddings of all words) #
s = torch.cat((s, w.mean(dim = 0).view(-1, z)),0)
· 文档嵌入：将整个推文矢量化
from flair.embeddings import DocumentPoolEmbeddings
### initialize the document embeddings, mode = mean ###
document_embeddings = DocumentPoolEmbeddings([
flair_embedding_backward,
flair_embedding_forward
])
# Storing Size of embedding #
z = sentence.embedding.size()[1]
### Vectorising text ###
# creating a tensor for storing sentence embeddings
s = torch.zeros(0,z)
# iterating Sentences #
for tweet in tqdm(txt):
sentence = Sentence(tweet)
document_embeddings.embed(sentence)
# Adding Document embeddings to list #
s = torch.cat((s, sentence.embedding.view(-1,z)),0)
你可以为模型选择任一种方法。现在我们的文本已经矢量化过，我们可以将其提供给我们的机器学习模型了！
第6步: 为训练集和测试集划分数据
## tensor to numpy array ##
X = s.numpy()
## Test set ##
test = X[31962:,:]
train = X[:31962,:]
# extracting labels of the training set #
target = data['label'][data['label'].isnull()==False].values
第7步：构建模型并定义自定义评估程序（用于F1分数）
· 为XGBoost定义自定义F1评估程序
def custom_eval(preds, dtrain):
labels = dtrain.get_label().astype(np.int)
preds = (preds >= 0.3).astype(np.int)
return [('f1_score', f1_score(labels, preds))]
· 构建XGBoost模型
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score
### Splitting training set ###
x_train, x_valid, y_train, y_valid = train_test_split(train, target,
random_state=42,
test_size=0.3)
### XGBoost compatible data ###
dtrain = xgb.DMatrix(x_train,y_train)
dvalid = xgb.DMatrix(x_valid, label = y_valid)
### defining parameters ###
params = {
'colsample': 0.9,
'colsample_bytree': 0.5,
'eta': 0.1,
'max_depth': 8,
'min_child_weight': 6,
'objective': 'binary:logistic',
'subsample': 0.9
}
### Training the model ###
xgb_model = xgb.train(
params,
dtrain,
feval= custom_eval,
num_boost_round= 1000,
maximize=True,
evals=[(dvalid, "Validation")],
early_stopping_rounds=30
)
至此，我们的模型已经通过训练，可以进行评估了！
第8步: 可以预测了！
### Reformatting test set for XGB ###
dtest = xgb.DMatrix(test)
### Predicting ###
predict = xgb_model.predict(dtest) # predicting
我们可以把预测上传到练习题界面，其中，0.2是概率阈值。
注意：根据Flair的官方文档显示，一个嵌入和其他嵌入堆叠时，效果更佳。但是存在一个问题。
在CPU上计算可能需要非常长的时间，强烈建议利用GPU来获得更快的结果，你可以在Colab中使用免费的。
2.词性标注（POS）
我们将使用Conll-2003数据集的一个子集，是一个预先标记的英文数据集。
第1步：导入数据集
### file was uploaded manually to local environment of Colab ###
data = open('pos-tagged_corpus.txt','r')
txt = data.read()
#print(txt)
数据文件每行包含一个单词，空行表示句子边界。
第2步：从数据集中提取句子和PoS标签
### converting text in form of list of (words with their tags) ###
txt = txt.split(' ')
### removing DOCSTART (document header)
txt = [x for x in txt if x != '-DOCSTART- -X- -X- O']
### check ###
for i in range(10):
print(txt[i])
print(‘-’*10)
### Extracting Sentences ###
# Initialize empty list for storing words
words = []
# initialize empty list for storing sentences #
corpus = []
for i in tqdm(txt):
## if blank sentence encountered ##
if i =='':
## previous words form a sentence ##
corpus.append(' '.join(words))
## Refresh Word list ##
words = []
else:
## word at index 0 ##
words.append(i.split()[0])
# did it work? #
for i in range(10):
print(corpus[i])
print(‘-’*10)
### Extracting POS ###
# Initialize empty list for storing word pos
w_pos = []
#initialize empty list for storing sentence pos #
POS = []
for i in tqdm(txt):
## blank sentence = new line ##
if i =='':
## previous words form a sentence POS ##
POS.append(' '.join(w_pos))
## Refresh words list ##
w_pos = []
else:
## pos tag from index 1 ##
w_pos.append(i.split()[1])
# did it work? #
for i in range(10):
print(corpus[i])
print(POS[i])
### Removing blanks form sentence and pos ###
corpus = [x for x in corpus if x!= '']
POS = [x for x in POS if x!= '']
### Check ###
For i in range(10):
print(corpus[i])
print(POS[i])
我们从数据集中提取了我们需要的基本方面。让我们继续第3步。
第3步：使用NLTK和Flair标记文本
· 使用NLTK进行标记
首先，输入所需的库资源：
import nltk
nltk.download('tagsets')
nltk.download('punkt')
nltk.download('averaged_perceptron_tagger')
from nltk import word_tokenize
这将会下载所有所需的文件，用于使用NLTK进行标记。
### Tagging the corpus with NLTK ###
#for storing results#
nltk_pos = []
##for every sentence ##
for i in tqdm(corpus):
# Tokenize sentence #
text = word_tokenize(i)
#tag Words#
z = nltk.pos_tag(text)
# store #
nltk_pos.append(z)
POS标签采用以下格式：
[(‘token_1’, ‘tag_1’), ………….. , (‘token_n’, ‘tag_n’)]
让我们从中提取POS：
### Extracting final pos by nltk in a list ###
tmp = []
nltk_result = []
## every tagged sentence ##
for i in tqdm(nltk_pos):
tmp = []
## every word ##
for j in i:
## append tag (from index 1) ##
tmp.append(j[1])
# join the tags of every sentence #
nltk_result.append(' '.join(tmp))
### check ###
for i in range(10):
print(nltk_result[i])
print(corpus[i])
NLTK标签已准备就绪。
· 现在，关注一下使用Flair进行标记
首先，输入库资源：
!pip install flair
from flair.data import Sentence
from flair.models import SequenceTagger
使用Flair进行标记：
# initiating object #
pos = SequenceTagger.load('pos-fast')
#for storing pos tagged string#
f_pos = []
## for every sentence ##
for i in tqdm(corpus):
sentence = Sentence(i)
pos.predict(sentence)
## append tagged sentence ##
f_pos.append(sentence.to_tagged_string())
###check ###
for i in range(10):
print(f_pos[i])
print(corpus[i])
结果将为以下格式：
token_1 <tag_1> token_2 <tag_2> ………………….. token_n <tag_n>
注意：我们可以在Flair库中使用不同的标记器，可以随意修补和实验。
用NLTK的方式提取句子标签
Import re
### Extracting POS tags ###
## in every sentence by index ##
for i in tqdm(range(len(f_pos))):
## for every words ith sentence ##
for j in corpus[i].split():
## replace that word from ith sentence in f_pos ##
f_pos[i] = str(f_pos[i]).replace(j,"",1)
## Removing < > symbols ##
for j in ['<','>']:
f_pos[i] = str(f_pos[i]).replace(j,"")
## removing redundant spaces ##
f_pos[i] = re.sub(' +', ' ', str(f_pos[i]))
f_pos[i] = str(f_pos[i]).lstrip()
### check ###
for i in range(10):
print(f_pos[i])
print(corpus[i])
啊哈！我们终于标记了语料库并从其中按顺序提取出句子。我们可以自由删除所有的标点和特殊符号。
### Removing Symbols and redundant space ###
## in every sentence by index ##
for i in tqdm(range(len(corpus))):
# Removing Symbols #
corpus[i] = re.sub('[^a-zA-Z]', ' ', str(corpus[i]))
POS[i] = re.sub('[^a-zA-Z]', ' ', str(POS[i]))
f_pos[i] = re.sub('[^a-zA-Z]', ' ', str(f_pos[i]))
nltk_result[i] = re.sub('[^a-zA-Z]', ' ', str(nltk_result[i]))
## Removing HYPH SYM (they are for symbols) ##
f_pos[i] = str(f_pos[i]).replace('HYPH',"")
f_pos[i] = str(f_pos[i]).replace('SYM',"")
POS[i] = str(POS[i]).replace('SYM',"")
POS[i] = str(POS[i]).replace('HYPH',"")
nltk_result[i] = str(nltk_result[i].replace('HYPH',''))
nltk_result[i] = str(nltk_result[i].replace('SYM',''))
## Removing redundant space ##
POS[i] = re.sub(' +', ' ', str(POS[i]))
f_pos[i] = re.sub(' +', ' ', str(f_pos[i]))
corpus[i] = re.sub(' +', ' ', str(corpus[i]))
nltk_result[i] = re.sub(' +', ' ', str(nltk_result[i]))
我们使用NLTK和Flair标记了语料库，提取并删除了所有不必要的元素，让我们一起看看：
for i in range(1000):
print('corpus '+corpus[i])
print('actual '+POS[i])
print('nltk '+nltk_result[i])
print('flair '+f_pos[i])
print('-'*50)
输出：
结果看起来非常有说服力！
第4步：针对标记数据集评估来自NLTK和Flair的PoS标记
在这里，我们将在定制评估器的帮助下对标签进行逐字评估。
请注意，在上面的示例中，与NLTK和flair标签相比，实际的POS标签包含冗余（如粗体所示）。因此，我们不会考虑句子长度不等的POS标记句子。
### EVALUATION FUNCTION ###
def eval(x,y):
# correct match #
count = 0
#Total comparisons made#
comp = 0
## for every sentence index in dataset ##
for i in range(len(x)):
## if the sentence length match ##
if len(x[i].split()) == len(y[i].split()):
## compare each word ##
for j in range(len(x[i].split())):
if x[i][j] == y[i][j] :
## Match! ##
count = count+1
comp = comp + 1
else:
comp = comp + 1
return (count/comp)*100
最后，我们根据数据集提供的POS标签评估NLTK和Flair的POS标签。
print("nltk Score ", eval2(POS,nltk_result))
print("Flair Score ", eval2(POS,f_pos))
结果是：
NLTK评估分数: 85.38654023442645
Flair 评估分数: 90.96172124773179
Flair显然在字嵌入和堆叠字嵌入方面占据优势。由于其高级的API，这些嵌入可以毫不费力地实现。