更新时间：2026-05-18 | 阅读时长：15分钟🔬

---

前言

很多人听到"机器学习"三个字就头皮发麻。

公式太多、概念太抽象、门槛好像高不可攀……

但其实，机器学习的本质很简单：让计算机从数据里找到规律，然后用来做预测。

就像你教小孩认猫：给他看一百张猫的图片，他下次见到猫就能认出来。机器学习干的也是这事——只不过"学生"变成了代码。

今天这篇文章，用最通俗的方式，带你入门Python机器学习。用的工具是scikit-learn，它把机器学习的门槛降到了脚底下。

---

一、准备工作

首先安装必要的库：

bash

复制

pip install scikit-learn numpy pandas matplotlib

导入我们今天要用的所有库：

python

复制

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.cluster import KMeans
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
from sklearn.metrics import mean_squared_error, r2_score
import warnings
warnings.filterwarnings('ignore')

plt.rcParams['font.sans-serif'] = ['SimHei', 'Arial Unicode MS']
plt.rcParams['axes.unicode_minus'] = False
print("库导入成功！")

---

二、了解数据

我们用经典的鸢尾花（iris）数据集，这是机器学习界的"Hello World"。

python

复制

# 加载数据集
iris = load_iris()
print("数据集形状：", iris.data.shape)
print("特征名称：", iris.feature_names)
print("标签名称：", iris.target_names)

运行结果：

数据集形状： (150, 4)
特征名称： ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
标签名称： ['setosa' 'versicolor' 'virginica']

150朵花，4个特征（花萼长度、花萼宽度、花瓣长度、花瓣宽度），3个类别。

把数据转成DataFrame，看起来更直观：

python

复制

df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['species'] = [iris.target_names[i] for i in iris.target]
print(df.head(10))

---

三、数据预处理

机器学习前，一般要做两件事：划分训练集和测试集，以及特征标准化。

python

复制

X = iris.data
y = iris.target

# 划分训练集和测试集（80%训练，20%测试）
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[0]}")
print(f"测试集大小：{X_test.shape[0]}")

# 特征标准化（让不同量纲的特征在同一个尺度上）
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
print("标准化完成！")

---

四、分类模型：让电脑学会"认花"

4.1 逻辑回归

python

复制

# 训练逻辑回归模型
lr_model = LogisticRegression(max_iter=200, random_state=42)
lr_model.fit(X_train_scaled, y_train)

# 预测
y_pred_lr = lr_model.predict(X_test_scaled)

# 评估
print("=== 逻辑回归结果 ===")
print(f"准确率：{accuracy_score(y_test, y_pred_lr):.2%}")
print("\n分类报告：")
print(classification_report(y_test, y_pred_lr, target_names=iris.target_names))

运行结果示例：

=== 逻辑回归结果 ===
准确率：100.00%

分类报告：
              precision    recall  f1-score   support
      setosa       1.00      1.00      1.00        10
  versicolor       1.00      1.00      1.00        10
   virginica       1.00      1.00      1.00        10

准确率100%！这个数据集太简单了，三个类别分得很开。

4.2 K近邻算法（KNN）

KNN的思路很直观：看它最近的K个邻居是谁，多数属于哪个类，它就属于哪个类。

python

复制

# 训练KNN模型
knn_model = KNeighborsClassifier(n_neighbors=5)
knn_model.fit(X_train_scaled, y_train)

# 预测
y_pred_knn = knn_model.predict(X_test_scaled)

# 评估
print("=== KNN结果 ===")
print(f"准确率：{accuracy_score(y_test, y_pred_knn):.2%}")

4.3 决策树

决策树就像不停问问题来分类：

• 花瓣宽度 > 0.8？ 是 → 继续问
• 花瓣长度 > 4.5？ 是 → 可能是维吉尼亚鸢尾

python

复制

# 训练决策树模型
dt_model = DecisionTreeClassifier(max_depth=5, random_state=42)
dt_model.fit(X_train_scaled, y_train)

# 预测
y_pred_dt = dt_model.predict(X_test_scaled)

# 评估
print("=== 决策树结果 ===")
print(f"准确率：{accuracy_score(y_test, y_pred_dt):.2%}")

---

五、混淆矩阵可视化

混淆矩阵能让我们更直观地看到模型哪里分对了、哪里分错了：

python

复制

