python实战（六）——推特文本分类

最新推荐文章于 2025-03-28 14:39:42 发布

CM莫问

最新推荐文章于 2025-03-28 14:39:42 发布

阅读量1.4k

点赞数 26

分类专栏： python实战深度学习文章标签： python 人工智能算法 bert 神经网络自然语言处理

本文链接：https://blog.csdn.net/ChaneMo/article/details/143356712

版权

深度学习同时被 2 个专栏收录

39 篇文章

订阅专栏

python实战

17 篇文章

订阅专栏

一、任务目标

这次我们用的是kaggle的入门数据集《Natural Language Processing with Disaster Tweets》，为了便于评估建模效果，我们仅使用带标签的train.csv文件。这个任务的目标是根据给出的推特文本判断是否真的是发生了灾难，这是由于一些人会使用与灾难相关的词语去描述正在发生的事情，但却并不是真的发生了灾难。比如“大地震！xxx发布了最新的自研操作系统！”，这里用到了地震这个词，但实际上只是表达作者对此的震惊，并不是真的地震了。我们需要训练一个模型去划分哪些是真的灾难，哪些只是夸张的表达（二分类问题）。

二、深度学习建模

1、探索性数据分析

首先看看数据量和各个列：

import pandas as pd
df = pd.read_csv('./data/disasterTweets.csv')
print('数据量：', len(df))
print(df.head())

打印一下各列的信息：

print(df.info())

我们可以看到总共有5列，其中最主要的是text和target列，同时，keyword和location列存在一定数量的空值。

2、数据预处理

由于keyword和location列存在一些空值，这里我们需要思考处理的策略。假设我们仅使用text和target进行建模，那么大可直接去掉keyword和location两列。然而，凭直觉判断，或许这两列能够为建模提供一些额外的信息，比如可能在哪个地方发生了真实的灾难，推特文本中也会带上这个地点名，又或者关键词可以帮助我们判断到底推文的重点的地方在哪里，那么我们就不能简单的删掉这两列又或是删掉包含空值的行（因为要预测的新数据或许这两个字段就是空的，我们需要考虑这种情况的处理，总不能把要预测的新数据中的这种含空值列也删掉）。

在这里，笔者选择使用文本填充空值（原字段数据类型就是文本）：

df = df.fillna('EMPTY')

3、特征工程

（1）处理location列

这里我们考虑构造一些新的特征，因为我们打算充分使用keyword和location两列。首先处理location，我们统计一下，location是否在推特正文中出现过：

loc_in_text = []
for loc, twe in zip(df['location'], df['text']):
    if loc in twe:
        loc_in_text.append(1)
    else:
        loc_in_text.append(0)
df['loc_in_text'] = loc_in_text

接着，我们看一下在正文中出现了location且实际发生灾难的比例：

have_disaster = 0
no_disaster = 0
for lab, lit in zip(df['target'], df['loc_in_text']):
    if lab==lit:
        if lab==0:
            no_disaster += 1
        else:
            have_disaster += 1
print('没有发生灾难的数据量：{}，文中出现location的数据量：{}'.format(df['target'].tolist().count(0), no_disaster))
print('发生灾难的数据量：{}，文中出现location的数据量：{}'.format(df['target'].tolist().count(1), have_disaster))

可以看到，虽然实际发生灾难的推文中出现location的推文只有数十条，但是在没发生灾难的推文中大部分都出现了location，可见location应该有一定用处。

（2）处理keyword列

这里我们如法炮制：

keyword_in_text = []
for kw, twe in zip(df['keyword'], df['text']):
    if kw in twe:
        keyword_in_text.append(1)
    else:
        keyword_in_text.append(0)
df['keyword_in_text'] = keyword_in_text

have_keyword = 0
no_keyword = 0
for lab, kit in zip(df['target'], df['keyword_in_text']):
    if lab==kit:
        if lab==0:
            no_keyword += 1
        else:
            have_keyword += 1
print('没有发生灾难的数据量：{}，文中出现keyword的数据量：{}'.format(df['target'].tolist().count(0), no_keyword))
print('发生灾难的数据量：{}，文中出现keyword的数据量：{}'.format(df['target'].tolist().count(1), have_keyword))

可见，keyword在两类数据中的出现概率差距要比location小，但是我们目前先保留。

4、文本表示

