自然语言处理之文本分类：使用Scikit-Learn进行Logistic Regression建模

于 2025-05-12 21:15:23 发布
阅读量545 收藏 23
点赞数 20
分类专栏： 自然语言（二） 文章标签： 自然语言处理 分类 scikit-learn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhubeibei168/article/details/147880000
版权

自然语言处理之文本分类：使用Scikit-Learn进行Logistic Regression建模

在这里插入图片描述

自然语言处理基础

文本预处理

文本预处理是自然语言处理中至关重要的第一步，它包括多个子步骤，旨在将原始文本转换为机器学习算法可以理解的格式。以下是一些常见的文本预处理技术：

  1. 转换为小写：将所有文本转换为小写，以减少词汇的多样性，避免大小写引起的特征重复。
  2. 去除标点符号：标点符号通常不携带语义信息，去除它们可以减少噪音。
  3. 分词：将文本分割成单词或短语，这是处理文本的基本单位。
  4. 去除停用词：停用词如“的”、“是”、“在”等在文本中频繁出现但不携带太多信息，去除可以减少特征空间。
  5. 词干提取或词形还原：将单词还原为其基本形式，减少词汇的多样性，提高模型的泛化能力。

示例代码

from sklearn.feature_extraction.text import CountVectorizer
from nltk.corpus import stopwords
import nltk
nltk.download('stopwords')
import string

# 原始文本数据
documents = [
    "这是一个关于自然语言处理的教程",
    "自然语言处理非常有趣",
    "教程中包含很多示例"
]

# 文本预处理函数
def preprocess_text(text):
    # 转换为小写
    text = text.lower()
    # 去除标点符号
    text = text.translate(str.maketrans('', '', string.punctuation))
    # 分词
    words = nltk.word_tokenize(text)
    # 去除停用词
    words = [word for word in words if word not in stopwords.words('chinese')]
    # 词形还原（此处省略，因为中文分词后即为基本形式）
    return words

# 预处理文本数据
processed_docs = [' '.join(preprocess_text(doc)) for doc in documents]

# 创建CountVectorizer对象
vectorizer = CountVectorizer()

# 将预处理后的文本转换为词频矩阵
X = vectorizer.fit_transform(processed_docs)

# 输出词频矩阵
print(vectorizer.get_feature_names_out())
print(X.toarray())

词袋模型与TF-IDF

词袋模型是一种将文本转换为数值向量的方法，它忽略了单词的顺序，只关注单词的出现频率。TF-IDF（Term Frequency-Inverse Document Frequency）是一种加权技术，用于评估一个词对一个文档或语料库中的重要程度。TF-IDF值越高，词在文档中的重要性越高。

示例代码

from sklearn.feature_extraction.text import TfidfVectorizer

# 使用TF-IDFVectorizer进行文本向量化
tfidf_vectorizer = TfidfVectorizer()

# 将预处理后的文本转换为TF-IDF矩阵
X_tfidf = tfidf_vectorizer.fit_transform(processed_docs)

# 输出TF-IDF矩阵
print(tfidf_vectorizer.get_feature_names_out())
print(X_tfidf.toarray())

向量化文本数据

向量化文本数据是将文本转换为数值特征的过程，这是机器学习模型可以处理的格式。词袋模型和TF-IDF都是常用的向量化技术，它们将文本转换为向量，其中每个维度对应一个词汇，值表示该词在文档中的频率或TF-IDF值。

示例代码

# 使用CountVectorizer进行词袋模型向量化
bag_of_words = vectorizer.fit_transform(processed_docs)

# 输出词袋模型向量
print(bag_of_words.toarray())

通过上述步骤，我们可以将原始文本数据转换为机器学习模型可以理解的数值向量，为后续的文本分类任务做好准备。接下来，可以使用这些向量数据训练Logistic Regression模型或其他机器学习模型进行文本分类。

Logistic Regression理论

Logistic函数解析

Logistic回归是一种用于解决分类问题的统计学方法，尤其适用于二分类问题。其核心在于使用Logistic函数（也称为Sigmoid函数）将线性模型的输出转换为概率值。Logistic函数定义如下：