def plot_confusion_matrix(cm, title):
    plt.figure(figsize=(6, 5))
    plt.imshow(cm, interpolation='nearest', cmap='Blues')
    plt.title(title, fontsize=14)
    plt.colorbar()
    tick_marks = np.arange(len(iris.target_names))
    plt.xticks(tick_marks, iris.target_names)
    plt.yticks(tick_marks, iris.target_names)

    # 在格子里填数字
    for i in range(cm.shape[0]):
        for j in range(cm.shape[1]):
            plt.text(j, i, format(cm[i, j], 'd'),
                    ha="center", va="center",
                    color="white" if cm[i, j] > cm.max() / 2 else "black")
    plt.ylabel('真实类别')
    plt.xlabel('预测类别')
    plt.tight_layout()
    plt.savefig('confusion_matrix.png', dpi=150)
    plt.show()

# 绘制逻辑回归的混淆矩阵
cm = confusion_matrix(y_test, y_pred_lr)
plot_confusion_matrix(cm, '逻辑回归 - 混淆矩阵')
print("混淆矩阵已保存为 confusion_matrix.png")

---

六、回归模型：预测数值

分类是预测类别，回归是预测数值。我们用糖尿病数据集来演示：

python

复制

from sklearn.datasets import load_diabetes
from sklearn.linear_model import LinearRegression

# 加载糖尿病数据集
diabetes = load_diabetes()
X = diabetes.data
y = diabetes.target

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

# 训练线性回归模型
lr_reg = LinearRegression()
lr_reg.fit(X_train, y_train)

# 预测
y_pred = lr_reg.predict(X_test)

# 评估
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)

print("=== 线性回归结果 ===")
print(f"均方误差（MSE）：{mse:.2f}")
print(f"均方根误差（RMSE）：{rmse:.2f}")
print(f"R² 决定系数：{r2:.4f}")

R² 越接近1，说明模型拟合得越好。

---

七、聚类分析：无监督学习

前面的例子都是有监督学习——我们告诉模型正确答案是什么。

聚类不需要正确答案，它自己发现数据里的"群落"。

python

复制

# 用K-Means对鸢尾花做聚类
X = iris.data

# 假设我们知道数据里有3个类别
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
clusters = kmeans.fit_predict(X)

# 可视化（用前两个特征）
plt.figure(figsize=(10, 5))

plt.subplot(1, 2, 1)
plt.scatter(X[:, 0], X[:, 1], c=clusters, cmap='viridis', s=50)
plt.xlabel('花萼长度 (cm)')
plt.ylabel('花萼宽度 (cm)')
plt.title('K-Means 聚类结果')
plt.colorbar()

plt.subplot(1, 2, 2)
plt.scatter(X[:, 0], X[:, 1], c=iris.target, cmap='viridis', s=50)
plt.xlabel('花萼长度 (cm)')
plt.ylabel('花萼宽度 (cm)')
plt.title('真实类别（作为对比）')
plt.colorbar()

plt.tight_layout()
plt.savefig('clustering_result.png', dpi=150)
plt.show()
print("聚类结果已保存为 clustering_result.png")

聚类的结果和真实标签可能不完全对应，但结构是相似的——这说明数据的内在规律确实存在。

---

八、模型对比：一图看全

把几种分类模型放在一起比一比：

python

复制

from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.neural_network import MLPClassifier

models = {
    '逻辑回归': LogisticRegression(max_iter=200, random_state=42),
    'KNN': KNeighborsClassifier(n_neighbors=5),
    '决策树': DecisionTreeClassifier(max_depth=5, random_state=42),
    '朴素贝叶斯': GaussianNB(),
    '支持向量机': SVC(kernel='rbf', random_state=42),
    '随机森林': RandomForestClassifier(n_estimators=100, random_state=42),
    '神经网络': MLPClassifier(hidden_layer_sizes=(50, 30), max_iter=500, random_state=42)
}

results = {}
for name, model in models.items():
    model.fit(X_train_scaled, y_train)
    pred = model.predict(X_test_scaled)
    acc = accuracy_score(y_test, pred)
    results[name] = acc

# 排序并可视化
sorted_results = sorted(results.items(), key=lambda x: x[1], reverse=True)

plt.figure(figsize=(12, 6))
names = [x[0] for x in sorted_results]
scores = [x[1] for x in sorted_results]

colors = plt.cm.RdYlGn(np.linspace(0.3, 0.9, len(names)))
bars = plt.barh(names, scores, color=colors)
plt.xlabel('准确率')
plt.title('六种分类模型准确率对比（鸢尾花数据集）', fontsize=14)
plt.xlim(0.8, 1.02)

