NLP 任务 on 扎塔-Zata

命名实体识别

Thu, 13 Mar 2025 14:29:48 +0800

基于Transformers的命名实体识别（NER）教程

命名实体识别（NER）是自然语言处理（NLP）中的一项重要任务，目标是从文本中识别出命名实体（如人名、地名、组织名等）并对其进行分类。本教程将使用Hugging Face的transformers库，结合一个中文NER数据集（例如“人民日报NER数据集”），实现一个完整的NER模型训练和预测流程。

Step 1: 导入相关包

首先，我们需要导入必要的库和模块：

import evaluate
from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForTokenClassification, TrainingArguments, Trainer, DataCollatorForTokenClassification

evaluate: 用于加载评估指标，例如seqeval，专门用于NER任务的评估。
datasets: Hugging Face提供的数据集管理工具，用于加载和处理数据。
transformers: 核心库，提供预训练模型、分词器和训练工具。

Step 2: 加载数据集

我们需要一个NER数据集。这里以“人民日报NER数据集”为例，您可以在线加载或从本地加载：

# 在线加载（需要联网）
# ner_datasets = load_dataset("peoples_daily_ner", cache_dir="./data")

# 本地加载（无需联网）
from datasets import DatasetDict
ner_datasets = DatasetDict.load_from_disk("ner_data")
print(ner_datasets)

输出示例：

DatasetDict({
 train: Dataset({...})
 validation: Dataset({...})
 test: Dataset({...})
})

查看数据集内容

查看第一条训练数据：

print(ner_datasets["train"][0])

输出示例：

{'tokens': ['小', '明', '在', '北', '京', '上', '班'], 'ner_tags': [1, 2, 0, 3, 4, 0, 0]}

查看特征信息：

print(ner_datasets["train"].features)

输出示例：

{'tokens': Sequence(feature=Value(dtype='string')),
 'ner_tags': Sequence(feature=ClassLabel(names=['O', 'B-PER', 'I-PER', 'B-LOC', 'I-LOC', ...]))}

获取标签列表：

label_list = ner_datasets["train"].features["ner_tags"].feature.names
print(label_list)

输出示例：

['O', 'B-PER', 'I-PER', 'B-LOC', 'I-LOC', ...]

这里，O表示非实体，B-和I-分别表示实体的开始和内部（BIO标注格式）。

Step 3: 数据集预处理

NER任务需要将文本分词并对齐标签。由于预训练模型的分词器（如BERT）可能会将一个词拆分成多个子词（subword），我们需要确保标签与分词后的结果对齐。

加载分词器

tokenizer = AutoTokenizer.from_pretrained("hfl/chinese-macbert-base")

测试分词器

对于已经分词好的数据（如tokens），需要设置is_split_into_words=True：

res = tokenizer(ner_datasets["train"][0]["tokens"], is_split_into_words=True)
print(res)

输出示例：

{'input_ids': [101, 2207, 6607, 1762, 1266, 7425, 677, 4408, 102], 'token_type_ids': [...], 'attention_mask': [...]}

查看word_ids（每个token对应的原始词索引）：

print(res.word_ids())

输出示例：

[None, 0, 1, 2, 3, 4, 5, 6, None]

None表示特殊token（如[CLS]和[SEP]），其他数字对应原始tokens的索引。

定义预处理函数

我们需要将标签与分词结果对齐：

def process_function(examples):
 tokenized_examples = tokenizer(examples["tokens"], max_length=128, truncation=True, is_split_into_words=True)
 labels = []
 for i, label in enumerate(examples["ner_tags"]):
 word_ids = tokenized_examples.word_ids(batch_index=i)
 label_ids = []
 for word_id in word_ids:
 if word_id is None: # 特殊token用-100标记（会被模型忽略）
 label_ids.append(-100)
 else:
 label_ids.append(label[word_id]) # 对齐原始标签
 labels.append(label_ids)
 tokenized_examples["labels"] = labels
 return tokenized_examples

# 应用到数据集
tokenized_datasets = ner_datasets.map(process_function, batched=True)
print(tokenized_datasets["train"][0])

Step 4: 创建模型

加载预训练模型，并指定标签数量：

model = AutoModelForTokenClassification.from_pretrained("hfl/chinese-macbert-base", num_labels=len(label_list))
print(model.config.num_labels) # 验证标签数量

