Python机器学习入门：从数据处理到模型部署全实战

一、机器学习概述与开发环境搭建

1.1 什么是机器学习

机器学习是人工智能的一个分支，它使计算机能够从数据中学习并做出预测或决策，而无需进行明确编程。机器学习算法通过分析数据、识别模式，并利用这些模式来进行预测。

机器学习的主要类型：

• 监督学习：从标注数据中学习，用于分类和回归任务
• 无监督学习：从未标注数据中发现模式，用于聚类和降维
• 强化学习：通过试错学习，用于决策和控制

1.2 Python机器学习生态

┌─────────────────────────────────────────────────────────┐
│               Python机器学习生态系统                      │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  数据处理层                                              │
│    ├── NumPy（数值计算）                                  │
│    ├── Pandas（数据处理）                                 │
│    └── Matplotlib/Seaborn（数据可视化）                   │
│                                                         │
│  机器学习框架                                             │
│    ├── Scikit-learn（传统ML）                            │
│    ├── TensorFlow（深度学习）                            │
│    ├── PyTorch（深度学习）                               │
│    └── XGBoost/LightGBM（梯度提升）                      │
│                                                         │
│  数据采集与存储                                          │
│    ├── SQLAlchemy（数据库）                              │
│    ├── requests（网络请求）                               │
│    └── BeautifulSoup（网页爬取）                         │
│                                                         │
│  模型部署                                                │
│    ├── Flask/FastAPI（API服务）                          │
│    ├── Docker（容器化）                                  │
│    └── ONNX（模型转换）                                  │
│                                                         │
└─────────────────────────────────────────────────────────┘

1.3 开发环境搭建

步骤1：安装Anaconda

# 下载Anaconda安装包
# 运行安装向导
# 添加到系统PATH

步骤2：创建虚拟环境

# 创建环境
conda create -n ml_env python=3.9

# 激活环境
conda activate ml_env

# 安装依赖
pip install numpy pandas matplotlib seaborn scikit-learn tensorflow pytorch

步骤3：安装Jupyter Notebook

pip install jupyter
jupyter notebook

1.4 常用库版本

库	用途	推荐版本
NumPy	数值计算	1.24+
Pandas	数据处理	1.5+
Matplotlib	数据可视化	3.7+
Scikit-learn	机器学习	1.2+
TensorFlow	深度学习	2.15+
PyTorch	深度学习	2.1+

二、数据处理与可视化

2.1 NumPy基础

import numpy as np

# 创建数组
arr = np.array([1, 2, 3, 4, 5])
print("一维数组:", arr)

# 创建二维数组
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("二维数组:\n", matrix)

# 数组运算
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
print("加法:", arr1 + arr2)
print("乘法:", arr1 * arr2)
print("点积:", np.dot(arr1, arr2))

# 数组操作
print("转置:\n", matrix.T)
print("形状:", matrix.shape)
print("求和:", np.sum(matrix))
print("均值:", np.mean(matrix))
print("最大值:", np.max(matrix))

# 矩阵运算
mat1 = np.array([[1, 2], [3, 4]])
mat2 = np.array([[5, 6], [7, 8]])
print("矩阵乘法:\n", np.dot(mat1, mat2))

# 生成随机数
np.random.seed(42)
rand_arr = np.random.rand(5)
print("随机数组:", rand_arr)

rand_matrix = np.random.randn(3, 3)
print("正态分布随机矩阵:\n", rand_matrix)

2.2 Pandas数据处理

import pandas as pd

# 创建DataFrame
data = {
    '姓名': ['张三', '李四', '王五', '赵六'],
    '年龄': [25, 30, 28, 35],
    '性别': ['男', '女', '男', '男'],
    '工资': [8000, 10000, 9000, 12000]
}
df = pd.DataFrame(data)
print("DataFrame:\n", df)

# 数据查看
print("前3行:\n", df.head(3))
print("基本信息:\n", df.info())
print("统计摘要:\n", df.describe())