为了对比加入location和keyword辅助信息与否对建模结果的影响，这里我们分两种情况进行文本表示。同时，本文直接应用bert模型进行文本向量化，不对bert进行任务微调，展示一下预训练语言模型拿来即用的效果。首先加载模型：

from transformers import BertTokenizer, BertModel
import torch
 
# 同样，可以去HuggingFace找更强大的模型
model_name = 'bert-base-uncased'
# 初始化分词器
tokenizer = BertTokenizer.from_pretrained(model_name)
# 加载模型
model = BertModel.from_pretrained(model_name)

（1）原始推文文本表示

由于数据量不大，这里不使用DataLoader了，直接写循环：

texts = df['text'].tolist()
# 定义批量大小
batch_size = 16
# 创建一个空列表来存储所有的句子嵌入
all_sentence_embeddings = []
# 处理数据的批量
for i in range(0, len(texts), batch_size):
    if i%100==0:
        print('processing No.{} sample'.format(i))
        
    batch_texts = texts[i:i+batch_size]
    
    # 分词器生成Bert必要的输出格式
    inputs = tokenizer(batch_texts, padding=True, truncation=True, return_tensors="pt")
    
    # 禁用梯度，打开预测模式
    with torch.no_grad():
        # 预测输出
        outputs = model(**inputs)
    
    # 取最后一层的token平均向量
    sentence_embeddings = outputs.pooler_output
    
    # 将当前批量的句子嵌入添加到列表中
    all_sentence_embeddings += sentence_embeddings

（2）原始推文加辅助信息文本表示

首先，文本类信息无法像数值类数据建模那样使用简单的0、1索引，我们选择通过在原推文添加额外文本的形式将附加的location和keyword信息融入进文本中（某种程度上来看，这属于语义增强的一种方式）。下面这里只是一个示例，实际上可以有很多种方式的语义增强，得益于预训练模型强大的理解能力，我们所增加的文本信息能够较好地被模型理解并表达出来，这是传统文本表示模型所无法比拟的。

texts = df['text'].tolist()
location_info = '. With location:'
keyword_info = 'With keyword:'
texts_with_tips = []
for text, loc, kw, word in zip(texts, loc_in_text, keyword_in_text, df['keyword'].tolist()):
    if loc==1:
        text += location_info+'True.'
    else:
        text += location_info+'False.'
    if kw==1:
        text += keyword_info+word+'True.'+'Keyword:'+word+'.'
    else:
        text += keyword_info+'False.'
    texts_with_tips.append(text)
texts = texts_with_tips

# 定义批量大小
batch_size = 16
# 创建一个空列表来存储所有的句子嵌入
all_sentence_embeddings = []
# 处理数据的批量
for i in range(0, len(texts), batch_size):
    if i%100==0:
        print('processing No.{} sample'.format(i))
        
    batch_texts = texts[i:i+batch_size]
    
    # 分词器生成Bert必要的输出格式
    inputs = tokenizer(batch_texts, padding=True, truncation=True, return_tensors="pt")
    
    # 禁用梯度，打开预测模式
    with torch.no_grad():
        # 预测输出
        outputs = model(**inputs)
    
    # 取最后一层的token平均向量
    sentence_embeddings = outputs.pooler_output
    
    # 将当前批量的句子嵌入添加到列表中
    all_sentence_embeddings += sentence_embeddings

5、分类建模

先划分数据集，sklearn模型无法处理torch的tensor，我们将它转换成list类型：

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split([list(li) for li in all_sentence_embeddings], df['target'].tolist(), stratify=df['target'].tolist(), test_size=0.3, random_state=2024)

这里下游模型直接使用一个简单的MLP：

from sklearn.neural_network import MLPClassifier
from sklearn.metrics import precision_score, recall_score, f1_score
dtc = MLPClassifier(hidden_layer_sizes=(128,64), max_iter=100, random_state=2024)
dtc.fit(X_train, y_train)
y_pred = dtc.predict(X_test)
print('Prec:', precision_score(y_test, y_pred))
print('Rec:', recall_score(y_test, y_pred))
print('F1:', f1_score(y_test, y_pred))

（1）原始推文文本表示建模结果

（2）语义增强后的推文文本表示建模结果