注意：num_labels必须与label_list长度一致，否则会导致设备错误。

Step 5: 创建评估函数

NER任务通常使用seqeval来计算F1分数等指标：

# 安装seqeval（如果未安装）
# !pip install seqeval

# 加载评估模块
seqeval = evaluate.load("seqeval_metric.py") # 本地加载方式

def eval_metric(pred):
 predictions, labels = pred
 predictions = np.argmax(predictions, axis=-1)

 # 将ID转换为标签，忽略-100
 true_predictions = [[label_list[p] for p, l in zip(pred, label) if l != -100]
 for pred, label in zip(predictions, labels)]
 true_labels = [[label_list[l] for p, l in zip(pred, label) if l != -100]
 for pred, label in zip(predictions, labels)]

 result = seqeval.compute(predictions=true_predictions, references=true_labels, mode="strict", scheme="IOB2")
 return {"f1": result["overall_f1"]}

Step 6: 配置训练参数

args = TrainingArguments(
 output_dir="models_for_ner",
 per_device_train_batch_size=64,
 per_device_eval_batch_size=128,
 evaluation_strategy="epoch",
 save_strategy="epoch",
 metric_for_best_model="f1",
 load_best_model_at_end=True,
 logging_steps=50,
 num_train_epochs=1 # 为了演示设为1，实际可设为3-5
)

Step 7: 创建训练器

trainer = Trainer(
 model=model,
 args=args,
 train_dataset=tokenized_datasets["train"],
 eval_dataset=tokenized_datasets["validation"],
 compute_metrics=eval_metric,
 data_collator=DataCollatorForTokenClassification(tokenizer=tokenizer)
)

DataCollatorForTokenClassification会自动对齐输入和标签，填充到相同长度。

Step 8: 模型训练

trainer.train()

训练完成后，评估测试集：

trainer.evaluate(eval_dataset=tokenized_datasets["test"])

Step 9: 模型预测

使用pipeline进行推理：

from transformers import pipeline

# 设置id2label
model.config.id2label = {idx: label for idx, label in enumerate(label_list)}

# 创建NER pipeline
ner_pipe = pipeline("token-classification", model=model, tokenizer=tokenizer, device=0, aggregation_strategy="simple")

# 预测示例
text = "小明在北京上班"
res = ner_pipe(text)
print(res)

输出示例：

[{'entity_group': 'PER', 'start': 0, 'end': 2, 'word': '小明'},
 {'entity_group': 'LOC', 'start': 3, 'end': 5, 'word': '北京'}]

提取结果：

ner_result = {}
for r in res:
 if r["entity_group"] not in ner_result:
 ner_result[r["entity_group"]] = []
 ner_result[r["entity_group"]].append(text[r["start"]:r["end"]])
print(ner_result)

输出示例：

{'PER': ['小明'], 'LOC': ['北京']}

总结

通过以上步骤，您已经完成了：

数据加载与预处理
模型创建与训练
评估与预测

文本分类

Thu, 13 Mar 2025 10:54:48 +0800

基础概念

什么是文本分类？

文本分类是自然语言处理（NLP）中的一个核心任务，目的是将一段文本分配到一个或多个预定义的类别中。例如：

情感分析：判断文本是“正面”、“负面”还是“中性”。
垃圾邮件检测：判断邮件是“垃圾邮件”还是“正常邮件”。
主题分类：将新闻分为“体育”、“科技”、“政治”等。

文本分类的基本流程

数据准备：收集并标注文本数据。
文本预处理：清洗和转换文本，使其适合机器学习模型。
特征提取：将文本转化为数值形式（如词袋模型或词嵌入）。
模型训练：选择并训练一个分类模型。
评估与优化：测试模型性能并改进。

scikit-learn 框架

步骤详解与代码示例

以下基于 Python，使用 scikit-learn 库实现一个简单的文本分类任务。我们以情感分析为例，区分“正面”和“负面”评论。

1. 数据准备

假设我们有以下小型数据集：

# 示例数据
texts = [
 "这个电影太棒了，值得一看！",
 "服务很好，我很满意。",
 "剧情很无聊，太差了。",
 "浪费时间，完全不好看。"
]
labels = ["正面", "正面", "负面", "负面"] # 对应的标签

2. 文本预处理

中文文本需要分词（英文通常只需小写化和去标点）。我们使用 jieba 库进行中文分词。