# 数据筛选
print("年龄大于30的行:\n", df[df['年龄'] > 30])
print("男性员工:\n", df[df['性别'] == '男'])

# 数据排序
print("按工资降序排序:\n", df.sort_values('工资', ascending=False))

# 数据分组
grouped = df.groupby('性别')
print("分组统计:\n", grouped['工资'].mean())

# 数据合并
data2 = {
    '姓名': ['张三', '李四', '王五', '孙七'],
    '部门': ['研发', '市场', '研发', '销售']
}
df2 = pd.DataFrame(data2)
merged_df = pd.merge(df, df2, on='姓名')
print("合并后:\n", merged_df)

# 数据缺失处理
df3 = df.copy()
df3.loc[1, '工资'] = None
print("有缺失值的DataFrame:\n", df3)
print("填充缺失值:\n", df3.fillna(df3['工资'].mean()))

# 读取CSV文件
# df = pd.read_csv('data.csv')
# 保存CSV文件
# df.to_csv('output.csv', index=False)

2.3 Matplotlib可视化

import matplotlib.pyplot as plt
import numpy as np

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei']
plt.rcParams['axes.unicode_minus'] = False

# 折线图
x = np.linspace(0, 2 * np.pi, 100)
y = np.sin(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y, label='sin(x)', color='blue', linewidth=2)
plt.plot(x, np.cos(x), label='cos(x)', color='red', linewidth=2)
plt.title('三角函数图像')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()

# 柱状图
categories = ['A', 'B', 'C', 'D', 'E']
values = [30, 45, 25, 50, 40]

plt.figure(figsize=(10, 6))
plt.bar(categories, values, color=['red', 'blue', 'green', 'yellow', 'orange'])
plt.title('类别统计')
plt.xlabel('类别')
plt.ylabel('数值')
plt.show()

# 直方图
np.random.seed(42)
data = np.random.randn(1000)

plt.figure(figsize=(10, 6))
plt.hist(data, bins=30, color='skyblue', edgecolor='black')
plt.title('正态分布直方图')
plt.xlabel('数值')
plt.ylabel('频数')
plt.show()

# 散点图
x = np.random.rand(50)
y = 2 * x + np.random.randn(50) * 0.3

plt.figure(figsize=(10, 6))
plt.scatter(x, y, color='red', marker='o')
plt.title('散点图')
plt.xlabel('x')
plt.ylabel('y')
plt.show()

# 饼图
labels = ['苹果', '香蕉', '橙子', '葡萄']
sizes = [35, 25, 20, 20]

plt.figure(figsize=(8, 8))
plt.pie(sizes, labels=labels, autopct='%1.1f%%', 
        colors=['red', 'yellow', 'orange', 'purple'])
plt.title('水果占比')
plt.show()

三、监督学习算法

3.1 线性回归

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# 生成模拟数据
np.random.seed(42)
X = np.random.rand(100, 1) * 10
y = 3 * X + 5 + np.random.randn(100, 1) * 2

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

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

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

# 预测
y_pred = model.predict(X_test)

# 输出模型参数
print("斜率:", model.coef_[0][0])
print("截距:", model.intercept_[0])

# 评估模型
print("均方误差:", mean_squared_error(y_test, y_pred))
print("R²评分:", r2_score(y_test, y_pred))

# 可视化结果
plt.figure(figsize=(10, 6))
plt.scatter(X_test, y_test, color='blue', label='真实值')
plt.plot(X_test, y_pred, color='red', linewidth=2, label='预测值')
plt.title('线性回归预测')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.show()

3.2 逻辑回归

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# 生成模拟数据
np.random.seed(42)
X = np.random.randn(200, 2)
y = (X[:, 0] + X[:, 1] > 0).astype(int)

# 划分训练集和测试集
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)

# 评估模型
print("准确率:", accuracy_score(y_test, y_pred))
print("混淆矩阵:\n", confusion_matrix(y_test, y_pred))
print("分类报告:\n", classification_report(y_test, y_pred))

