Python自然语言处理实战：从基础到应用

关注

原创最新推荐文章于 2026-09-17 14:05:37 发布 1.2w 阅读 AI 写同款· GEO 优化 ›

《Python机器学习基础教程》第八章自然语言处理（NLP）基础8.16 深度实战：依存句法分析在NLP中的应用实例与语义理解依存句法分析是一种解析句子结构的方法，它将句子中的每个词视为一个节点，并通过有向边表示词与词之间的依存关系。依存关系通常包括主谓关系、动宾关系、修饰关系等。依存树是一个有向无环图（DAG），其中根节点通常是句子的主要动词或名词。阅读详情

Python自然语言处理实战：从基础到应用

前言

大家好，我是第一程序员（名字大，人很菜）。作为一个非科班转码、正在学习Rust和Python的萌新，最近我开始学习自然语言处理（NLP）。今天我想分享一下Python自然语言处理的实战经验，从基础到应用。

一、NLP基础

1.1 NLP的基本概念

自然语言处理：研究如何让计算机理解和处理人类语言的学科
词法分析：将文本分解为词或词素
句法分析：分析句子的语法结构
语义分析：理解文本的含义
语用分析：理解文本在特定语境下的意义

1.2 NLP的应用场景

文本分类：情感分析、垃圾邮件检测、新闻分类等
命名实体识别：识别文本中的实体，如人名、地名、组织机构等
机器翻译：将一种语言翻译成另一种语言
问答系统：回答用户的问题
文本生成：生成自然语言文本

二、环境搭建

2.1 安装必要的库

# 安装NLTK
pip install nltk

# 安装SpaCy
pip install spacy

# 下载SpaCy模型
python -m spacy download en_core_web_sm

# 安装Transformers
pip install transformers

# 安装其他库
pip install numpy pandas matplotlib

三、基础操作

3.1 文本预处理

使用NLTK进行文本预处理：

import nltk
from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer, WordNetLemmatizer

# 下载必要的资源
nltk.download('punkt')
nltk.download('stopwords')
nltk.download('wordnet')

# 示例文本
text = "Hello, world! This is a sample text for natural language processing."

# 分词
words = word_tokenize(text)
print("分词结果:", words)

# 分句
sentences = sent_tokenize(text)
print("分句结果:", sentences)

# 去除停用词
stop_words = set(stopwords.words('english'))
filtered_words = [word for word in words if word.lower() not in stop_words]
print("去除停用词:", filtered_words)

# 词干提取
stemmer = PorterStemmer()
stemmed_words = [stemmer.stem(word) for word in filtered_words]
print("词干提取:", stemmed_words)

# 词形还原
lemmatizer = WordNetLemmatizer()
lemmatized_words = [lemmatizer.lemmatize(word) for word in filtered_words]
print("词形还原:", lemmatized_words)

3.2 词性标注

使用SpaCy进行词性标注：

import spacy

# 加载模型
nlp = spacy.load('en_core_web_sm')

# 处理文本
doc = nlp("Hello, world! This is a sample text for natural language processing.")

# 词性标注
for token in doc:
    print(f"{token.text} - {token.pos_} - {token.dep_}")

3.3 命名实体识别

使用SpaCy进行命名实体识别：

import spacy

# 加载模型
nlp = spacy.load('en_core_web_sm')

# 处理文本
doc = nlp("Apple is looking at buying U.K. startup for $1 billion")

# 命名实体识别
for ent in doc.ents:
    print(f"{ent.text} - {ent.label_}")

四、实战项目：情感分析

4.1 数据准备

使用IMDB数据集：

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer

# 加载数据集
# 假设我们有一个包含电影评论和情感标签的数据集
data = pd.read_csv('imdb.csv')

# 查看数据
data.head()

# 分割数据集
X_train, X_test, y_train, y_test = train_test_split(data['review'], data['sentiment'], test_size=0.2, random_state=42)

# 特征提取
vectorizer = TfidfVectorizer(max_features=5000)
X_train_vectorized = vectorizer.fit_transform(X_train)
X_test_vectorized = vectorizer.transform(X_test)

4.2 模型训练

使用逻辑回归进行情感分析：

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

# 训练模型
model = LogisticRegression()
model.fit(X_train_vectorized, y_train)

# 预测
y_pred = model.predict(X_test_vectorized)

# 评估
print(f"准确率: {accuracy_score(y_test, y_pred):.2f}")
print(classification_report(y_test, y_pred))

4.3 使用深度学习进行情感分析

使用Transformer进行情感分析：

from transformers import BertTokenizer, BertForSequenceClassification
import torch
from torch.utils.data import DataLoader, Dataset

# 自定义数据集类
class SentimentDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length):
        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'].squeeze(),
            'attention_mask': encoding['attention_mask'].squeeze(),
            'label': torch.tensor(label)
        }

# 加载预训练模型和分词器
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)

# 创建数据集
train_dataset = SentimentDataset(X_train.tolist(), y_train.tolist(), tokenizer, max_length=128)
test_dataset = SentimentDataset(X_test.tolist(), y_test.tolist(), tokenizer, max_length=128)

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# 训练模型
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)

optimizer = torch.optim.Adam(model.parameters(), lr=2e-5)
criterion = torch.nn.CrossEntropyLoss()

epochs = 3
for epoch in range(epochs):
    model.train()
    running_loss = 0.0
    
    for batch in train_loader:
        input_ids = batch['input_ids'].to(device)
        attention_mask = batch['attention_mask'].to(device)
        labels = batch['label'].to(device)
        
        optimizer.zero_grad()
        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
    
    print(f'Epoch {epoch+1}, Loss: {running_loss/len(train_loader):.3f}')

# 评估模型
model.eval()
correct = 0
total = 0

with torch.no_grad():
    for batch in test_loader:
        input_ids = batch['input_ids'].to(device)
        attention_mask = batch['attention_mask'].to(device)
        labels = batch['label'].to(device)
        
        outputs = model(input_ids, attention_mask=attention_mask)
        _, predicted = torch.max(outputs.logits, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'测试准确率: {100 * correct / total:.2f}%')

五、实战项目：文本生成

5.1 使用GPT-2进行文本生成

from transformers import GPT2Tokenizer, GPT2LMHeadModel

# 加载预训练模型和分词器
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
model = GPT2LMHeadModel.from_pretrained('gpt2')

# 生成文本
prompt = "Once upon a time"
inputs = tokenizer(prompt, return_tensors='pt')

# 生成文本
outputs = model.generate(
    inputs['input_ids'],
    max_length=100,
    num_return_sequences=1,
    no_repeat_ngram_size=2,
    do_sample=True,
    temperature=0.7
)

# 解码生成的文本
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(generated_text)