import jieba

# 分词函数
def preprocess(text):
 return " ".join(jieba.cut(text)) # 分词后用空格连接

# 应用到数据
processed_texts = [preprocess(text) for text in texts]
print(processed_texts)
# 输出示例: ['这个 电影 太棒了 ， 值得 一看 ！', ...]

3. 特征提取

将文本转化为数值表示。这里使用 TF-IDF（词频-逆文档频率）方法。

from sklearn.feature_extraction.text import TfidfVectorizer

# 初始化 TF-IDF 向量化器
vectorizer = TfidfVectorizer()

# 转换为 TF-IDF 特征矩阵
X = vectorizer.fit_transform(processed_texts)
print(X.shape) # 输出矩阵形状，例如 (4, 15)
print(X[0])
print(X[1])
print(X[2])
print(X[3])

4. 模型训练

使用一个简单的分类器，比如逻辑回归。

from sklearn.linear_model import LogisticRegression

# 初始化模型
model = LogisticRegression()

# 训练模型
model.fit(X, labels)

5. 测试与预测

用训练好的模型预测新文本的情感。

# 新文本
new_texts = ["这个产品真不错！", "太差了，不推荐。"]
new_processed = [preprocess(text) for text in new_texts]
new_X = vectorizer.transform(new_processed)

# 预测
predictions = model.predict(new_X)
print(predictions) # 输出: ['正面', '负面']

6. 评估模型（可选）

如果有更多数据，可以拆分为训练集和测试集，用准确率等指标评估模型。

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 拆分数据
X_train, X_test, y_train, y_test = train_test_split(X, labels, test_size=0.25, random_state=42)

# 训练与预测
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算准确率
print("准确率:", accuracy_score(y_test, y_pred))

进阶建议

更复杂的模型：
- 试试支持向量机（SVM）：from sklearn.svm import SVC
- 或深度学习模型（如 LSTM），使用 TensorFlow 或 PyTorch。
词嵌入：
- 用预训练模型（如 word2vec 或 BERT）替代 TF-IDF，提升效果。
- 对于中文，可以用 transformers 库加载中文 BERT。
中文处理优化：
- 去停用词（如“的”、“了”），提高特征质量。
- 使用更大的数据集，比如从网络爬取评论。

工具与资源

Python 库：scikit-learn, jieba, transformers
数据集：可以从 Kaggle 或中文 NLP 数据集（如微博情感数据集）获取。
学习资料：推荐《Natural Language Processing with Python》或在线课程。

transformers 框架

中文情感分类实例

示例文件：

ChnSentiCorp_htl_all.csv
metric_f1
metric_accuracy

1. 环境准备

确保已安装必要的库。如果没有安装，请运行以下命令：

pip install transformers torch datasets evaluate

evaluate: 用于加载和计算评估指标（如准确率和F1分数）。

2. Step 1: 导入相关包

我们需要导入Transformers的核心模块、datasets用于数据加载，以及torch用于张量操作。

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments, DataCollatorWithPadding, pipeline
from datasets import load_dataset
import torch
import evaluate

3. Step 2: 加载数据集

你提供的代码使用本地CSV文件ChnSentiCorp_htl_all.csv，这是一个中文酒店评论情感分类数据集。我们假设CSV文件格式为：

review: 评论文本。
label: 情感标签（0表示差评，1表示好评）。

加载并过滤掉review为空的数据：

dataset = load_dataset("csv", data_files="./ChnSentiCorp_htl_all.csv", split="train")
dataset = dataset.filter(lambda x: x["review"] is not None)
print(dataset)

输出示例：

Dataset({
 features: ['review', 'label'],
 num_rows: 7766 # 数据行数取决于你的文件
})

4. Step 3: 划分数据集

将数据集分为训练集和测试集（例如90%训练，10%测试）：

datasets = dataset.train_test_split(test_size=0.1)
print(datasets)

输出示例：

DatasetDict({
 train: Dataset({
 features: ['review', 'label'],
 num_rows: 6989
 })
 test: Dataset({
 features: ['review', 'label'],
 num_rows: 777
 })
})

5. Step 4: 数据集预处理

使用hfl/chinese-macbert-large的预训练分词器对中文文本进行分词和编码。

tokenizer = AutoTokenizer.from_pretrained("hfl/chinese-macbert-large")

