Python AI 入门 - 学习单元

Scikit-learn - 机器学习入门

Scikit-learn 是 Python 中最流行的机器学习库之一，它提供了简单高效的工具来进行数据挖掘和数据分析。

为什么使用 Scikit-learn？ Scikit-learn 提供了丰富的机器学习算法，包括分类、回归、聚类等，而且它的 API 设计简洁一致，非常适合初学者。

机器学习基本概念

在开始使用 Scikit-learn 之前，让我们了解一些基本的机器学习概念：

监督学习：从标记数据中学习，例如分类和回归
无监督学习：从未标记数据中学习，例如聚类
训练集：用于训练模型的数据
测试集：用于评估模型性能的数据
特征：输入数据的属性
标签：输出数据的值

Scikit-learn 工作流程

Python 代码

# 导入必要的库
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix

# 1. 加载数据
# 这里使用一个示例数据集
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data  # 特征
y = iris.target  # 标签

print("特征形状:", X.shape)
print("标签形状:", y.shape)
print("标签类别:", np.unique(y))

# 2. 数据预处理
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
print("训练集大小:", X_train.shape)
print("测试集大小:", X_test.shape)

# 特征缩放
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

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

# 4. 模型预测
y_pred = model.predict(X_test_scaled)

# 5. 模型评估
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)

print(f"模型准确率: {accuracy:.2f}")
print("混淆矩阵:")
print(conf_matrix)

# 6. 模型应用
# 使用训练好的模型进行新数据预测
new_data = np.array([[5.1, 3.5, 1.4, 0.2]])  # 新数据
new_data_scaled = scaler.transform(new_data)
prediction = model.predict(new_data_scaled)
print(f"新数据预测结果: {prediction}")
print(f"预测的类别: {iris.target_names[prediction][0]}")

常用机器学习算法

分类算法

逻辑回归 (Logistic Regression)
决策树 (Decision Tree)
随机森林 (Random Forest)
支持向量机 (SVM)
K-最近邻 (KNN)

回归算法

线性回归 (Linear Regression)
岭回归 (Ridge Regression)
LASSO 回归
决策树回归
随机森林回归

提示： 选择合适的算法取决于你的数据类型和问题类型。对于初学者来说，建议从简单的算法开始，如线性回归和逻辑回归，然后再尝试更复杂的算法。

深度学习入门

深度学习是机器学习的一个分支，它使用多层神经网络来学习数据中的复杂模式。在 Python 中，我们可以使用 TensorFlow 或 PyTorch 等框架来实现深度学习模型。

为什么学习深度学习？ 深度学习在图像识别、自然语言处理、语音识别等领域取得了巨大的成功，是当今 AI 领域的热点。

神经网络基础

神经网络由输入层、隐藏层和输出层组成：

输入层：接收原始数据
隐藏层：学习数据中的特征
输出层：产生预测结果
激活函数：引入非线性，如 ReLU、Sigmoid、Tanh
损失函数：衡量预测值与真实值的差异
优化器：更新模型参数，如 SGD、Adam

使用 TensorFlow/Keras 构建神经网络

Python 代码

# 导入必要的库
import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.datasets import mnist

# 1. 加载数据
(X_train, y_train), (X_test, y_test) = mnist.load_data()
print("训练集大小:", X_train.shape)
print("测试集大小:", X_test.shape)

# 2. 数据预处理
# 归一化
X_train = X_train / 255.0
X_test = X_test / 255.0

# 3. 构建模型
model = Sequential([
    Flatten(input_shape=(28, 28)),  #  flatten 层将 28x28 的图像转换为 1D 数组
    Dense(128, activation='relu'),  # 隐藏层，128 个神经元
    Dense(10, activation='softmax')  # 输出层，10 个类别
])

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

# 5. 训练模型
history = model.fit(X_train, y_train, epochs=5, validation_split=0.2)

# 6. 评估模型
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"测试准确率: {test_acc:.2f}")

# 7. 模型预测
# 预测单个图像
import matplotlib.pyplot as plt

# 选择一个测试图像
index = 0
test_image = X_test[index]
plt.imshow(test_image, cmap='gray')
plt.title(f"真实标签: {y_test[index]}")
# plt.show()

# 进行预测
test_image = test_image.reshape(1, 28, 28)  # 调整形状
prediction = model.predict(test_image)
predicted_label = np.argmax(prediction)
print(f"预测标签: {predicted_label}")

使用 PyTorch 构建神经网络

Python 代码

# 导入必要的库
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# 1. 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# 2. 加载数据
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

# 3. 定义模型
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )

def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

model = NeuralNetwork()

# 4. 定义损失函数和优化器
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 5. 训练模型
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    model.train()
    for batch, (X, y) in enumerate(dataloader):
        # 计算预测误差
        pred = model(X)
        loss = loss_fn(pred, y)

# 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

if batch % 100 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")

# 6. 测试模型
def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    model.eval()
    test_loss, correct = 0, 0
    with torch.no_grad():
        for X, y in dataloader:
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= num_batches
    correct /= size
    print(f"测试结果: \n  准确率: {(100*correct):>0.1f}%, 平均损失: {test_loss:>8f}\n")

# 7. 开始训练
epochs = 5
for t in range(epochs):
    print(f"第 {t+1} 轮\n-------------------------------")
    train(train_loader, model, loss_fn, optimizer)
    test(test_loader, model, loss_fn)
print("训练完成！")

提示： TensorFlow 和 PyTorch 都是强大的深度学习框架。对于初学者来说，Keras（TensorFlow 的高级 API）可能更容易上手，因为它提供了更简洁的接口。

实践项目：图像分类

现在让我们通过一个实际的图像分类项目来综合运用所学的深度学习知识：

Python 代码

# 实践项目：使用 Keras 进行 MNIST 手写数字分类
import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt

# 1. 加载数据
(X_train, y_train), (X_test, y_test) = mnist.load_data()
print("原始训练集形状:", X_train.shape)
print("原始测试集形状:", X_test.shape)

# 2. 数据预处理
# 调整形状以适应 CNN 输入
X_train = X_train.reshape((X_train.shape[0], 28, 28, 1))
X_test = X_test.reshape((X_test.shape[0], 28, 28, 1))

# 归一化
X_train = X_train / 255.0
X_test = X_test / 255.0

# 3. 构建 CNN 模型
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    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')
])

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

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

# 6. 训练模型
history = model.fit(X_train, y_train, epochs=5, validation_split=0.2)

# 7. 评估模型
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"测试准确率: {test_acc:.2f}")

# 8. 可视化训练过程
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.xlabel('轮次')
plt.ylabel('准确率')
plt.legend()

# 损失
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='训练损失')
plt.plot(history.history['val_loss'], label='验证损失')
plt.title('损失')
plt.xlabel('轮次')
plt.ylabel('损失')
plt.legend()

plt.tight_layout()
# plt.show()

# 9. 预测测试图像
# 选择前 5 个测试图像进行预测
plt.figure(figsize=(10, 5))
for i in range(5):
    plt.subplot(1, 5, i+1)
    plt.imshow(X_test[i].reshape(28, 28), cmap='gray')
    plt.axis('off')
    # 预测
    prediction = model.predict(X_test[i].reshape(1, 28, 28, 1))
    predicted_label = np.argmax(prediction)
    plt.title(f"预测: {predicted_label}")

plt.tight_layout()
# plt.show()

提示： 这个实践项目展示了如何使用 CNN（卷积神经网络）来进行图像分类。CNN 特别适合处理图像数据，因为它能够自动学习图像中的特征。

完成本单元，返回课程首页