# 可视化决策边界
plt.figure(figsize=(10, 6))
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k')
plt.title('逻辑回归决策边界')
plt.show()

3.3 支持向量机

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC
from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 生成非线性数据
X, y = make_circles(n_samples=100, noise=0.1, random_state=42)

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

# 创建SVM模型（使用RBF核）
model = SVC(kernel='rbf', C=1.0, gamma='scale')

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

# 预测
y_pred = model.predict(X_test)

# 评估模型
print("准确率:", accuracy_score(y_test, y_pred))

# 可视化决策边界
plt.figure(figsize=(10, 6))
h = 0.02
x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k')
plt.title('SVM决策边界（RBF核）')
plt.show()

3.4 决策树与随机森林

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_wine
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 加载数据集
wine = load_wine()
X, y = wine.data, wine.target

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

# 创建决策树模型
dt_model = DecisionTreeClassifier(max_depth=3, random_state=42)
dt_model.fit(X_train, y_train)
dt_pred = dt_model.predict(X_test)
print("决策树准确率:", accuracy_score(y_test, dt_pred))

# 创建随机森林模型
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)
rf_pred = rf_model.predict(X_test)
print("随机森林准确率:", accuracy_score(y_test, rf_pred))

# 可视化决策树
plt.figure(figsize=(15, 10))
plot_tree(dt_model, feature_names=wine.feature_names, 
          class_names=wine.target_names, filled=True)
plt.title('决策树可视化')
plt.show()

# 特征重要性
importances = rf_model.feature_importances_
indices = np.argsort(importances)[::-1]

plt.figure(figsize=(10, 6))
plt.bar(range(X.shape[1]), importances[indices])
plt.xticks(range(X.shape[1]), np.array(wine.feature_names)[indices], rotation=90)
plt.title('随机森林特征重要性')
plt.show()

四、无监督学习算法

4.1 K-Means聚类

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs

# 生成聚类数据
X, y_true = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=42)

# 创建K-Means模型
kmeans = KMeans(n_clusters=4, random_state=42)
kmeans.fit(X)
y_pred = kmeans.predict(X)

# 获取聚类中心
centers = kmeans.cluster_centers_

# 可视化聚类结果
plt.figure(figsize=(10, 6))
plt.scatter(X[:, 0], X[:, 1], c=y_pred, s=50, cmap='viridis')
plt.scatter(centers[:, 0], centers[:, 1], c='red', s=200, alpha=0.75, marker='X')
plt.title('K-Means聚类结果')
plt.show()

# 使用肘部法则选择K值
inertias = []
K = range(1, 10)
for k in K:
    kmeans = KMeans(n_clusters=k, random_state=42)
    kmeans.fit(X)
    inertias.append(kmeans.inertia_)

plt.figure(figsize=(10, 6))
plt.plot(K, inertias, 'bx-')
plt.xlabel('K值')
plt.ylabel('惯性值')
plt.title('肘部法则')
plt.show()

4.2 主成分分析（PCA）

import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris

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

# 创建PCA模型，降维到2维
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# 查看主成分方差解释率
print("方差解释率:", pca.explained_variance_ratio_)
print("累计方差解释率:", np.sum(pca.explained_variance_ratio_))

# 可视化降维结果
plt.figure(figsize=(10, 6))
for target, color, name in zip(range(3), ['red', 'green', 'blue'], iris.target_names):
    plt.scatter(X_pca[y == target, 0], X_pca[y == target, 1], 
                c=color, label=name, edgecolors='k')
plt.title('PCA降维可视化')
plt.xlabel('主成分1')
plt.ylabel('主成分2')
plt.legend()
plt.show()

# 查看特征向量
print("特征向量:\n", pca.components_)

4.3 层次聚类

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import AgglomerativeClustering
from sklearn.datasets import make_blobs
from scipy.cluster.hierarchy import dendrogram, linkage