def process_function(examples):
 tokenized_examples = tokenizer(examples["review"], max_length=32, truncation=True, padding="max_length")
 tokenized_examples["labels"] = examples["label"] # 将"label"重命名为"labels"，Trainer需要此字段
 return tokenized_examples

tokenized_datasets = datasets.map(process_function, batched=True, remove_columns=datasets["train"].column_names)
print(tokenized_datasets)

max_length=32: 限制输入长度为32个token，适合短文本任务，可根据需要调整。
remove_columns: 删除原始列（如review和label），保留分词后的字段（如input_ids、attention_mask和labels）。

输出示例：

DatasetDict({
 train: Dataset({
 features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],
 num_rows: 6989
 })
 test: Dataset({
 features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],
 num_rows: 777
 })
})

6. Step 5: 创建模型

加载hfl/chinese-macbert-large预训练模型，指定分类任务的类别数（2类：差评和好评）。

model = AutoModelForSequenceClassification.from_pretrained("hfl/chinese-macbert-large", num_labels=2)

7. Step 6: 创建评估函数

使用evaluate库加载准确率和F1分数指标，并定义评估函数。

acc_metric = evaluate.load("accuracy") # 如果网络不好，可用本地文件加载
f1_metric = evaluate.load("f1")

def eval_metric(eval_predict):
 predictions, labels = eval_predict
 predictions = predictions.argmax(axis=-1) # 取最大概率的类别
 acc = acc_metric.compute(predictions=predictions, references=labels)
 f1 = f1_metric.compute(predictions=predictions, references=labels, average="binary")
 return {"accuracy": acc["accuracy"], "f1": f1["f1"]}

如果网络不佳，可以下载metric_accuracy.py和metric_f1.py脚本本地加载（从Hugging Face的evaluate库获取）。

8. Step 7: 创建TrainingArguments

定义训练参数，控制训练过程。

train_args = TrainingArguments(
 output_dir="./results", # 模型保存路径
 evaluation_strategy="epoch", # 每轮评估一次
 save_strategy="epoch", # 每轮保存一次
 learning_rate=2e-5, # 学习率
 per_device_train_batch_size=16, # 训练批次大小
 per_device_eval_batch_size=16, # 验证批次大小
 num_train_epochs=3, # 训练轮数
 weight_decay=0.01, # 权重衰减
 logging_dir="./logs", # 日志保存路径
 logging_steps=10, # 每10步记录一次日志
 load_best_model_at_end=True, # 训练结束时加载最佳模型
 metric_for_best_model="f1", # 以F1分数选择最佳模型
)

load_best_model_at_end=True: 确保训练结束后加载在验证集上表现最好的模型。

9. Step 8: 创建Trainer

初始化Trainer，并结合参数冻结和数据整理器。

# 参数冻结（可选，仅微调分类头）
for name, param in model.bert.named_parameters():
 param.requires_grad = False # 冻结BERT部分参数，节省计算资源

# 数据整理器，动态填充批次
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

trainer = Trainer(
 model=model,
 args=train_args,
 train_dataset=tokenized_datasets["train"],
 eval_dataset=tokenized_datasets["test"],
 data_collator=data_collator,
 compute_metrics=eval_metric,
)

参数冻结: 冻结BERT主干，仅训练分类层，适合资源有限或数据量较小的场景。若需全参数微调，可删除冻结代码。
DataCollatorWithPadding: 动态填充批次中的序列长度，提高效率。

10. Step 9: 模型训练与评估

开始训练并在测试集上评估模型。

# 训练模型
trainer.train()

# 评估模型
eval_results = trainer.evaluate(tokenized_datasets["test"])
print("评估结果:", eval_results)

# 预测测试集
predictions = trainer.predict(tokenized_datasets["test"])
print("预测结果示例:", predictions.predictions[:5]) # 查看前5个预测logits

11. Step 10: 模型预测

对新句子进行推理，提供两种方式：手动推理和使用pipeline。

手动推理：

sen = "我觉得这家酒店不错，饭很好吃！"
id2_label = {0: "差评！", 1: "好评！"}
model.eval()
with torch.inference_mode():
 inputs = tokenizer(sen, return_tensors="pt")
 inputs = {k: v.to("cuda") for k, v in inputs.items()} # 如果有GPU
 logits = model(**inputs).logits
 pred = torch.argmax(logits, dim=-1)
 print(f"输入：{sen}\n模型预测结果:{id2_label[pred.item()]}")