f ( z ) = 1 1 + e − z f(z) = \frac{1}{1 + e^{-z}} f(z)=1+e−z1​

其中， z z z是线性模型的输出， f ( z ) f(z) f(z)是经过Logistic函数转换后的概率值。这个函数的特性是将任何实数映射到(0, 1)区间内，非常适合表示事件发生的概率。

代码示例

import numpy as np
import matplotlib.pyplot as plt

# 定义Logistic函数
def logistic_function(z):
    return 1 / (1 + np.exp(-z))

# 生成数据点
z = np.linspace(-10, 10, 100)
f_z = logistic_function(z)

# 绘制Logistic函数图像
plt.figure(figsize=(8, 4))
plt.plot(z, f_z, 'b-', linewidth=2)
plt.title('Logistic函数')
plt.xlabel('z')
plt.ylabel('f(z)')
plt.grid(True)
plt.show()

这段代码定义了Logistic函数，并使用numpy和matplotlib库生成并绘制了函数图像，直观展示了Logistic函数的S形曲线。

最大似然估计

最大似然估计（Maximum Likelihood Estimation, MLE）是一种常用的参数估计方法，用于确定模型参数，使得模型预测结果与实际观测数据最匹配。在Logistic回归中，我们通过最大化似然函数来找到最优参数。

假设我们有 n n n个样本，每个样本的特征向量为 x i x_i xi​，对应的标签为 y i y_i yi​（ y i ∈ { 0 , 1 } y_i \in \{0, 1\} yi​∈{0,1}）。Logistic回归模型的似然函数 L ( θ ) L(\theta) L(θ)可以表示为：

L ( θ ) = ∏ i = 1 n P ( y i ∣ x i , θ ) L(\theta) = \prod_{i=1}^{n} P(y_i|x_i, \theta) L(θ)=i=1∏n​P(yi​∣xi​,θ)

其中， P ( y i ∣ x i , θ ) P(y_i|x_i, \theta) P(yi​∣xi​,θ)是给定参数 θ \theta θ和特征 x i x_i xi​时，标签 y i y_i yi​的概率。对于二分类问题，我们可以将其表示为：