# 生成数据
X, y_true = make_blobs(n_samples=50, centers=3, cluster_std=0.60, random_state=42)

# 层次聚类
model = AgglomerativeClustering(n_clusters=3)
y_pred = model.fit_predict(X)

# 可视化聚类结果
plt.figure(figsize=(10, 6))
plt.scatter(X[:, 0], X[:, 1], c=y_pred, s=50, cmap='viridis')
plt.title('层次聚类结果')
plt.show()

# 绘制谱系图
linked = linkage(X, 'ward')

plt.figure(figsize=(15, 10))
dendrogram(linked, orientation='top', labels=y_true, 
           distance_sort='descending', show_leaf_counts=True)
plt.title('层次聚类谱系图')
plt.show()

五、深度学习入门

5.1 TensorFlow基础

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# 加载MNIST数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 数据预处理
x_train = x_train / 255.0
x_test = x_test / 255.0
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

# 创建神经网络模型
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

# 编译模型
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# 训练模型
history = model.fit(x_train, y_train, 
                    epochs=10, 
                    batch_size=32, 
                    validation_split=0.1)

# 评估模型
test_loss, test_acc = model.evaluate(x_test, y_test)
print("测试准确率:", test_acc)

# 预测
predictions = model.predict(x_test)
print("第一个样本预测:", np.argmax(predictions[0]))
print("第一个样本真实值:", np.argmax(y_test[0]))

# 绘制训练曲线
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='训练准确率')
plt.plot(history.history['val_accuracy'], label='验证准确率')
plt.title('准确率曲线')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='训练损失')
plt.plot(history.history['val_loss'], label='验证损失')
plt.title('损失曲线')
plt.legend()

plt.show()

5.2 CNN卷积神经网络

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.utils import to_categorical

# 加载CIFAR-10数据集
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

# 数据预处理
x_train = x_train / 255.0
x_test = x_test / 255.0
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

# 创建CNN模型
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    Flatten(),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

# 编译模型
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# 训练模型
history = model.fit(x_train, y_train, 
                    epochs=15, 
                    batch_size=64, 
                    validation_split=0.1)

# 评估模型
test_loss, test_acc = model.evaluate(x_test, y_test)
print("测试准确率:", test_acc)

# 查看模型结构
model.summary()

# 绘制训练曲线
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='训练准确率')
plt.plot(history.history['val_accuracy'], label='验证准确率')
plt.title('准确率曲线')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='训练损失')
plt.plot(history.history['val_loss'], label='验证损失')
plt.title('损失曲线')
plt.legend()

plt.show()

六、模型评估与调优

6.1 交叉验证

import numpy as np
from sklearn.model_selection import cross_val_score, KFold
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_wine

# 加载数据集
wine = load_wine()
X, y = wine.data, wine.target

# 创建模型
model = LogisticRegression(max_iter=200)

# K折交叉验证
kf = KFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=kf, scoring='accuracy')

print("各折准确率:", scores)
print("平均准确率:", np.mean(scores))
print("标准差:", np.std(scores))

6.2 网格搜索

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC
from sklearn.datasets import load_wine

# 加载数据集
wine = load_wine()
X, y = wine.data, wine.target

# 创建模型
model = SVC()

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

# 网格搜索
grid = GridSearchCV(model, param_grid, cv=5, scoring='accuracy')
grid.fit(X, y)

print("最佳参数:", grid.best_params_)
print("最佳分数:", grid.best_score_)

# 使用最佳参数
best_model = grid.best_estimator_

6.3 混淆矩阵与ROC曲线

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, roc_curve, auc
from sklearn.datasets import load_breast_cancer

# 加载数据集
cancer = load_breast_cancer()
X, y = cancer.data, cancer.target

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

# 创建模型
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)

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

# 计算ROC曲线
fpr, tpr, thresholds = roc_curve(y_test, y_proba)
roc_auc = auc(fpr, tpr)