for bar, score in zip(bars, scores):
    plt.text(score + 0.003, bar.get_y() + bar.get_height() / 2,
             f'{score:.2%}', va='center', fontsize=11)

plt.tight_layout()
plt.savefig('model_comparison.png', dpi=150)
plt.show()
print("模型对比图已保存为 model_comparison.png")

从图里一眼就能看出哪个模型表现最好。

---

九、完整实战：预测泰坦尼克号生存率

最后来一个真实的、有意义的数据集——泰坦尼克号乘客生存预测。

这个数据集需要一些预处理（处理缺失值、编码分类变量），更能体现真实的机器学习流程：

python

复制

# 准备泰坦尼克号数据
url = "https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv"
df = pd.read_csv(url)
print(f"原始数据：{df.shape}")
print(df.head())

python

复制

# 数据预处理
df = df.drop(['PassengerId', 'Name', 'Ticket', 'Cabin'], axis=1)

# 填充缺失值
df['Age'].fillna(df['Age'].median(), inplace=True)
df['Embarked'].fillna(df['Embarked'].mode()[0], inplace=True)

# 编码分类变量
df['Sex'] = df['Sex'].map({'male': 0, 'female': 1})
df['Embarked'] = df['Embarked'].map({'S': 0, 'C': 1, 'Q': 2})

# 分离特征和标签
X = df.drop('Survived', axis=1)
y = df['Survived']

# 划分数据集
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)

print(f"\n处理后特征：{X.columns.tolist()}")
print(f"训练集：{X_train.shape[0]}条，测试集：{X_test.shape[0]}条")

python

复制

# 训练随机森林模型
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train_scaled, y_train)

# 预测
y_pred = rf_model.predict(X_test_scaled)

# 评估
print("\n=== 泰坦尼克号生存预测结果 ===")
print(f"准确率：{accuracy_score(y_test, y_pred):.2%}")
print("\n详细分类报告：")
print(classification_report(y_test, y_pred, target_names=['遇难', '生存']))

# 特征重要性
feature_importance = pd.DataFrame({
    'feature': X.columns,
    'importance': rf_model.feature_importances_
}).sort_values('importance', ascending=False)

print("\n特征重要性排名：")
print(feature_importance)

# 可视化特征重要性
plt.figure(figsize=(10, 5))
plt.barh(feature_importance['feature'], feature_importance['importance'])
plt.xlabel('重要性')
plt.title('泰坦尼克号 - 特征重要性（随机森林）')
plt.gca().invert_yaxis()
plt.tight_layout()
plt.savefig('titanic_feature_importance.png', dpi=150)
plt.show()

这个实战告诉我们：性别（Sex）和票价（Fare）是最重要的预测因素——这也和历史事实吻合，女性和有钱人优先获救。

---

十、保存和加载模型

训练好的模型可以保存下来，下次直接用，不用重新训练：

python

复制

import joblib

# 保存模型
joblib.dump(lr_model, 'iris_logistic_model.pkl')
joblib.dump(scaler, 'iris_scaler.pkl')
print("模型已保存！")

# 加载模型
loaded_model = joblib.load('iris_logistic_model.pkl')
loaded_scaler = joblib.load('iris_scaler.pkl')
print("模型加载成功！")

# 用加载的模型做预测
sample = [[5.1, 3.5, 1.4, 0.2]]
sample_scaled = loaded_scaler.transform(sample)
prediction = loaded_model.predict(sample_scaled)
print(f"预测类别：{iris.target_names[prediction[0]]}")

---

总结

今天这篇文章，涵盖了机器学习最核心的内容：

类别	模型	用途
分类	逻辑回归、KNN、决策树、SVM、随机森林、神经网络	预测类别
回归	线性回归	预测数值
聚类	K-Means	发现数据的自然分组

整个流程就三步：加载数据 → 训练模型 → 评估效果。

scikit-learn把每一步都封装成了几行代码，让任何人都能快速上手机器学习。

下一步可以深入学习：模型调参、交叉验证、集成学习等进阶内容。这些技能会让你从一个"会用工具的人"变成一个"真正懂机器学习的人"。

---

👍 如果这篇文章对你有帮助，记得点赞！ 在评论区说说，你最想用机器学习解决什么问题？

我是AI实验室2026，专注AI大模型与Python技术，我们下篇见！