1. 什么是机器学习？ #

1.1 生活中的例子 #

想象一下，你要教一个小朋友识别猫和狗：

• 你给他看很多猫和狗的照片，告诉他"这是猫"、"这是狗"
• 经过一段时间的学习，小朋友就能自己识别新的猫和狗的照片了

这就是机器学习的基本思想：让计算机通过大量数据学习规律，然后能够对新的数据做出预测或分类。

1.2 机器学习的类型 #

1. 监督学习：有标准答案的学习

   • 分类：预测类别（如：这是猫还是狗？）
   • 回归：预测数值（如：明天温度是多少度？）

2. 无监督学习：没有标准答案的学习

   • 聚类：将相似的数据分组（如：哪些客户行为相似？）

3. 强化学习：通过试错学习（如：游戏AI）

1.3 为什么需要 Scikit-learn？ #

Scikit-learn（简称 sklearn）是 Python 中最流行的机器学习库，它：

• 简单易用：几行代码就能完成机器学习任务
• 功能全面：包含各种机器学习算法
• 文档完善：有详细的教程和示例
• 免费开源：可以自由使用

2. 前置知识 #

在学习 Scikit-learn 之前，我们需要了解一些 Python 基础知识。

2.1 NumPy 基础 #

NumPy 是 Python 中用于数值计算的库，Scikit-learn 使用 NumPy 数组来存储数据。

# 导入 NumPy 库
import numpy as np

# 创建一维数组（向量）
arr1d = np.array([1, 2, 3, 4, 5])
print(f"一维数组: {arr1d}")
print(f"形状: {arr1d.shape}")

# 创建二维数组（矩阵）
# 每行是一个样本，每列是一个特征
arr2d = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])
print(f"\n二维数组:")
print(arr2d)
print(f"形状: {arr2d.shape}")  # (3, 3) 表示3行3列

# 生成随机数组
random_arr = np.random.random((5, 3))  # 5行3列的随机数
print(f"\n随机数组形状: {random_arr.shape}")

# 数组的基本操作
print(f"\n数组求和: {arr1d.sum()}")
print(f"数组平均值: {arr1d.mean()}")
print(f"数组最大值: {arr1d.max()}")

2.2 什么是特征和标签？ #

在机器学习中：

• 特征（Features）：输入数据，用来预测的信息（如：身高、体重、年龄）
• 标签（Labels）：输出结果，我们要预测的目标（如：是否喜欢、价格多少）

# 导入 NumPy
import numpy as np

# 示例：根据身高和体重预测是否喜欢运动
# 特征 X：身高（cm）和体重（kg）
X = np.array([
    [170, 65],  # 样本1：身高170cm，体重65kg
    [160, 55],  # 样本2：身高160cm，体重55kg
    [180, 75],  # 样本3：身高180cm，体重75kg
    [165, 60]   # 样本4：身高165cm，体重60kg
])

# 标签 y：是否喜欢运动（1表示喜欢，0表示不喜欢）
y = np.array([1, 0, 1, 0])

print(f"特征 X 的形状: {X.shape}")  # (4, 2) 表示4个样本，每个样本2个特征
print(f"标签 y 的形状: {y.shape}")  # (4,) 表示4个标签
print(f"\n特征 X:")
print(X)
print(f"\n标签 y: {y}")

3. 安装 Scikit-learn #

3.1 安装方法 #

# 使用 pip 安装
pip install scikit-learn

# 或者使用 conda 安装
conda install scikit-learn

3.2 验证安装 #

# 导入 scikit-learn
import sklearn

# 查看版本
print(f"Scikit-learn 版本: {sklearn.__version__}")

# 测试基本功能
from sklearn.datasets import load_iris
iris = load_iris()
print(f"\n成功加载鸢尾花数据集，样本数: {len(iris.data)}")

4. 机器学习示例 #

让我们从一个最简单的例子开始，了解 Scikit-learn 的基本使用流程。

4.1 鸢尾花分类 #

# 导入必要的库
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report

# 步骤1：加载数据
# 鸢尾花数据集是 Scikit-learn 内置的经典数据集
# 包含150个样本，每个样本有4个特征（花萼长度、花萼宽度、花瓣长度、花瓣宽度）
# 目标是将花分为3类：山鸢尾、变色鸢尾、维吉尼亚鸢尾
iris = load_iris()
X = iris.data  # 特征（150个样本，每个4个特征）
y = iris.target  # 标签（150个标签，0、1、2分别代表3种花）