# 绘制ROC曲线
plt.figure(figsize=(10, 6))
plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC曲线 (AUC = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('假阳性率')
plt.ylabel('真阳性率')
plt.title('ROC曲线')
plt.legend()
plt.show()

# 混淆矩阵
y_pred = model.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
print("混淆矩阵:\n", cm)

七、模型部署

7.1 使用Flask部署模型

from flask import Flask, request, jsonify
import numpy as np
from sklearn.linear_model import LinearRegression

# 创建Flask应用
app = Flask(__name__)

# 训练一个简单的模型
np.random.seed(42)
X = np.random.rand(100, 1) * 10
y = 3 * X + 5 + np.random.randn(100, 1) * 2
model = LinearRegression()
model.fit(X, y)

@app.route('/predict', methods=['POST'])
def predict():
    try:
        # 获取请求数据
        data = request.get_json()
        X_new = np.array(data['input']).reshape(-1, 1)
        
        # 预测
        y_pred = model.predict(X_new)
        
        # 返回结果
        return jsonify({'prediction': y_pred.tolist()})
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/health', methods=['GET'])
def health():
    return jsonify({'status': 'healthy'})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

7.2 客户端调用示例

import requests
import numpy as np

# 发送预测请求
url = 'http://localhost:5000/predict'
data = {'input': [2.5, 3.0, 4.5]}
response = requests.post(url, json=data)

if response.status_code == 200:
    result = response.json()
    print("预测结果:", result['prediction'])
else:
    print("请求失败:", response.json())

# 健康检查
health_response = requests.get('http://localhost:5000/health')
print("健康状态:", health_response.json())

7.3 模型保存与加载

import joblib
import numpy as np
from sklearn.linear_model import LinearRegression

# 训练模型
np.random.seed(42)
X = np.random.rand(100, 1) * 10
y = 3 * X + 5 + np.random.randn(100, 1) * 2
model = LinearRegression()
model.fit(X, y)

# 保存模型
joblib.dump(model, 'linear_model.joblib')
print("模型已保存")

# 加载模型
loaded_model = joblib.load('linear_model.joblib')
print("模型已加载")

# 使用加载的模型预测
X_new = np.array([[5.0]])
y_pred = loaded_model.predict(X_new)
print("预测结果:", y_pred)

八、学习路径与资源推荐

8.1 Python机器学习学习路径

阶段1：基础准备
    ├── Python编程基础
    ├── NumPy数值计算
    ├── Pandas数据处理
    └── Matplotlib可视化

阶段2：传统机器学习
    ├── 线性回归
    ├── 逻辑回归
    ├── 决策树/随机森林
    ├── SVM支持向量机
    └── K-Means聚类

阶段3：深度学习
    ├── TensorFlow/PyTorch基础
    ├── 神经网络原理
    ├── CNN卷积神经网络
    ├── RNN循环神经网络
    └── Transformer架构

阶段4：进阶应用
    ├── 模型评估与调优
    ├── 特征工程
    ├── 模型部署
    └── 实战项目

阶段5：前沿方向
    ├── 强化学习
    ├── 生成对抗网络
    ├── 大语言模型
    └── 计算机视觉

8.2 推荐资源

学习书籍：

• 《Python机器学习基础教程》（Andreas Müller）
• 《深度学习》（Ian Goodfellow）
• 《动手学深度学习》（李沐）
• 《统计学习方法》（李航）

在线课程：

• Coursera机器学习（Andrew Ng）
• fast.ai深度学习课程
• Kaggle Learn

在线资源：

• scikit-learn官方文档
• TensorFlow官方教程
• PyTorch官方教程
• Kaggle竞赛平台

8.3 实践项目建议

1. 房价预测（线性回归）
2. 鸢尾花分类（决策树/SVM）
3. MNIST手写数字识别（神经网络）
4. CIFAR-10图像分类（CNN）
5. 客户分群（K-Means聚类）
6. 股票价格预测（RNN）

---

关键词：Python、机器学习、深度学习、TensorFlow、Scikit-learn、数据处理、模型部署

本文字数：约5500字