P ( y i ∣ x i , θ ) = { f ( θ T x i ) if  y i = 1 1 − f ( θ T x i ) if  y i = 0 P(y_i|x_i, \theta) = \left\{ \begin{array}{ll} f(\theta^T x_i) & \text{if } y_i = 1 \\ 1 - f(\theta^T x_i) & \text{if } y_i = 0 \end{array} \right. P(yi​∣xi​,θ)={f(θTxi​)1−f(θTxi​)​if yi​=1if yi​=0​

为了简化计算，我们通常对似然函数取对数，得到对数似然函数，然后最大化这个函数。

代码示例

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# 生成模拟数据
X, y = make_classification(n_samples=100, n_features=2, n_classes=2, random_state=42)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建Logistic回归模型
logreg = LogisticRegression(solver='lbfgs')

# 训练模型
logreg.fit(X_train, y_train)

# 输出模型参数
print("模型参数：", logreg.coef_)

这段代码使用sklearn库生成了模拟的二分类数据，然后使用Logistic回归模型进行训练。logreg.coef_输出了模型的参数，这些参数是通过最大似然估计方法找到的。

梯度下降法

梯度下降法是一种迭代优化算法，用于最小化目标函数。在Logistic回归中，我们通常最小化损失函数，即对数似然函数的负值。损失函数 J ( θ ) J(\theta) J(θ)可以表示为：

J ( θ ) = − 1 n ∑ i = 1 n [ y i log ⁡ ( f ( θ T x i ) ) + ( 1 − y i ) log ⁡ ( 1 − f ( θ T x i ) ) ] J(\theta) = -\frac{1}{n} \sum_{i=1}^{n} \left[ y_i \log(f(\theta^T x_i)) + (1 - y_i) \log(1 - f(\theta^T x_i)) \right] J(θ)=−n1​i=1∑n​[yi​log(f(θTxi​))+(1−yi​)log(1−f(θTxi​))]

梯度下降法通过计算损失函数关于参数 θ \theta θ的梯度，然后沿着梯度的反方向更新参数，以逐步减小损失函数的值。

代码示例

import numpy as np

# 定义损失函数
def loss_function(theta, X, y):
    m = X.shape[0]
    h = logistic_function(X @ theta)
    epsilon = 1e-5
    return -1 / m * np.sum(y * np.log(h + epsilon) + (1 - y) * np.log(1 - h + epsilon))

# 定义梯度函数
def gradient_function(theta, X, y):
    m = X.shape[0]
    h = logistic_function(X @ theta)
    return 1 / m * X.T @ (h - y)

# 梯度下降法
def gradient_descent(X, y, theta, alpha, num_iters):
    m = X.shape[0]
    J_history = np.zeros(num_iters)
    for i in range(num_iters):
        theta = theta - alpha * gradient_function(theta, X, y)
        J_history[i] = loss_function(theta, X, y)
    return theta, J_history

# 生成模拟数据
X = np.random.rand(100, 2)
y = np.random.randint(0, 2, size=(100, 1))

# 初始化参数
theta = np.zeros((2, 1))

# 设置学习率和迭代次数
alpha = 0.01
num_iters = 1000

# 运行梯度下降法
theta, J_history = gradient_descent(X, y, theta, alpha, num_iters)

# 输出最终参数和损失函数历史
print("最终参数：", theta)
plt.figure(figsize=(8, 4))
plt.plot(J_history, 'r-', linewidth=2)
plt.title('损失函数历史')
plt.xlabel('迭代次数')
plt.ylabel('损失函数值')
plt.grid(True)
plt.show()

这段代码定义了损失函数和梯度函数，并实现了梯度下降法。通过模拟数据和初始化参数，我们运行了梯度下降法，最终输出了模型参数和损失函数随迭代次数变化的历史图像。这展示了梯度下降法如何逐步优化参数以减小损失函数的值。

以上三个部分详细介绍了Logistic回归的理论基础，包括Logistic函数的解析、最大似然估计原理以及梯度下降法的实现。通过这些理论和代码示例，我们可以更好地理解Logistic回归模型的工作机制，并学会如何使用scikit-learn库进行建模。

Scikit-Learn入门：使用Logistic Regression进行文本分类

数据集加载

在开始文本分类任务之前，首先需要加载数据集。Scikit-Learn提供了多种内置数据集，包括文本数据集，如20_newsgroups，这是一个常用的数据集，包含20个不同类别的新闻组文章。

from sklearn.datasets import fetch_20newsgroups

# 加载数据集，subset='train'表示加载训练集
newsgroups_train = fetch_20newsgroups(subset='train')
# 加载测试集
newsgroups_test = fetch_20newsgroups(subset='test')

# 查看数据集的描述
print(newsgroups_train.DESCR)

# 数据集中的文本数据和标签
print(newsgroups_train.data[0])  # 打印第一条文本数据
print(newsgroups_train.target[0])  # 打印第一条文本数据的标签

数据预处理

文本数据需要转换为数值特征，以便机器学习模型可以处理。这通常通过CountVectorizer或TfidfVectorizer来实现。

from sklearn.feature_extraction.text import TfidfVectorizer

# 初始化TfidfVectorizer
vectorizer = TfidfVectorizer()

# 将文本数据转换为TF-IDF特征
X_train = vectorizer.fit_transform(newsgroups_train.data)
X_test = vectorizer.transform(newsgroups_test.data)

# 获取标签
y_train = newsgroups_train.target
y_test = newsgroups_test.target

模型训练与评估

训练Logistic Regression模型

使用Scikit-Learn的LogisticRegression类来训练模型。

from sklearn.linear_model import LogisticRegression

# 初始化Logistic Regression模型
clf = LogisticRegression(max_iter=1000)

# 训练模型
clf.fit(X_train, y_train)

评估模型

评估模型的性能，通常使用准确率、召回率、F1分数等指标。

from sklearn.metrics import classification_report

# 预测测试集
y_pred = clf.predict(X_test)

# 打印分类报告
print(classification_report(y_test, y_pred, target_names=newsgroups_test.target_names))

交叉验证

交叉验证是一种评估模型性能的方法，它将数据集分为几个部分，轮流将每个部分作为测试集，其余部分作为训练集。

from sklearn.model_selection import cross_val_score

# 使用交叉验证评估模型
scores = cross_val_score(clf, X_train, y_train, cv=5)

# 打印交叉验证的准确率
print("Cross-validation scores: ", scores)
print("Average cross-validation score: ", scores.mean())

通过以上步骤，我们可以使用Scikit-Learn进行Logistic Regression的文本分类任务，包括数据集的加载、预处理、模型训练、评估以及交叉验证。这些步骤是构建任何文本分类模型的基础，通过调整参数和特征工程，可以进一步优化模型的性能。

自然语言处理之文本分类：使用Scikit-Learn进行Logistic Regression建模

Logistic Regression建模

模型初始化

在使用Scikit-Learn进行Logistic Regression建模之前，首先需要导入必要的库，并初始化模型。Logistic Regression是一种广泛应用于二分类问题的统计学方法，它通过拟合数据来预测事件发生的概率。

# 导入所需的库
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics import accuracy_score, confusion_matrix
import pandas as pd

# 读取数据
data = pd.read_csv('data.csv')

# 初始化Logistic Regression模型
model = LogisticRegression(solver='liblinear')

特征选择与工程

文本数据需要转换为数值特征才能被模型处理。这通常通过词袋模型或TF-IDF等方法实现。特征工程还包括选择最相关的特征，以提高模型的性能。

# 使用CountVectorizer进行特征提取
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(data['text'])

# 选择特征
# 假设我们已经通过分析确定了最相关的词汇
relevant_features = ['keyword1', 'keyword2', 'keyword3']
X_reduced = X[:, vectorizer.vocabulary_[word] for word in relevant_features]

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

参数调优

Logistic Regression模型有多个参数可以调整，如正则化类型（penalty）、正则化强度（C）等。使用网格搜索或随机搜索等方法可以找到最佳参数组合。

# 导入GridSearchCV进行参数调优
from sklearn.model_selection import GridSearchCV

# 定义参数网格
param_grid = {
    'penalty': ['l1', 'l2'],
    'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]
}

# 初始化GridSearchCV
grid_search = GridSearchCV(LogisticRegression(solver='liblinear'), param_grid, cv=5)

# 拟合模型
grid_search.fit(X_train, y_train)

# 输出最佳参数
best_params = grid_search.best_params_
print("Best parameters:", best_params)

# 使用最佳参数重新初始化模型
best_model = LogisticRegression(solver='liblinear', penalty=best_params['penalty'], C=best_params['C'])
best_model.fit(X_train, y_train)

模型评估

评估模型的性能是建模过程中的重要步骤。可以使用准确率、混淆矩阵等指标来评估模型。

# 预测测试集
y_pred = best_model.predict(X_test)

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

# 输出混淆矩阵
conf_matrix = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:\n", conf_matrix)

结论

通过上述步骤，我们已经使用Scikit-Learn成功地构建了一个Logistic Regression模型，用于文本分类任务，并通过参数调优和特征工程提高了模型的性能。模型的评估结果表明，它在测试集上具有良好的分类能力。

模型评估与优化

在自然语言处理（NLP）的文本分类任务中，模型的评估与优化是确保模型性能和准确性的关键步骤。本教程将深入探讨如何使用Scikit-Learn库评估和优化Logistic Regression模型。

准确率与混淆矩阵

准确率

准确率（Accuracy）是最直观的评估指标，它衡量模型正确分类的样本数占总样本数的比例。然而，在类别不平衡的数据集中，准确率可能不是最佳的评估指标。

混淆矩阵

混淆矩阵（Confusion Matrix）提供了更详细的分类结果信息，包括真正例（True Positives, TP）、真反例（True Negatives, TN）、假正例（False Positives, FP）和假反例（False Negatives, FN）。

示例代码
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import CountVectorizer

# 加载数据集
newsgroups = fetch_20newsgroups(subset='all')
X, y = newsgroups.data, newsgroups.target

# 文本向量化
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(X)

# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

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

# 预测
y_pred = model.predict(X_test)

# 生成混淆矩阵
cm = confusion_matrix(y_test, y_pred)
print("混淆矩阵:\n", cm)

混淆矩阵帮助我们理解模型在各个类别上的表现，是优化模型的重要工具。

ROC曲线与AUC值

ROC曲线

ROC（Receiver Operating Characteristic）曲线是评估二分类模型性能的常用工具，它以假正例率（False Positive Rate, FPR）为横轴，真正例率（True Positive Rate, TPR）为纵轴绘制。

AUC值

AUC（Area Under the Curve）是ROC曲线下的面积，AUC值越接近1，模型的分类性能越好。

示例代码
from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt

# 生成预测概率
y_scores = model.predict_proba(X_test)[:, 1]

# 计算FPR和TPR
fpr, tpr, _ = roc_curve(y_test, y_scores)

# 计算AUC
roc_auc = auc(fpr, tpr)

# 绘制ROC曲线
plt.figure()
lw = 2
plt.plot(fpr, tpr, color='darkorange', lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic')
plt.legend(loc="lower right")
plt.show()

通过绘制ROC曲线和计算AUC值，我们可以更全面地评估模型的性能。

模型优化策略

参数调优

使用网格搜索（Grid Search）或随机搜索（Random Search）来寻找最佳的模型参数。

示例代码
from sklearn.model_selection import GridSearchCV

# 定义参数网格
param_grid = {'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}

# 创建网格搜索对象
grid = GridSearchCV(LogisticRegression(), param_grid, cv=5, scoring='accuracy')

# 执行网格搜索
grid.fit(X_train, y_train)

# 输出最佳参数
print("最佳参数: ", grid.best_params_)

特征选择

使用特征选择技术，如递归特征消除（Recursive Feature Elimination, RFE）或基于特征重要性的选择，来提高模型性能。

示例代码
from sklearn.feature_selection import RFE

# 创建RFE对象
rfe = RFE(estimator=LogisticRegression(), n_features_to_select=1000)

# 执行特征选择
rfe.fit(X_train, y_train)

# 使用选择后的特征重新训练模型
X_train_rfe = rfe.transform(X_train)
X_test_rfe = rfe.transform(X_test)
model_rfe = LogisticRegression()
model_rfe.fit(X_train_rfe, y_train)

# 预测并评估
y_pred_rfe = model_rfe.predict(X_test_rfe)
print("使用RFE后的准确率: ", model_rfe.score(X_test_rfe, y_test))

集成学习

使用集成学习方法，如Bagging或Boosting，来提高模型的稳定性和预测性能。

示例代码
from sklearn.ensemble import BaggingClassifier

# 创建BaggingClassifier
bagging = BaggingClassifier(base_estimator=LogisticRegression(), n_estimators=10)

# 训练模型
bagging.fit(X_train, y_train)

# 预测并评估
y_pred_bagging = bagging.predict(X_test)
print("使用Bagging后的准确率: ", bagging.score(X_test, y_test))

通过上述方法，我们可以有效地评估和优化Logistic Regression模型在文本分类任务中的性能。在实际应用中，根据具体问题和数据集的特点，可能需要尝试多种评估指标和优化策略，以达到最佳的分类效果。

实战案例分析

情感分析

原理与内容

情感分析（Sentiment Analysis）是自然语言处理中的一项重要任务，旨在从文本中识别和提取情感信息，判断文本的情感倾向，如正面、负面或中性。在本案例中，我们将使用Logistic Regression模型结合Scikit-Learn库进行情感分析。

示例代码与数据样例

假设我们有一组电影评论数据，其中包含评论文本和情感标签（正面或负面）。我们将使用这些数据训练一个Logistic Regression模型。

数据样例
| 评论文本 | 情感标签 |
|----------|----------|
| 这部电影太棒了，我非常喜欢！ | 正面 |
| 故事情节很糟糕，不推荐。 | 负面 |
| 演员表现一般，但特效不错。 | 中性 |
数据预处理
import pandas as pd
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report

# 加载数据
data = pd.read_csv('movie_reviews.csv')
X = data['评论文本']
y = data['情感标签']

# 文本向量化
vectorizer = CountVectorizer()
X_vec = vectorizer.fit_transform(X)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X_vec, y, test_size=0.2, random_state=42)
模型训练与评估
# 创建Logistic Regression模型
model = LogisticRegression()

# 训练模型
model.fit(X_train, y_train)

# 预测测试集
y_pred = model.predict(X_test)

# 输出分类报告
print(classification_report(y_test, y_pred))

描述

在上述代码中，我们首先加载了电影评论数据，并将其评论文本和情感标签分别存储在X和y变量中。接着，我们使用CountVectorizer将文本数据转换为数值特征向量，以便模型可以处理。然后，数据被划分为训练集和测试集，比例为80%和20%。

创建Logistic Regression模型后，我们使用训练集数据进行模型训练。训练完成后，模型对测试集进行预测，预测结果存储在y_pred中。最后，我们使用classification_report函数来评估模型的性能，包括精确度、召回率和F1分数。

主题分类

原理与内容

主题分类（Topic Classification）是将文本分类到预定义的主题类别中。Logistic Regression可以用于多分类问题，因此非常适合进行主题分类任务。

示例代码与数据样例

假设我们有一组新闻文章数据，需要将其分类为“体育”、“科技”、“娱乐”等主题。

数据样例
| 文章标题 | 主题 |
|----------|------|
| 中国女排赢得世界冠军 | 体育 |
| 苹果发布新款iPhone | 科技 |
| 好莱坞明星出席电影节 | 娱乐 |
数据预处理
# 加载数据
data = pd.read_csv('news_articles.csv')
X = data['文章标题']
y = data['主题']

# 文本向量化
vectorizer = CountVectorizer()
X_vec = vectorizer.fit_transform(X)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X_vec, y, test_size=0.2, random_state=42)
模型训练与评估
# 创建Logistic Regression模型
model = LogisticRegression(multi_class='multinomial', solver='lbfgs')

# 训练模型
model.fit(X_train, y_train)

# 预测测试集
y_pred = model.predict(X_test)

# 输出分类报告
print(classification_report(y_test, y_pred))

描述

在主题分类的案例中，我们同样使用CountVectorizer进行文本向量化，然后将数据划分为训练集和测试集。由于主题分类通常涉及多个类别，我们创建Logistic Regression模型时需要指定multi_class='multinomial'和solver='lbfgs'，以支持多分类任务。模型训练和评估的过程与情感分析案例相似。

垃圾邮件检测

原理与内容

垃圾邮件检测（Spam Detection）是识别电子邮件是否为垃圾邮件的任务。Logistic Regression可以基于邮件中的关键词和短语来判断邮件的类别。

示例代码与数据样例

假设我们有一组电子邮件数据，其中包含邮件内容和是否为垃圾邮件的标签。

数据样例
| 邮件内容 | 是否垃圾邮件 |
|----------|--------------|
| 您的订单已发货 | 否 |
| 赢取10000美元，立即点击！ | 是 |
| 会议安排已更新，请查收 | 否 |
数据预处理
# 加载数据
data = pd.read_csv('emails.csv')
X = data['邮件内容']
y = data['是否垃圾邮件']

# 文本向量化
vectorizer = CountVectorizer()
X_vec = vectorizer.fit_transform(X)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X_vec, y, test_size=0.2, random_state=42)
模型训练与评估
# 创建Logistic Regression模型
model = LogisticRegression()

# 训练模型
model.fit(X_train, y_train)

# 预测测试集
y_pred = model.predict(X_test)

# 输出分类报告
print(classification_report(y_test, y_pred))

描述

垃圾邮件检测案例中，我们使用相同的方法进行数据预处理和模型训练。CountVectorizer将邮件内容转换为特征向量，然后使用Logistic Regression模型进行训练。模型的评估同样使用classification_report函数，以检查模型在识别垃圾邮件方面的性能。

以上三个案例展示了如何使用Scikit-Learn库中的Logistic Regression模型进行文本分类任务。通过调整模型参数和优化特征提取方法，可以进一步提高模型的分类准确率。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值