print(f"数据形状: {X.shape}")
print(f"标签形状: {y.shape}")
print(f"特征名称: {iris.feature_names}")
print(f"类别名称: {iris.target_names}")

# 步骤2：划分训练集和测试集
# 将数据分为两部分：训练集（用来训练模型）和测试集（用来评估模型）
# test_size=0.2 表示20%的数据作为测试集，80%作为训练集
# random_state=42 设置随机种子，确保每次划分结果相同
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print(f"\n训练集大小: {X_train.shape[0]}")
print(f"测试集大小: {X_test.shape[0]}")

# 步骤3：数据预处理
# 标准化：将数据转换为均值为0、标准差为1的分布
# 这有助于提高模型的性能
scaler = StandardScaler()
# 在训练集上拟合（计算均值和标准差）
X_train_scaled = scaler.fit_transform(X_train)
# 在测试集上应用相同的转换（使用训练集的均值和标准差）
X_test_scaled = scaler.transform(X_test)

# 步骤4：创建模型
# KNeighborsClassifier：K近邻分类器
# n_neighbors=3 表示使用最近的3个邻居来做预测
clf = KNeighborsClassifier(n_neighbors=3)

# 步骤5：训练模型
# fit 方法用于训练模型，让模型学习训练数据的规律
clf.fit(X_train_scaled, y_train)

# 步骤6：预测
# predict 方法用于对新数据进行预测
y_pred = clf.predict(X_test_scaled)

# 步骤7：评估模型
# accuracy_score 计算准确率（预测正确的比例）
accuracy = accuracy_score(y_test, y_pred)
print(f"\n模型准确率: {accuracy:.4f}")

