第1章：机器学习核心概念
    ↓
理解监督学习/无监督学习
    ↓
掌握损失函数和优化器
    ↓
实战：MNIST分类（sklearn）
    ↓
第2章：从传统特征到深度学习
    ↓
了解SIFT、HOG等传统特征
    ↓
理解深度学习的优势
    ↓
准备深度学习环境
    ↓
进入第二篇：深度学习基础

# Python版本
Python 3.10+

# 第1章所需库
pip install scikit-learn numpy matplotlib

# 第2章所需库（传统特征）
pip install opencv-python scikit-image

# 深度学习环境（第2章末尾准备）
pip install torch torchvision  # PyTorch
# 或
pip install tensorflow         # TensorFlow

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

# 生成分类数据
X, y = make_classification(n_samples=100, n_features=20, n_classes=2)

# 监督学习：训练数据包含X和y
model = LogisticRegression()
model.fit(X, y)  # 需要标签y

# 预测
predictions = model.predict(X)

from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs

# 生成聚类数据
X, _ = make_blobs(n_samples=100, n_features=2, centers=3)

# 无监督学习：训练数据只有X
model = KMeans(n_clusters=3)
model.fit(X)  # 不需要标签

# 聚类结果
labels = model.predict(X)

import numpy as np

def mse_loss(y_true, y_pred):
    """均方误差损失"""
    return np.mean((y_true - y_pred) ** 2)

# 示例
y_true = np.array([1.0, 2.0, 3.0])
y_pred = np.array([1.1, 2.2, 2.9])
loss = mse_loss(y_true, y_pred)
print(f"MSE Loss: {loss:.4f}")  # 0.0233

def binary_cross_entropy(y_true, y_pred):
    """二分类交叉熵"""
    epsilon = 1e-15  # 防止log(0)
    y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
    return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))

# 示例
y_true = np.array([1, 0, 1])
y_pred = np.array([0.9, 0.1, 0.8])
loss = binary_cross_entropy(y_true, y_pred)
print(f"BCE Loss: {loss:.4f}")  # 0.1336

# sklearn中的SGD示例
from sklearn.linear_model import SGDClassifier

model = SGDClassifier(
    loss='log_loss',        # 损失函数
    learning_rate='constant',  # 学习率策略
    eta0=0.01,             # 初始学习率
    max_iter=1000
)

训练误差和测试误差随模型复杂度变化：

误差
 ↑
 |          测试误差
 |         /‾‾‾‾‾
 |        /
 |       /
 |      /
 |     /_________ 训练误差
 |
 └─────────────────→ 模型复杂度
        ↑
    最佳复杂度

from sklearn.linear_model import Lasso

# L1正则化
model = Lasso(alpha=0.1)  # alpha是正则化强度

from sklearn.linear_model import Ridge

# L2正则化
model = Ridge(alpha=1.0)  # alpha是正则化强度

from sklearn.linear_model import ElasticNet

# L1 + L2正则化
model = ElasticNet(alpha=0.1, l1_ratio=0.5)  # l1_ratio控制L1和L2的比例

# 详见 code/chapter01_ml_basics/mnist_sklearn.py

# 1. 安装依赖
pip install scikit-learn numpy matplotlib

# 2. 运行代码
cd chapter01/code
python mnist_sklearn.py

数据集信息：
训练集: 60000 samples
测试集: 10000 samples
图像尺寸: 28x28

模型性能比较：
Logistic Regression - 准确率: 92.50%
Random Forest - 准确率: 96.80%
SVM - 准确率: 94.20%

最佳模型: Random Forest

from sklearn.datasets import fetch_openml

# 加载MNIST数据集
mnist = fetch_openml('mnist_784', version=1, parser='auto')
X, y = mnist.data, mnist.target

# 归一化
X = X / 255.0

# 划分训练集和测试集
X_train, X_test = X[:60000], X[60000:]
y_train, y_test = y[:60000], y[60000:]

from sklearn.linear_model import LogisticRegression

model = LogisticRegression(max_iter=100)
model.fit(X_train, y_train)

from sklearn.metrics import accuracy_score, classification_report

y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy:.2%}")