使用Pipeline：

model.config.id2label = id2_label # 为pipeline设置标签映射
pipe = pipeline("text-classification", model=model, tokenizer=tokenizer, device=0) # device=0表示GPU
result = pipe(sen)
print(f"输入：{sen}\nPipeline预测结果:{result}")

输出示例：

输入：我觉得这家酒店不错，饭很好吃！
模型预测结果:好评！
Pipeline预测结果:[{'label': '好评！', 'score': 0.95}]

12. 完整代码示例

以下是将所有步骤整合的完整脚本：

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments, DataCollatorWithPadding, pipeline
from datasets import load_dataset
import torch
import evaluate

# Step 2: 加载数据集
dataset = load_dataset("csv", data_files="./ChnSentiCorp_htl_all.csv", split="train")
dataset = dataset.filter(lambda x: x["review"] is not None)

# Step 3: 划分数据集
datasets = dataset.train_test_split(test_size=0.1)

# Step 4: 数据集预处理
tokenizer = AutoTokenizer.from_pretrained("hfl/chinese-macbert-large")
def process_function(examples):
 tokenized_examples = tokenizer(examples["review"], max_length=32, truncation=True, padding="max_length")
 tokenized_examples["labels"] = examples["label"]
 return tokenized_examples
tokenized_datasets = datasets.map(process_function, batched=True, remove_columns=datasets["train"].column_names)

# Step 5: 创建模型
model = AutoModelForSequenceClassification.from_pretrained("hfl/chinese-macbert-large", num_labels=2)

# Step 6: 创建评估函数
acc_metric = evaluate.load("accuracy")
f1_metric = evaluate.load("f1")
def eval_metric(eval_predict):
 predictions, labels = eval_predict
 predictions = predictions.argmax(axis=-1)
 acc = acc_metric.compute(predictions=predictions, references=labels)
 f1 = f1_metric.compute(predictions=predictions, references=labels, average="binary")
 return {"accuracy": acc["accuracy"], "f1": f1["f1"]}

# Step 7: 创建TrainingArguments
train_args = TrainingArguments(
 output_dir="./results",
 evaluation_strategy="epoch",
 save_strategy="epoch",
 learning_rate=2e-5,
 per_device_train_batch_size=16,
 per_device_eval_batch_size=16,
 num_train_epochs=3,
 weight_decay=0.01,
 logging_dir="./logs",
 logging_steps=10,
 load_best_model_at_end=True,
 metric_for_best_model="f1",
)

# Step 8: 创建Trainer
for name, param in model.bert.named_parameters():
 param.requires_grad = False # 参数冻结
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
trainer = Trainer(
 model=model,
 args=train_args,
 train_dataset=tokenized_datasets["train"],
 eval_dataset=tokenized_datasets["test"],
 data_collator=data_collator,
 compute_metrics=eval_metric,
)

# Step 9: 模型训练与评估
trainer.train()
eval_results = trainer.evaluate(tokenized_datasets["test"])
print("评估结果:", eval_results)

# Step 10: 模型预测
sen = "我觉得这家酒店不错，饭很好吃！"
id2_label = {0: "差评！", 1: "好评！"}
model.eval()
with torch.inference_mode():
 inputs = tokenizer(sen, return_tensors="pt")
 inputs = {k: v.to("cuda") for k, v in inputs.items()}
 logits = model(**inputs).logits
 pred = torch.argmax(logits, dim=-1)
 print(f"输入：{sen}\n模型预测结果:{id2_label[pred.item()]}")

# 使用Pipeline预测
model.config.id2label = id2_label
pipe = pipeline("text-classification", model=model, tokenizer=tokenizer, device=0)
print(f"Pipeline预测结果:{pipe(sen)}")

补充说明

数据集下载: 如果没有ChnSentiCorp_htl_all.csv，可从网上下载（如https://github.com/pengming617/bert_classification）。
硬件需求: chinese-macbert-large模型较大，建议使用GPU运行。若无GPU，可减小max_length或使用更小的模型（如bert-base-chinese）。
参数调整: 若数据量较大，可取消参数冻结（删除requires_grad = False），进行全参数微调。
保存模型: 训练完成后，模型会自动保存到./results目录，可用trainer.save_model()手动保存。