# classification_report 显示详细的分类报告
print("\n分类报告:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

4.2 Scikit-learn 的统一接口 #

所有 Scikit-learn 的模型都遵循相同的接口：

1. 创建模型：model = SomeModel()
2. 训练模型：model.fit(X_train, y_train)
3. 预测：y_pred = model.predict(X_test)
4. 评估：score = model.score(X_test, y_test)

5. 数据预处理 #

5.1 为什么需要数据预处理？ #

原始数据通常不能直接用于机器学习，需要：

• 标准化：不同特征的数值范围可能差异很大
• 编码：将文字转换为数字
• 处理缺失值：填补或删除缺失的数据

5.2 标准化（StandardScaler） #

标准化将数据转换为均值为0、标准差为1的分布。

# 导入必要的库
import numpy as np
from sklearn.preprocessing import StandardScaler

# 创建示例数据
# 假设有两个特征：身高（cm，范围150-200）和体重（kg，范围50-100）
X = np.array([
    [170, 65],
    [160, 55],
    [180, 75],
    [165, 60]
])

print("原始数据:")
print(X)
print(f"均值: {X.mean(axis=0)}")
print(f"标准差: {X.std(axis=0)}")

# 创建标准化器
scaler = StandardScaler()

# 拟合并转换数据
# fit_transform 先计算均值和标准差，然后转换数据
X_scaled = scaler.fit_transform(X)

print("\n标准化后的数据:")
print(X_scaled)
print(f"均值: {X_scaled.mean(axis=0)}")  # 应该接近 [0, 0]
print(f"标准差: {X_scaled.std(axis=0)}")  # 应该接近 [1, 1]

5.3 归一化（MinMaxScaler） #

归一化将数据缩放到指定范围（通常是0到1）。

# 导入必要的库
import numpy as np
from sklearn.preprocessing import MinMaxScaler

# 创建示例数据
X = np.array([
    [170, 65],
    [160, 55],
    [180, 75],
    [165, 60]
])

print("原始数据:")
print(X)
print(f"最小值: {X.min(axis=0)}")
print(f"最大值: {X.max(axis=0)}")

# 创建归一化器
# feature_range=(0, 1) 表示缩放到0到1之间
minmax_scaler = MinMaxScaler(feature_range=(0, 1))

# 拟合并转换数据
X_normalized = minmax_scaler.fit_transform(X)

print("\n归一化后的数据:")
print(X_normalized)
print(f"最小值: {X_normalized.min(axis=0)}")  # 应该接近 [0, 0]
print(f"最大值: {X_normalized.max(axis=0)}")  # 应该接近 [1, 1]

5.4 标签编码（LabelEncoder） #

将文字标签转换为数字。

# 导入必要的库
from sklearn.preprocessing import LabelEncoder

# 创建示例数据（文字标签）
y_text = ['猫', '狗', '猫', '鸟', '狗', '猫']

print("原始标签:")
print(y_text)

# 创建标签编码器
label_encoder = LabelEncoder()

# 拟合并转换
# fit_transform 先学习所有不同的标签，然后转换为数字
y_encoded = label_encoder.fit_transform(y_text)

print("\n编码后的标签:")
print(y_encoded)

# 查看编码映射
print("\n编码映射:")
for label, encoded in zip(label_encoder.classes_, range(len(label_encoder.classes_))):
    print(f"{label} -> {encoded}")

# 反向转换（将数字转换回文字）
y_decoded = label_encoder.inverse_transform(y_encoded)
print(f"\n反向转换: {y_decoded}")

5.5 独热编码（OneHotEncoder） #

独热编码将类别特征转换为二进制向量。

# 导入必要的库
import numpy as np
from sklearn.preprocessing import OneHotEncoder

# 创建示例数据（类别特征）
# 假设有3个类别：'红色'、'绿色'、'蓝色'
categories = np.array([['红色'], ['绿色'], ['红色'], ['蓝色'], ['绿色']])

print("原始类别数据:")
print(categories)

# 创建独热编码器
# sparse=False 表示返回密集矩阵（而不是稀疏矩阵）
encoder = OneHotEncoder(sparse=False)

# 拟合并转换
# fit_transform 先学习所有不同的类别，然后转换为独热编码
encoded = encoder.fit_transform(categories)

print("\n独热编码后的数据:")
print(encoded)
print(f"形状: {encoded.shape}")  # (5, 3) 表示5个样本，3个类别

# 查看类别名称
print(f"\n类别名称: {encoder.categories_}")

6. 分类算法 #

6.1 K近邻分类器（KNeighborsClassifier） #

K近邻算法：根据最近的K个邻居的类别来预测新样本的类别。

# 导入必要的库
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report

# 生成示例数据
# make_classification 用于生成分类数据集
# n_samples=200 生成200个样本
# n_features=4 每个样本4个特征
# n_classes=3 3个类别
# random_state=42 设置随机种子
X, y = make_classification(
    n_samples=200,
    n_features=4,
    n_classes=3,
    n_informative=4,
    n_redundant=0,
    random_state=42
)

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

# 标准化数据
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 创建K近邻分类器
# n_neighbors=5 表示使用最近的5个邻居
clf = KNeighborsClassifier(n_neighbors=5)

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

# 预测
y_pred = clf.predict(X_test_scaled)

# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy:.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred))

6.2 决策树分类器（DecisionTreeClassifier） #

决策树通过一系列规则来做决策，就像流程图一样。

# 导入必要的库
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report

# 加载鸢尾花数据集
iris = load_iris()
X, y = iris.data, iris.target

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

# 创建决策树分类器
# max_depth=3 限制树的最大深度，防止过拟合
clf = DecisionTreeClassifier(max_depth=3, random_state=42)

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

# 预测
y_pred = clf.predict(X_test)

# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy:.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

6.3 随机森林分类器（RandomForestClassifier） #

随机森林是多个决策树的组合，通过投票来做决策。

# 导入必要的库
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# 加载数据
iris = load_iris()
X, y = iris.data, iris.target

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

# 创建随机森林分类器
# n_estimators=100 表示使用100棵决策树
# random_state=42 设置随机种子
clf = RandomForestClassifier(n_estimators=100, random_state=42)

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

# 预测
y_pred = clf.predict(X_test)

# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy:.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

# 查看特征重要性
# 随机森林可以告诉我们哪些特征最重要
importances = clf.feature_importances_
print("\n特征重要性:")
for i, (name, importance) in enumerate(zip(iris.feature_names, importances)):
    print(f"{name}: {importance:.4f}")

6.4 朴素贝叶斯分类器（GaussianNB） #

朴素贝叶斯基于概率来做分类，假设特征之间相互独立。

# 导入必要的库
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, classification_report

# 加载数据
iris = load_iris()
X, y = iris.data, iris.target

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

# 创建朴素贝叶斯分类器
clf = GaussianNB()

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

# 预测
y_pred = clf.predict(X_test)

# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy:.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

7. 回归算法 #

7.1 线性回归（LinearRegression） #

线性回归用于预测连续数值，假设特征和目标之间存在线性关系。

# 导入必要的库
import numpy as np
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# 生成回归数据
# make_regression 用于生成回归数据集
# n_samples=100 生成100个样本
# n_features=1 每个样本1个特征
# noise=10 添加噪声
# random_state=42 设置随机种子
X, y = make_regression(
    n_samples=100,
    n_features=1,
    noise=10,
    random_state=42
)

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

# 创建线性回归模型
reg = LinearRegression()

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

# 预测
y_pred = reg.predict(X_test)

# 评估
# mean_squared_error 计算均方误差（越小越好）
mse = mean_squared_error(y_test, y_pred)
# r2_score 计算决定系数（越接近1越好，表示模型解释了多少方差）
r2 = r2_score(y_test, y_pred)

print(f"均方误差: {mse:.4f}")
print(f"决定系数 (R²): {r2:.4f}")
print(f"\n回归系数: {reg.coef_[0]:.4f}")
print(f"截距: {reg.intercept_:.4f}")

7.2 决策树回归（DecisionTreeRegressor） #

决策树也可以用于回归，预测连续数值。

# 导入必要的库
import numpy as np
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error, r2_score

# 生成回归数据
X, y = make_regression(
    n_samples=100,
    n_features=2,
    noise=10,
    random_state=42
)

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

# 创建决策树回归器
# max_depth=5 限制树的最大深度
reg = DecisionTreeRegressor(max_depth=5, random_state=42)

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

# 预测
y_pred = reg.predict(X_test)

# 评估
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"均方误差: {mse:.4f}")
print(f"决定系数 (R²): {r2:.4f}")