原始图像 → 手工设计的特征提取器 → 特征向量 → 分类器 → 预测结果

import cv2
import numpy as np
import matplotlib.pyplot as plt

def detect_sift_features(image_path):
    """
    使用SIFT检测和提取特征

    Args:
        image_path: 图像路径
    """
    # 读取图像（灰度）
    img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

    # 创建SIFT检测器
    sift = cv2.SIFT_create()

    # 检测关键点和计算描述子
    keypoints, descriptors = sift.detectAndCompute(img, None)

    # 绘制关键点
    img_keypoints = cv2.drawKeypoints(
        img,
        keypoints,
        None,
        flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS
    )

    print(f"检测到 {len(keypoints)} 个关键点")
    print(f"描述子维度: {descriptors.shape}")

    # 显示结果
    plt.figure(figsize=(12, 6))
    plt.imshow(img_keypoints, cmap='gray')
    plt.title(f'SIFT关键点 (共{len(keypoints)}个)')
    plt.axis('off')
    plt.tight_layout()
    plt.savefig('sift_keypoints.png', dpi=150, bbox_inches='tight')
    plt.close()

    return keypoints, descriptors

# 使用示例
# keypoints, descriptors = detect_sift_features('image.jpg')

from skimage.feature import hog
from skimage import exposure
import matplotlib.pyplot as plt

def extract_hog_features(image, visualize=True):
    """
    提取HOG特征

    Args:
        image: 输入图像（灰度）
        visualize: 是否可视化

    Returns:
        features: HOG特征向量
        hog_image: HOG可视化图像（如果visualize=True）
    """
    # 提取HOG特征
    features, hog_image = hog(
        image,
        orientations=9,           # 梯度方向的bins数量
        pixels_per_cell=(8, 8),   # 每个cell的像素数
        cells_per_block=(2, 2),   # 每个block的cell数
        visualize=visualize,
        block_norm='L2-Hys'       # 归一化方法
    )

    if visualize:
        # 增强对比度以便可视化
        hog_image_rescaled = exposure.rescale_intensity(
            hog_image,
            in_range=(0, 10)
        )

        # 显示原图和HOG特征
        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))

        ax1.imshow(image, cmap='gray')
        ax1.set_title('原始图像')
        ax1.axis('off')

        ax2.imshow(hog_image_rescaled, cmap='gray')
        ax2.set_title('HOG特征可视化')
        ax2.axis('off')

        plt.tight_layout()
        plt.savefig('hog_features.png', dpi=150, bbox_inches='tight')
        plt.close()

    print(f"HOG特征维度: {len(features)}")

    return features, hog_image if visualize else None

# 使用示例
# features, hog_img = extract_hog_features(gray_image)

传统方法：
  图像 → 手工特征（数百到数千维）→ 分类器

深度学习：
  图像 → 自动学习特征（数百万参数）→ 分类

| 变化类型 | 传统方法应对 | 效果 |
|---------|------------|------|
| 光照变化 | 归一化、不变特征 | 中等 |
| 尺度变化 | 多尺度检测 | 较好 |
| 视角变化 | 3D特征、视角不变性 | 较差 |
| 遮挡 | 局部特征 | 较差 |
| 类内变化 | 特征选择 | 较差 |

传统方法：
  ┌──────────┐    ┌──────────┐    ┌──────────┐
  │ 原始图像 │ →  │ 手工特征 │ →  │  分类器  │
  └──────────┘    └──────────┘    └──────────┘
                      ↑
                  需要人工设计

深度学习：
  ┌──────────┐    ┌──────────────────────┐    ┌──────────┐
  │ 原始图像 │ →  │ 自动学习的特征层级   │ →  │  分类器  │
  └──────────┘    └──────────────────────┘    └──────────┘
                  低级特征 → 中级特征 → 高级特征
                      ↑
                  端到端学习

卷积神经网络（CNN）的特征层次：

第1层（低级特征）：
  - 边缘检测器
  - 颜色斑点
  - 简单纹理

第2-3层（中级特征）：
  - 简单形状
  - 纹理组合
  - 局部模式

第4-5层（高级特征）：
  - 物体部件（眼睛、轮子等）
  - 复杂模式
  - 语义概念