显然，增加了语义信息之后，从F1值的角度来看，一定程度上提升了模型性能（recall提升了5个点，但precision降低了5个点）。当然这个结果并不算得上好，可以进一步通过优化语义增强方式、微调Bert或者调整下游模型来提升整体模型的预测能力（具体可参考kaggle上的开源方案）。

三、完整代码

import pandas as pd
from transformers import BertTokenizer, BertModel
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import precision_score, recall_score, f1_score
import torch
#设置显示窗口数据显示完整
pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 100)
pd.set_option('display.width', 1000)


# 读取数据
df = pd.read_csv('./data/disasterTweets.csv')
print('数据量：', len(df))
print(df.head())
print(df.info())
df = df.fillna('EMPTY')

# 统计位置特征在推文中的出现次数
loc_in_text = []
for loc, twe in zip(df['location'], df['text']):
    if loc in twe:
        loc_in_text.append(1)
    else:
        loc_in_text.append(0)
df['loc_in_text'] = loc_in_text

have_disaster = 0
no_disaster = 0
for lab, lit in zip(df['target'], df['loc_in_text']):
    if lab==lit:
        if lab==0:
            no_disaster += 1
        else:
            have_disaster += 1
print('没有发生灾难的数据量：{}，文中出现location的数据量：{}'.format(df['target'].tolist().count(0), no_disaster))
print('发生灾难的数据量：{}，文中出现location的数据量：{}'.format(df['target'].tolist().count(1), have_disaster))

# 统计关键词特征在推文中的出现次数
keyword_in_text = []
for kw, twe in zip(df['keyword'], df['text']):
    if kw in twe:
        keyword_in_text.append(1)
    else:
        keyword_in_text.append(0)
df['keyword_in_text'] = keyword_in_text

have_keyword = 0
no_keyword = 0
for lab, kit in zip(df['target'], df['keyword_in_text']):
    if lab==kit:
        if lab==0:
            no_keyword += 1
        else:
            have_keyword += 1
print('没有发生灾难的数据量：{}，文中出现keyword的数据量：{}'.format(df['target'].tolist().count(0), no_keyword))
print('发生灾难的数据量：{}，文中出现keyword的数据量：{}'.format(df['target'].tolist().count(1), have_keyword))


# 定义模型权重，可以去HuggingFace找更强大的模型
model_name = 'bert-base-uncased'
# 初始化分词器
tokenizer = BertTokenizer.from_pretrained(model_name)
# 加载模型
model = BertModel.from_pretrained(model_name)

# texts = df['text'].tolist()
texts = df['text'].tolist()
location_info = '. With location:'
keyword_info = 'With keyword:'
texts_with_tips = []
for text, loc, kw, word in zip(texts, loc_in_text, keyword_in_text, df['keyword'].tolist()):
    if loc==1:
        text += location_info+'True.'
    else:
        text += location_info+'False.'
    if kw==1:
        text += keyword_info+word+'True.'+'Keyword:'+word+'.'
    else:
        text += keyword_info+'False.'
    texts_with_tips.append(text)
texts = texts_with_tips

# 定义批量大小
batch_size = 16
# 创建一个空列表来存储所有的句子嵌入
all_sentence_embeddings = []
# 处理数据的批量
for i in range(0, len(texts), batch_size):
    if i % 100 == 0:
        print('processing No.{} sample'.format(i))

    batch_texts = texts[i:i + batch_size]

    # 分词器生成Bert必要的输出格式
    inputs = tokenizer(batch_texts, padding=True, truncation=True, return_tensors="pt")

    # 禁用梯度，打开预测模式
    with torch.no_grad():
        # 预测输出
        outputs = model(**inputs)

    # 取最后一层的token平均向量
    sentence_embeddings = outputs.pooler_output

    # 将当前批量的句子嵌入添加到列表中
    all_sentence_embeddings += sentence_embeddings

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split([list(li) for li in all_sentence_embeddings],
                                                    df['target'].tolist(), stratify=df['target'].tolist(), test_size=0.3, random_state=2024)

# 训练MLP
dtc = MLPClassifier(hidden_layer_sizes=(128,64), max_iter=100, random_state=2024)
dtc.fit(X_train, y_train)
y_pred = dtc.predict(X_test)
print('Prec:', precision_score(y_test, y_pred))
print('Rec:', recall_score(y_test, y_pred))
print('F1:', f1_score(y_test, y_pred))