8. 模型评估 #

8.1 分类评估指标 #

# 导入必要的库
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    confusion_matrix, classification_report
)

# 加载数据
iris = load_iris()
X, y = iris.data, iris.target

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

# 训练模型
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

# 预测
y_pred = clf.predict(X_test)

# 准确率：预测正确的比例
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy:.4f}")

# 精确率：预测为正例中真正为正例的比例
precision = precision_score(y_test, y_pred, average='weighted')
print(f"精确率: {precision:.4f}")

# 召回率：真正例中被正确预测的比例
recall = recall_score(y_test, y_pred, average='weighted')
print(f"召回率: {recall:.4f}")

# F1分数：精确率和召回率的调和平均
f1 = f1_score(y_test, y_pred, average='weighted')
print(f"F1分数: {f1:.4f}")

# 混淆矩阵：显示每个类别的预测情况
cm = confusion_matrix(y_test, y_pred)
print("\n混淆矩阵:")
print(cm)

# 分类报告：显示详细的评估指标
print("\n分类报告:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

8.2 回归评估指标 #

# 导入必要的库
import numpy as np
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

# 生成回归数据
X, y = make_regression(
    n_samples=100,
    n_features=2,
    noise=10,
    random_state=42
)

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

# 训练模型
reg = LinearRegression()
reg.fit(X_train, y_train)

# 预测
y_pred = reg.predict(X_test)

# 均方误差（MSE）：预测值与真实值差的平方的平均值
mse = mean_squared_error(y_test, y_pred)
print(f"均方误差 (MSE): {mse:.4f}")

# 均方根误差（RMSE）：MSE的平方根
rmse = np.sqrt(mse)
print(f"均方根误差 (RMSE): {rmse:.4f}")

# 平均绝对误差（MAE）：预测值与真实值差的绝对值的平均值
mae = mean_absolute_error(y_test, y_pred)
print(f"平均绝对误差 (MAE): {mae:.4f}")

# 决定系数（R²）：模型解释的方差比例，越接近1越好
r2 = r2_score(y_test, y_pred)
print(f"决定系数 (R²): {r2:.4f}")

8.3 交叉验证 #

交叉验证将数据分成多份，轮流用其中一份作为测试集，其他作为训练集。

# 导入必要的库
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score, KFold
from sklearn.ensemble import RandomForestClassifier

# 加载数据
iris = load_iris()
X, y = iris.data, iris.target

# 创建模型
clf = RandomForestClassifier(n_estimators=100, random_state=42)

# 交叉验证
# cv=5 表示5折交叉验证（将数据分成5份）
# scoring='accuracy' 使用准确率作为评估指标
scores = cross_val_score(clf, X, y, cv=5, scoring='accuracy')

print(f"交叉验证分数: {scores}")
print(f"平均分数: {scores.mean():.4f}")
print(f"标准差: {scores.std():.4f}")

9. 数据分割 #

9.1 训练集和测试集 #

将数据分为训练集（用于训练模型）和测试集（用于评估模型）。

# 导入必要的库
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# 加载数据
iris = load_iris()
X, y = iris.data, iris.target

# 划分训练集和测试集
# test_size=0.2 表示20%的数据作为测试集
# random_state=42 设置随机种子，确保结果可重复
# stratify=y 保持类别比例（确保训练集和测试集中各类别比例相同）
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

print(f"原始数据大小: {len(X)}")
print(f"训练集大小: {len(X_train)}")
print(f"测试集大小: {len(X_test)}")
print(f"\n训练集类别分布:")
unique, counts = np.unique(y_train, return_counts=True)
for u, c in zip(unique, counts):
    print(f"  类别 {u}: {c} 个样本")

10. 文本分类 #

下面是一个完整的文本分类示例，展示如何使用 Scikit-learn 进行文本分类。

# 导入必要的库
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score, classification_report

# 准备文本数据
# 假设我们要将文本分为两类：'科技' 和 '体育'
texts = [
    # 科技类
    '人工智能是未来的趋势',
    '机器学习改变了我们的生活',
    '深度学习在图像识别中表现出色',
    'Python是数据科学的首选语言',
    '神经网络模拟人脑的工作方式',
    # 体育类
    '足球是世界最受欢迎的运动',
    '篮球需要团队合作',
    '奥运会是体育盛事',
    '运动员需要刻苦训练',
    '体育比赛充满激情'
]

# 准备标签（0表示科技，1表示体育）
labels = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(
    texts, labels, test_size=0.3, random_state=42
)

# 文本向量化
# TfidfVectorizer 将文本转换为数值向量
# TF-IDF 是一种常用的文本特征提取方法
vectorizer = TfidfVectorizer()

# 在训练集上拟合并转换
X_train_vectors = vectorizer.fit_transform(X_train)
# 在测试集上转换（使用训练集的词汇表）
X_test_vectors = vectorizer.transform(X_test)

# 创建分类器
# MultinomialNB 是适用于文本分类的朴素贝叶斯分类器
clf = MultinomialNB()

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

# 预测
y_pred = clf.predict(X_test_vectors)

# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy:.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred, target_names=['科技', '体育']))

# 测试新文本
new_texts = ['机器学习算法', '足球世界杯']
new_vectors = vectorizer.transform(new_texts)
new_predictions = clf.predict(new_vectors)
print("\n新文本预测:")
for text, pred in zip(new_texts, new_predictions):
    category = '科技' if pred == 0 else '体育'
    print(f"'{text}' -> {category}")

11. 常见问题 #

11.1 如何处理缺失值？ #

# 导入必要的库
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier

# 创建包含缺失值的数据
# 使用 np.nan 表示缺失值
X = np.array([
    [1, 2, 3],
    [4, np.nan, 6],  # 第二个特征缺失
    [7, 8, 9],
    [10, 11, np.nan]  # 第三个特征缺失
])

print("原始数据（包含缺失值）:")
print(X)

# 创建缺失值填充器
# strategy='mean' 表示用均值填充
imputer = SimpleImputer(strategy='mean')

# 填充缺失值
X_imputed = imputer.fit_transform(X)

print("\n填充后的数据:")
print(X_imputed)

11.2 如何选择模型参数？ #

可以使用网格搜索来寻找最佳参数。

# 导入必要的库
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.ensemble import RandomForestClassifier

# 加载数据
iris = load_iris()
X, y = iris.data, iris.target

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

# 创建模型
clf = RandomForestClassifier(random_state=42)

# 定义参数网格
# 网格搜索会尝试所有参数组合
param_grid = {
    'n_estimators': [50, 100, 200],  # 树的数量
    'max_depth': [None, 5, 10]  # 树的最大深度
}

# 创建网格搜索
# cv=5 表示5折交叉验证
# scoring='accuracy' 使用准确率作为评估指标
grid_search = GridSearchCV(
    clf, param_grid, cv=5, scoring='accuracy'
)

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

# 查看最佳参数
print(f"最佳参数: {grid_search.best_params_}")
print(f"最佳交叉验证分数: {grid_search.best_score_:.4f}")

# 使用最佳模型预测
y_pred = grid_search.predict(X_test)
from sklearn.metrics import accuracy_score
print(f"测试集准确率: {accuracy_score(y_test, y_pred):.4f}")

12. 总结 #

12.1 Scikit-learn 的核心价值 #

1. 简单易用：统一的API，几行代码就能完成机器学习任务
2. 功能全面：包含分类、回归、聚类、降维等各种算法
3. 文档完善：有详细的文档和丰富的示例
4. 免费开源：可以自由使用和修改

12.2 基本使用流程 #

1. 准备数据：加载或生成数据
2. 数据预处理：标准化、编码等
3. 划分数据：分为训练集和测试集
4. 选择模型：根据任务选择合适的算法
5. 训练模型：使用训练集训练模型
6. 评估模型：使用测试集评估模型性能
7. 使用模型：对新数据进行预测