输入图像(猫)
    ↓
[第1层] 边缘、纹理
    ↓
[第2层] 简单形状
    ↓
[第3层] 猫的局部特征（耳朵、眼睛）
    ↓
[第4层] 猫的整体特征
    ↓
输出：猫（95%置信度）

性能
  ↑
  |              深度学习
  |            /
  |          /
  |        /
  |      /______ 传统方法（性能饱和）
  |    /
  |  /
  |/
  └─────────────────────→ 数据量

# 使用预训练的ResNet模型
import torchvision.models as models

# 加载ImageNet预训练模型
resnet = models.resnet50(pretrained=True)

# 只替换最后一层用于新任务
num_classes = 10  # 新任务的类别数
resnet.fc = nn.Linear(resnet.fc.in_features, num_classes)

# 只训练最后一层，其他层使用预训练权重
for param in resnet.parameters():
    param.requires_grad = False
resnet.fc.weight.requires_grad = True
resnet.fc.bias.requires_grad = True

# 1. 创建虚拟环境（推荐）
python -m venv cv_env
source cv_env/bin/activate  # Windows: cv_env\Scripts\activate

# 2. 安装PyTorch（根据CUDA版本选择）
# CPU版本
pip install torch torchvision torchaudio

# GPU版本（CUDA 11.8）
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# GPU版本（CUDA 12.1）
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# 3. 安装其他依赖
pip install numpy matplotlib opencv-python scikit-image

import torch
import torchvision

print(f"PyTorch版本: {torch.__version__}")
print(f"TorchVision版本: {torchvision.__version__}")
print(f"CUDA可用: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"CUDA版本: {torch.version.cuda}")
    print(f"GPU设备: {torch.cuda.get_device_name(0)}")

PyTorch版本: 2.1.0+cu118
TorchVision版本: 0.16.0+cu118
CUDA可用: True
CUDA版本: 11.8
GPU设备: NVIDIA GeForce RTX 3080

# 安装TensorFlow（包含GPU支持）
pip install tensorflow

# 验证安装
python -c "import tensorflow as tf; print(f'TensorFlow版本: {tf.__version__}'); print(f'GPU可用: {len(tf.config.list_physical_devices(\"GPU\"))}')"

# 深度学习框架
torch>=2.0.0
torchvision>=0.15.0
torchaudio>=2.0.0

# 图像处理
opencv-python>=4.8.0
scikit-image>=0.21.0
Pillow>=10.0.0

# 数据处理
numpy>=1.24.0
pandas>=2.0.0
matplotlib>=3.7.0
seaborn>=0.12.0

# 机器学习工具
scikit-learn>=1.3.0

# 进度条和可视化
tqdm>=4.65.0
tensorboard>=2.13.0

# Jupyter支持
jupyter>=1.0.0
ipywidgets>=8.0.0

pip install -r requirements.txt

cd chapter02/code
python test_environment.py

========================================
环境测试开始
========================================

[测试1] PyTorch安装
  ✓ PyTorch版本: 2.1.0+cu118
  ✓ CUDA可用: True
  ✓ GPU设备: NVIDIA GeForce RTX 3080

[测试2] 张量操作
  ✓ CPU张量创建成功
  ✓ GPU张量创建成功
  ✓ 张量运算正确

[测试3] 图像处理库
  ✓ OpenCV版本: 4.8.0
  ✓ scikit-image可用

[测试4] 数据加载
  ✓ MNIST数据集加载成功
  ✓ 数据形状: torch.Size([1, 28, 28])

========================================
所有测试通过！环境配置成功。
========================================

import torch
import torch.nn as nn

# 定义简单的全连接神经网络
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28 * 28, 128)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = x.view(-1, 28 * 28)  # 展平
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

# 训练模型
model = SimpleNN()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# 训练循环（简化版）
for epoch in range(10):
    for images, labels in train_loader:
        outputs = model(images)
        loss = criterion(outputs, labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

传统计算机视觉流程：
  图像 → 预处理 → 特征提取(手工) → 分类器 → 结果

深度学习流程：
  图像 → 神经网络(端到端) → 结果
           ↓
      自动学习特征