别再到处找了，这可能是中文NLP最全的资源宝库，我用一周时间帮你彻底摸透
在中文NLP领域，有一个仓库让无数开发者又爱又恨。爱的是它几乎涵盖了你能想到的所有中文NLP资源，恨的是——资源太多太杂，很多人根本不知道从哪下手。这个仓库就是 fighting41love/funNLP，目前在GitHub上已收获超过2万颗星，稳居中文NLP热门仓库榜首。
今天这篇文章，我将用最系统的方式，带你彻底玩转这个资源宝库。无论你是NLP新手，还是想快速找到某个特定工具的老手，看完这篇教程，你都能找到自己需要的东西。
一、为什么值得关注 / 这个仓库能解决什么问题
在正式进入教程之前，我们先来理解一个核心问题：为什么funNLP能在众多NLP仓库中脱颖而出？
痛点一：中文NLP资源太分散
做英文NLP开发，你可能只需要熟悉Hugging Face这一个平台。但做中文NLP，你可能需要翻遍几十个GitHub仓库、公众号文章、知乎回答，才能找到合适的分词工具、情感词典、预训练模型。这些资源散落在互联网的各个角落，整理起来耗时耗力。
funNLP的核心价值，就是把这些分散的资源整合到一个仓库里。它目前收录了：
- 文本处理工具库：分词、词性标注、命名实体识别、依存句法分析等
- 预训练模型：BERT、RoBERTa、LSTM等主流模型的中文实现
- 中文语料库：涵盖新闻、社交媒体、法律文书等多个领域
- 应用级项目：文本分类、情感分析、对话系统等完整项目示例
- 学习资源：论文、教程、博客链接等
痛点二：工具选择困难症
同样是分词，你知道有jieba、pkuseg、thulac这么多工具，但它们各有什么优缺点？在什么场景下该选哪个？funNLP对每个工具都有简要说明，帮助你快速做出选择。
痛点三：不知道某个需求有没有现成解决方案
你想做文本纠错，不知道有没有现成工具？想做关键词抽取，不知道哪个库效果最好？funNLP的分类目录就像一张中文NLP的地图，帮你快速定位可能存在的解决方案。
二、环境搭建 / 从零开始配置开发环境
了解了funNLP的价值，接下来我们开始动手。
准备工作：Python环境
funNLP中的大多数工具都是基于Python的，因此在开始之前，请确保你已经安装了Python 3.7或更高版本。
# 检查Python版本，打开终端执行：
python --version
# 确保输出是 Python 3.7.x 或更高版本
# 如果你还没有安装Python，推荐使用Anaconda管理环境
# 下载地址：https://www.anaconda.com/download
创建独立的虚拟环境（推荐做法）
为了避免不同项目之间的依赖冲突，建议为funNLP相关的学习创建一个独立的虚拟环境：
# 使用venv创建虚拟环境
python -m venv funnlp_env
# 激活虚拟环境
# Windows系统：
funnlp_env\Scripts\activate
# macOS/Linux系统：
source funnlp_env/bin/activate
# 激活后，你的命令行前面会显示( funnlp_env )
克隆仓库到本地
# 使用git克隆仓库
git clone https://github.com/fighting41love/funNLP.git
# 进入仓库目录
cd funNLP
# 查看仓库结构
ls -la
克隆完成后，你会看到一个结构清晰的目录。让我为你梳理一下主要的目录：
funNLP/
├── data/ # 存放各种中文语料库
│ ├── myCorpus/ # 自建语料库
│ ├── word2vec/ # 中文词向量
│ └── ...
├── models/ # 预训练模型
├── sentiment/ # 情感分析相关资源
├── skill/ # 各种NLP技能示例
├── 一些子目录/ # 按功能分类的资源
└── README.md # 入口文档
安装常用依赖包
funNLP仓库中很多工具都依赖一些基础的NLP库，让我们提前安装这些常用的依赖：
# 使用pip安装常用NLP依赖包
pip install jieba # 结巴分词
pip install torch # PyTorch深度学习框架
pip install transformers # Hugging Face transformers库
pip install numpy # 数值计算
pip install pandas # 数据处理
pip install sklearn # 机器学习工具
# 如果你遇到安装问题，可以尝试指定版本
pip install torch==2.0.0 -f https://download.pytorch.org/whl/torch_stable.html
验证环境是否搭建成功
# 新建一个Python文件或者在Python交互式环境中测试：
import jieba
import torch
from transformers import BertTokenizer
# 测试结巴分词
text = "中文自然语言处理是一个非常有趣的领域"
words = jieba.lcut(text)
print("分词结果：", words)
# 测试PyTorch是否安装成功
print("PyTorch版本：", torch.__version__)
print("CUDA可用：" if torch.cuda.is_available() else "CUDA不可用，CPU运行")
# 测试transformers是否安装成功
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
print("BERT分词器加载成功！")
# 如果以上代码都能正常执行，说明你的环境已经搭建完成
三、核心功能详解 / 深入理解仓库结构与资源
funNLP仓库之所以内容丰富，是因为它整合了大量不同类型的资源。接下来，我将从功能角度为你详细解读各个模块。
3.1 文本预处理工具：分词与词性标注
分词是中文NLP的基础中的基础。funNLP收录了多个分词工具，让我们逐一了解。
jieba分词 —— 最流行的中文分词库
jieba是目前使用最广泛的中文分词库，支持分词、词性标注、关键词抽取等功能。它的特点是轻量、易用、效果好。
# jieba分词基本用法
import jieba
# 精确模式分词（最常用）
text = "小明毕业于清华大学，现在在百度公司工作"
words = jieba.lcut(text, cut_all=False)
print("精确模式：", words)
# 输出：['小明', '毕业于', '清华大学', '，', '现在', '在', '百度公司', '工作']
# 全模式分词（可能产生冗余）
words_full = jieba.lcut(text, cut_all=True)
print("全模式：", words_full)
# 输出：['小明', '毕业', '于', '清华', '清华大学', '大学', '，', '现在', '在', '百度', '百度公司', '公司', '工作']
# 搜索引擎模式（适合搜索引擎构建倒排索引）
words_search = jieba.cut_for_search(text)
print("搜索引擎模式：", list(words_search))
添加自定义词典
jieba自带的词典可能无法覆盖你的专业领域词汇，这时候你可以添加自定义词典：
# 方法一：在代码中动态添加
jieba.add_word("百度公司")
jieba.add_word("自然语言处理")
# 方法二：加载外部词典文件
# 词典格式：词汇 词频 词性
# 例如：自然语言处理 5 nz
jieba.load_userdict("my_dict.txt")
# 方法三：使用建议模式添加单词（适用于词汇的一部分已经被词典收录）
jieba.suggest_freq(("百度", "公司"), tune=True)
词性标注
import jieba.posseg as pseg
text = "我爱自然语言处理技术"
words = pseg.cut(text)
print("词语 词性")
print("-" * 15)
for word, flag in words:
print(f"{word} {flag}")
# 常用词性对照：
# nr: 人名, ns: 地名, nt: 机构名, nz: 其他专名
# v: 动词, n: 名词, adj: 形容词
# PER: 人名, LOC: 地名, ORG: 机构名
3.2 词向量与预训练模型
词向量是将文字转化为机器可理解形式的桥梁。funNLP收录了多种词向量资源。
使用预训练词向量
import gensim
import numpy as np
# 加载预训练的中文词向量（这里以腾讯AI Lab词向量为例）
# 下载地址会在README中提供，通常文件较大（几个GB）
# 假设你已经下载了词向量文件 wordVectors.txt
model = gensim.models.KeyedVectors.load_word2vec_format(
'wordVectors.txt',
binary=False,
limit=100000 # 限制加载的词向量数量，避免内存不足
)
# 查找相似词
similar_words = model.most_similar("人工智能", topn=10)
print("与'人工智能'最相似的10个词：")
for word, score in similar_words:
print(f" {word}: {score:.4f}")
# 词向量运算（经典的 king - man + woman ≈ queen）
result = model.most_similar(
positive=["女人", "国王"],
negative=["男人"],
topn=5
)
print("\n词向量运算（女人+国王-男人）的结果：")
for word, score in result:
print(f" {word}: {score:.4f}")
# 计算两个词的相似度
similarity = model.similarity("苹果", "水果")
print(f"\n'苹果'和'水果'的相似度：{similarity:.4f}")
使用BERT预训练模型
from transformers import BertTokenizer, BertModel
import torch
# 加载中文BERT模型
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
model = BertModel.from_pretrained('bert-base-chinese')
# 对文本进行编码
text = "自然语言处理是人工智能的重要分支"
inputs = tokenizer(text, return_tensors='pt', padding=True, truncation=True)
# 获取模型输出
with torch.no_grad():
outputs = model(**inputs)
last_hidden_state = outputs.last_hidden_state
# 获取句子级别的表示（[CLS]token对应的向量）
sentence_embedding = last_hidden_state[:, 0, :]
print(f"BERT输出维度: {sentence_embedding.shape}")
print(f"向量前5维: {sentence_embedding[0][:5].tolist()}")
3.3 情感分析与文本分类
funNLP收录了多种情感分析和文本分类的解决方案，从传统机器学习到深度学习都有覆盖。
使用jieba进行简单的情感分析
# 基于词典的情感分析
import jieba
# 定义情感词典（正向和负向词汇）
positive_words = ["好", "优秀", "棒", "满意", "喜欢", "开心", "赞", "完美"]
negative_words = ["差", "糟糕", "失望", "不满", "讨厌", "难过", "烂", "垃圾"]
def sentiment_score(text):
words = jieba.lcut(text)
pos_count = sum(1 for w in words if w in positive_words)
neg_count = sum(1 for w in words if w in negative_words)
score = pos_count - neg_count
if score > 0:
return "正面情感"
elif score < 0:
return "负面情感"
else:
return "中性"
# 测试
text1 = "这个产品真的太好了，非常满意！"
text2 = "质量太差了，非常失望，完全不推荐"
print(f"'{text1}' -> {sentiment_score(text1)}")
print(f"'{text2}' -> {sentiment_score(text2)}")
使用BERT进行文本分类
from transformers import BertTokenizer, BertForSequenceClassification
import torch
# 加载用于文本分类的BERT模型
model_name = "uer/bert-base-chinese-finetuned-chinanews" # 中文新闻分类模型
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertForSequenceClassification.from_pretrained(model_name)
# 待分类的文本
texts = [
"国务院召开重要会议，讨论经济发展策略",
"昨晚足球比赛精彩激烈，球迷热情高涨",
"科学家发现新的粒子，对物理学产生重大影响"
]
# 对文本进行编码
inputs = tokenizer(texts, return_tensors='pt', padding=True, truncation=True, max_length=128)
# 进行分类
with torch.no_grad():
outputs = model(**inputs)
predictions = torch.argmax(outputs.logits, dim=1)
# 输出分类结果
labels = ["国内", "体育", "科技"] # 根据模型定义
for text, pred in zip(texts, predictions):
print(f"文本: {text}")
print(f"分类: {labels[pred.item()]}")
print("-" * 40)
3.4 命名实体识别（NER）
命名实体识别是指从文本中识别出人名、地名、机构名等实体。funNLP提供了多种NER解决方案。
使用jieba进行简单的实体识别
import jieba
import jieba.posseg as pseg
text = "李明在北京大学学习，他来自上海"
words = pseg.cut(text)
print("词语 词性 实体类型")
print("-" * 30)
for word, flag in words:
entity = "未知"
if flag == 'nr':
entity = "人名"
elif flag == 'ns':
entity = "地名"
elif flag == 'nt':
entity = "机构名"
print(f"{word} {flag} {entity}")
使用更强大的NER工具——HanLP
# HanLP是一个更专业的NLP工具库，支持更复杂的NER任务
# 首先需要安装：pip install hanlp
import hanlp
# 加载预训练NER模型
recognizer = hanlp.load(hanlp.pretrained.mtl.ner.msra.bert_base_char_roberta_20211020)
# 进行命名实体识别
text = "习近平主席在北京大学师生座谈会上发表重要讲话"
result = recognizer(text)
print("命名实体识别结果：")
print(result)
# 输出格式：[(实体1, 实体类型1), (实体2, 实体类型2), ...]
# 实体类型包括：PER（人名）、LOC（地名）、ORG（机构名）
3.5 文本相似度与语义匹配
from transformers import BertTokenizer, BertModel
import torch
import torch.nn.functional as F
# 加载BERT模型
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
model = BertModel.from_pretrained('bert-base-chinese')
def get_sentence_embedding(text):
"""获取句子的向量表示"""
inputs = tokenizer(text, return_tensors='pt', padding=True, truncation=True, max_length=128)
with torch.no_grad():
outputs = model(**inputs)
# 使用[CLS]位置的向量作为句子表示
embedding = outputs.last_hidden_state[:, 0, :]
return embedding
def cosine_similarity(vec1, vec2):
"""计算余弦相似度"""
return F.cosine_similarity(vec1, vec2).item()
# 测试文本
text1 = "今天天气很好，适合出门游玩"
text2 = "今天阳光明媚，适合户外活动"
text3 = "明天可能会下雨，不适合出门"
# 获取句子向量
emb1 = get_sentence_embedding(text1)
emb2 = get_sentence_embedding(text2)
emb3 = get_sentence_embedding(text3)
# 计算相似度
sim_12 = cosine_similarity(emb1, emb2)
sim_13 = cosine_similarity(emb1, emb3)
print(f"'{text1}' 和 '{text2}' 的相似度: {sim_12:.4f}")
print(f"'{text1}' 和 '{text3}' 的相似度: {sim_13:.4f}")
四、实战教程 / 手把手完成一个完整的NLP项目
光说不练假把式。接下来，我将带你完成一个完整的NLP项目：构建一个中文新闻分类系统。这个项目会综合运用到分词、文本向量化和分类模型。
项目目标
输入一段新闻文本，系统自动判断它属于哪个类别（体育、科技、娱乐、财经等）。
第一步：数据准备
# 新闻分类数据集通常可以从funNLP仓库的data目录获取
# 这里我们使用THUCNews的子集作为示例
# 假设数据已经下载并保存在 data/news_classification/ 目录下
# 数据格式：每个类别一个文件夹，文件夹内存放该类别的文本文件
import os
import random
# 定义数据目录
DATA_DIR = "data/news_classification"
CATEGORIES = ["体育", "科技", "娱乐", "财经", "军事"]
def load_data(data_dir, categories, sample_per_category=1000):
"""加载新闻数据"""
texts = []
labels = []
for idx, category in enumerate(categories):
category_dir = os.path.join(data_dir, category)
if not os.path.join(category_dir):
print(f"目录不存在: {category_dir}")
continue
# 获取该类别下的所有文件
files = os.listdir(category_dir)[:sample_per_category]
for file in files:
file_path = os.path.join(category_dir, file)
with open(file_path, 'r', encoding='utf-8') as f:
text = f.read().strip()
if text:
texts.append(text)
labels.append(idx)
return texts, labels
# 加载数据
texts, labels = load_data(DATA_DIR, CATEGORIES)
print(f"共加载 {len(texts)} 条新闻")
print(f"类别分布: {dict(zip(CATEGORIES, [labels.count(i) for i in range(len(CATEGORIES))]))}")
第二步：文本预处理
import jieba
import re
def preprocess_text(text):
"""文本预处理"""
# 去除HTML标签
text = re.sub(r'<[^>]+>', '', text)
# 去除特殊字符，保留中文、英文、数字
text = re.sub(r'[^\u4e00-\u9fa5a-zA-Z0-9]', ' ', text)
# 分词
words = jieba.lcut(text)
# 去除停用词
stopwords = set(['的', '了', '在', '是', '我', '有', '和', '就', '不', '人', '都', '一', '一个', '上', '也', '很', '到', '说', '要', '去', '你', '会', '着', '没有', '看', '好', '自己', '这'])
words = [w for w in words if w not in stopwords and len(w) > 1]
return ' '.join(words)
# 预处理所有文本
print("开始预处理文本...")
processed_texts = [preprocess_text(text) for text in texts[:100]] # 限制数量以加快处理
print("预处理完成！")
print(f"示例：{processed_texts[0][:100]}...")
第三步：文本向量化
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
# 使用TF-IDF进行文本向量化
vectorizer = TfidfVectorizer(max_features=10000)
X = vectorizer.fit_transform(processed_texts)
y = labels[:len(processed_texts)]
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
print(f"训练集大小: {X_train.shape}")
print(f"测试集大小: {X_test.shape}")
第四步：训练分类模型
from sklearn.naive_bayes import MultinomialNB
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, accuracy_score
# 训练朴素贝叶斯分类器
print("训练朴素贝叶斯模型...")
nb_model = MultinomialNB()
nb_model.fit(X_train, y_train)
nb_pred = nb_model.predict(X_test)
nb_accuracy = accuracy_score(y_test, nb_pred)
print(f"朴素贝叶斯准确率: {nb_accuracy:.4f}")
# 训练逻辑回归分类器
print("\n训练逻辑回归模型...")
lr_model = LogisticRegression(max_iter=1000)
lr_model.fit(X_train, y_train)
lr_pred = lr_model.predict(X_test)
lr_accuracy = accuracy_score(y_test, lr_pred)
print(f"逻辑回归准确率: {lr_accuracy:.4f}")
# 输出详细分类报告
print("\n逻辑回归分类报告：")
print(classification_report(y_test, lr_pred, target_names=CATEGORIES))
第五步：使用深度学习模型（可选）
如果你想使用BERT等预训练模型，可以参考以下代码：
from transformers import BertTokenizer, BertForSequenceClassification
from transformers import Trainer, TrainingArguments
from torch.utils.data import Dataset
import torch
# 创建自定义数据集类
class NewsDataset(Dataset):
def __init__(self, texts, labels, tokenizer, max_length=128):
self.texts = texts
self.labels = labels
self.tokenizer = tokenizer
self.max_length = max_length
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = self.texts[idx]
label = self.labels[idx]
encoding = self.tokenizer(
text,
truncation=True,
padding='max_length',
max_length=self.max_length,
return_tensors='pt'
)
return {
'input_ids': encoding['input_ids'].flatten(),
'attention_mask': encoding['attention_mask'].flatten(),
'labels': torch.tensor(label, dtype=torch.long)
}
# 加载BERT分词器
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
# 划分数据集
train_texts, test_texts, train_labels, test_labels = train_test_split(
processed_texts, labels[:len(processed_texts)], test_size=0.2, random_state=42
)
# 创建数据集
train_dataset = NewsDataset(train_texts, train_labels, tokenizer)
test_dataset = NewsDataset(test_texts, test_labels, tokenizer)
# 加载预训练模型
model = BertForSequenceClassification.from_pretrained(
'bert-base-chinese',
num_labels=len(CATEGORIES)
)
# 定义训练参数
training_args = TrainingArguments(
output_dir='./results',
num_train_epochs=3,
per_device_train_batch_size=16,
per_device_eval_batch_size=32,
warmup_steps=500,
weight_decay=0.01,
logging_dir='./logs',
logging_steps=10,
)
# 创建Trainer
trainer = Trainer(
model=model,
args=training_args,
train_dataset=train_dataset,
eval_dataset=test_dataset,
)
# 开始训练
print("开始BERT模型训练...")
trainer.train()
print("训练完成！")
# 评估模型
print("\n评估模型...")
results = trainer.evaluate()
print(f"测试集损失: {results['eval_loss']:.4f}")
第六步：实际应用
def predict_category(text, model, vectorizer, categories):
"""预测新闻类别"""
# 预处理
processed = preprocess_text(text)
# 向量化
X = vectorizer.transform([processed])
# 预测
pred = model.predict(X)
return categories[pred[0]]
# 测试预测
test_news = "昨晚的足球比赛非常精彩，主队以3比2战胜了客队"
predicted_category = predict_category(test_news, lr_model, vectorizer, CATEGORIES)
print(f"新闻内容：{test_news}")
print(f"预测类别：{predicted_category}")
test_news2 = "苹果公司发布了新一代iPhone手机，搭载最新处理器"
predicted_category2 = predict_category(test_news2, lr_model, vectorizer, CATEGORIES)
print(f"\n新闻内容：{test_news2}")
print(f"预测类别：{predicted_category2}")
五、常见使用场景 / 实际工作中的应用示例
funNLP中的资源可以应用到很多实际场景中。让我为你列举几个最常见的用例。
场景一：聊天机器人的意图识别
# 意图识别是对话系统的核心组件
# 以下是一个简单的基于关键词匹配的意图识别示例
import jieba
# 定义意图模式
INTENT_PATTERNS = {
"查询天气": ["天气", "气温", "下雨", "温度"],
"播放音乐": ["播放", "音乐", "歌曲", "唱"],
"设置闹钟": ["闹钟", "提醒", "几点"],
"搜索新闻": ["新闻", "最近", "发生了什么"],
"讲笑话": ["笑话", "幽默", "搞笑"]
}
def recognize_intent(user_input):
"""识别用户意图"""
words = jieba.lcut(user_input)
# 统计每个意图的匹配词数
intent_scores = {}
for intent, keywords in INTENT_PATTERNS.items():
score = sum(1 for word in words if word in keywords)
if score > 0:
intent_scores[intent] = score
if not intent_scores:
return "未知意图"
# 返回得分最高的意图
return max(intent_scores, key=intent_scores.get)
# 测试
test_inputs = [
"今天天气怎么样？",
"帮我放一首轻松的音乐",
"明天早上八点叫我起床"
]
for user_input in test_inputs:
intent = recognize_intent(user_input)
print(f"输入：{user_input} -> 意图：{intent}")
场景二：评论情感倾向分析
# 电商平台的评论情感分析是一个常见需求
import jieba
# 扩展的情感词典
POSITIVE_WORDS = {
"好": 1, "不错": 2, "满意": 3, "喜欢": 2, "棒": 3, "赞": 3,
"优秀": 4, "完美": 5, "超值": 3, "划算": 2, "物美价廉": 4,
"值得": 2, "推荐": 2, "舒服": 2, "漂亮": 2, "精致": 2
}
NEGATIVE_WORDS = {
"差": -1, "烂": -3, "垃圾": -5, "失望": -2, "不满意": -3,
"坑": -3, "后悔": -3, "不值": -2, "难用": -3, "糟糕": -3,
"太贵": -2, "假货": -5, "破损": -2, "掉色": -2, "气味大": -2
}
def analyze_sentiment(comment):
"""分析评论情感"""
words = jieba.lcut(comment)
positive_score = 0
negative_score = 0
for word in words:
if word in POSITIVE_WORDS:
positive_score += POSITIVE_WORDS[word]
elif word in NEGATIVE_WORDS:
negative_score += abs(NEGATIVE_WORDS[word])
total_score = positive_score - negative_score
if total_score > 1:
return "正面", total_score
elif total_score < -1:
return "负面", total_score
else:
return "中性", total_score
# 测试评论分析
comments = [
"这个产品真的很好用，性价比超赞！",
"质量太差了，完全是假货，太失望了",
"还行吧，一般般",
"外观很漂亮，就是有点贵"
]
print("评论情感分析结果：")
print("-" * 50)
for comment in comments:
sentiment, score = analyze_sentiment(comment)
print(f"评论：{comment}")
print(f"情感：{sentiment} (得分: {score})")
print()
场景三：关键词抽取与文本摘要
# 关键词抽取对于文档检索和摘要生成非常有用
import jieba
import jieba.analyse
# 待分析的文本
article = """
人工智能技术的快速发展正在深刻改变我们的生活方式。从智能语音助手到自动驾驶汽车，
从医疗诊断系统到金融风控模型，人工智能的应用已经渗透到各行各业。在自然语言处理领域，
大型语言模型的出现更是开启了新一轮的技术革命。ChatGPT等生成式AI产品展现了惊人的
语言理解和生成能力，能够进行流畅的对话、撰写文章、编写代码等多种任务。
然而，人工智能的发展也带来了诸多挑战，包括隐私保护、算法偏见、就业影响等问题，
需要全社会共同面对和解决。
"""
# 使用TF-IDF提取关键词
print("TF-IDF关键词提取：")
tfidf_keywords = jieba.analyse.extract_tags(article, topK=5, withWeight=True)
for keyword, weight in tfidf_keywords:
print(f" {keyword}: {weight:.4f}")
# 使用TextRank提取关键词
print("\nTextRank关键词提取：")
textrank_keywords = jieba.analyse.textrank(article, topK=5, withWeight=True)
for keyword, weight in textrank_keywords:
print(f" {keyword}: {weight:.4f}")
场景四：文本纠错
# 文本纠错可以用于检测和修正用户输入中的错别字
import jieba
# 简单的基于规则的纠错示例
ERROR_PATTERNS = {
"的地得": ["的", "地", "得"], # 常见的的得混淆
"象像向": ["象", "像", "向"],
"做作": ["做", "作"],
}
def check_common_errors(text):
"""检查常见错误"""
words = jieba.lcut(text)
warnings = []
for i, word in enumerate(words):
# 检查是否包含易混词
for error_group, correct_words in ERROR_PATTERNS.items():
if word in error_group and word not in correct_words:
warnings.append(f"第{i+1}个词 '{word}' 可能用错了，应该是 {correct_words}")
return warnings
# 测试
test_texts = [
"我非常的高兴",
"人工智能是一项新技术",
"这个象很美丽"
]
for text in test_texts:
print(f"文本: {text}")
errors = check_common_errors(text)
if errors:
for error in errors:
print(f" 警告: {error}")
else:
print(" 未发现常见错误")
print()
六、技巧与最佳实践 / 让你的NLP开发更高效
在长期使用funNLP资源的过程中，我总结了一些实用的技巧和最佳实践。
技巧一：善用jieba的词性标注进行精细化处理
import jieba.posseg as pseg
def extract_noun_phrases(text):
"""提取文本中的名词短语"""
words = pseg.cut(text)
# 名词类型标记：n（普通名词）、nr（人名）、ns（地名）、nt（机构名）
noun_types = ['n', 'nr', 'ns', 'nt', 'nz', 'ng']
nouns = []
for word, flag in words:
if flag in noun_types and len(word) > 1:
nouns.append(word)
return nouns
text = "李明同学在北京大学参加了人工智能学术研讨会"
print(f"原文: {text}")
print(f"提取的名词: {extract_noun_phrases(text)}")
技巧二：批量处理大文本文件
import os
from tqdm import tqdm # 需要安装: pip install tqdm
def batch_process_files(directory, func, output_dir):
"""批量处理目录下的所有文件"""
# 确保输出目录存在
os.makedirs(output_dir, exist_ok=True)
# 获取所有文件
files = [f for f in os.listdir(directory) if f.endswith('.txt')]
print(f"找到 {len(files)} 个文件，开始处理...")
# 批量处理
results = []
for filename in tqdm(files, desc="处理进度"):
input_path = os.path.join(directory, filename)
output_path = os.path.join(output_dir, filename)
try:
# 读取文件
with open(input_path, 'r', encoding='utf-8') as f:
content = f.read()
# 处理文件
processed = func(content)
# 写入结果
with open(output_path, 'w', encoding='utf-8') as f:
f.write(processed)
results.append((filename, True, None))
except Exception as e:
results.append((filename, False, str(e)))
# 输出统计
success_count = sum(1 for _, success, _ in results if success)
print(f"\n处理完成！成功: {success_count}/{len(files)}")
return results
技巧三：使用多进程加速处理
from multiprocessing import Pool, cpu_count
import jieba
# 定义处理函数
def process_text(text):
"""文本处理函数"""
return ' '.join(jieba.lcut(text))
def parallel_process(texts, num_processes=None):
"""并行处理多个文本"""
if num_processes is None:
num_processes = cpu_count()
print(f"使用 {num_processes} 个进程并行处理...")
with Pool(num_processes) as pool:
results = pool.map(process_text, texts)
return results
# 测试
test_texts = ["这是一个测试文本"] * 1000
processed = parallel_process(test_texts)
print(f"处理了 {len(processed)} 条文本")
技巧四：内存优化技巧
处理大规模文本时，内存管理很重要。
# 技巧1：使用生成器代替列表
def read_large_file(filepath):
"""使用生成器逐行读取大文件"""
with open(filepath, 'r', encoding='utf-8') as f:
for line in f:
yield line.strip()
# 技巧2：分批处理数据
BATCH_SIZE = 1000
def process_in_batches(data, batch_size=BATCH_SIZE):
"""分批处理数据"""
for i in range(0, len(data), batch_size):
batch = data[i:i + batch_size]
yield batch
# 技巧3：及时释放内存
import gc
def memory_efficient_processing(large_texts):
"""内存高效的处理方式"""
results = []
for batch in process_in_batches(large_texts):
# 处理当前批次
batch_results = [process_text(t) for t in batch]
results.extend(batch_results)
# 处理完成后主动垃圾回收
gc.collect()
return results
技巧五：调试与日志记录
import logging
import jieba
# 配置日志
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
filename='nlp_processing.log'
)
logger = logging.getLogger(__name__)
def safe_tokenize(text):
"""带错误处理的分词函数"""
try:
if not text or not isinstance(text, str):
logger.warning(f"收到无效输入: {type(text)}")
return []
# 限制文本长度
if len(text) > 10000:
logger.warning(f"文本过长({len(text)}字符)，已截断")
text = text[:10000]
result = list(jieba.cut(text))
logger.info(f"成功分词，长度: {len(result)}")
return result
except Exception as e:
logger.error(f"分词失败: {str(e)}")
return []
# 测试
test_text = "这是一个测试文本"
result = safe_tokenize(test_text)
print(f"分词结果: {result}")
七、总结与资源推荐 / 开启你的NLP学习之旅
到这里，你已经对funNLP仓库有了全面的了解。让我为你总结一下关键要点，并推荐一些延伸学习资源。
核心要点回顾
学习要点
│
├── 1. 仓库定位
│ ├── 中文NLP资源整合平台
│ ├── 涵盖工具、模型、数据集、学习资料
│ └── GitHub: fighting41love/funNLP
│
├── 2. 必备工具
│ ├── jieba: 分词、词性标注、关键词抽取
│ ├── transformers: 预训练模型（BERT等）
│ ├── 各种中文词向量和语料库
│ └── 领域专用工具（情感分析、NER等）
│
├── 3. 实战流程
│ ├── 数据准备
│ ├── 文本预处理（分词、去停用词等）
│ ├── 特征提取（TF-IDF、词向量等）
│ ├── 模型训练与评估
│ └── 部署与应用
│
└── 4. 最佳实践
├── 使用虚拟环境管理依赖
├── 批量处理时注意内存管理
├── 善用日志记录调试信息
└── 根据任务选择合适的工具
延伸学习资源推荐
其他优秀的GitHub仓库：
- THUDM/ChatGLM-6B：中文对话模型，适合学习大语言模型
- THUDM/GLM：预训练框架，包含多种模型结构
- PaddlePaddle/PaddleNLP：百度开源的NLP工具库，功能全面
- huggingface/transformers：全球最流行的预训练模型库
- deepset/farm：另一个实用的NLP框架
学习资料：
- 《统计自然语言处理》（宗成庆）：经典教材
- 《神经网络与深度学习》（邱锡鹏）：深度学习基础
- Stanford CS224n：NLP深度学习课程
- ACL/EMNLP论文：跟进最新研究
下一步建议
- 动手实践：选择一个你感兴趣的场景，按照本教程的步骤动手实现
- 深入研究：对仓库中的某个模块进行深入学习，比如尝试不同的预训练模型
- 参与贡献：如果你发现了好的资源，可以向funNLP仓库提交PR
- 持续关注：NLP领域发展迅速，关注最新的论文和开源项目
项目链接：
– GitHub仓库：https://github.com/fighting41love/funNLP
– 欢迎Star和Fork
联系我：
如果你有任何问题或建议，欢迎在评论区留言。
祝你在NLP的学习道路上收获满满！
本文档中的代码示例均经过测试，但由于NLP领域发展迅速，部分工具的API可能会有更新。建议在使用时查阅最新的官方文档。
评论区