📚 第1章：PyTorch基础概念与安装

本章概述

本章将带您进入PyTorch的世界，从基础概念开始，逐步了解PyTorch的特点、优势以及如何正确安装和配置开发环境。通过本章的学习，您将建立对PyTorch的整体认识，为后续深入学习打下坚实基础。

学习目标

• 理解PyTorch的核心概念和设计哲学
• 掌握PyTorch的安装和环境配置
• 了解PyTorch的生态系统和主要组件
• 编写第一个PyTorch程序
• 理解PyTorch与其他深度学习框架的区别

1.1 PyTorch简介

1.1.1 什么是PyTorch

PyTorch是由Facebook AI Research (FAIR)开发的开源深度学习框架，于2017年正式发布。它基于Torch库，使用Python作为主要编程语言，提供了灵活的深度学习平台。

核心特点

1. 动态计算图：PyTorch使用动态计算图（Define-by-Run），允许在运行时构建和修改网络结构
2. Pythonic设计：API设计符合Python习惯，易于学习和使用
3. 强大的GPU加速：原生支持CUDA，提供高效的GPU计算
4. 丰富的生态系统：包含计算机视觉、自然语言处理等领域的工具库
5. 研究友好：灵活的架构设计，便于快速原型开发和实验

1.1.2 PyTorch的发展历程

# PyTorch发展时间线
timeline = {
    "2016": "Torch的Python版本开始开发",
    "2017": "PyTorch 0.1.0 正式发布",
    "2018": "PyTorch 1.0 发布，引入TorchScript",
    "2019": "PyTorch 1.3 发布，移动端支持",
    "2020": "PyTorch 1.6 发布，自动混合精度",
    "2021": "PyTorch 1.9 发布，TorchScript改进",
    "2022": "PyTorch 1.13 发布，稳定版API",
    "2023": "PyTorch 2.0 发布，编译模式",
    "2024": "持续发展，生态系统完善"
}

for year, milestone in timeline.items():
    print(f"{year}: {milestone}")

1.1.3 PyTorch vs 其他框架

特性	PyTorch	TensorFlow	JAX	Keras
计算图	动态	静态/动态	动态	高级API
易用性	高	中等	中等	高
调试	容易	困难	中等	容易
生产部署	良好	优秀	良好	依赖TF
社区	活跃	活跃	增长中	活跃
研究应用	广泛	广泛	增长中	中等

1.2 PyTorch生态系统

1.2.1 核心组件

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader, Dataset

# PyTorch核心组件展示
print("PyTorch核心组件:")
print(f"1. torch - 核心张量库: {torch.__version__}")
print(f"2. torch.nn - 神经网络模块")
print(f"3. torch.optim - 优化器")
print(f"4. torch.utils.data - 数据处理工具")
print(f"5. torch.nn.functional - 函数式接口")

1.2.2 扩展库

# 主要扩展库
extensions = {
    "torchvision": "计算机视觉工具库",
    "torchaudio": "音频处理工具库", 
    "torchtext": "自然语言处理工具库",
    "torch-geometric": "图神经网络库",
    "pytorch-lightning": "高级训练框架",
    "transformers": "预训练模型库(Hugging Face)",
    "detectron2": "目标检测库",
    "fairseq": "序列建模库"
}

print("PyTorch生态系统:")
for lib, desc in extensions.items():
    print(f"- {lib}: {desc}")

1.3 安装PyTorch

1.3.1 系统要求

硬件要求

• CPU: 支持SSE4.2指令集的x86_64处理器
• 内存: 最少4GB RAM，推荐8GB以上
• GPU: NVIDIA GPU (可选，用于CUDA加速)
• 存储: 至少2GB可用空间

软件要求

• 操作系统: Windows 10+, macOS 10.15+, Linux
• Python: 3.8 - 3.11
• 包管理器: pip 或 conda

1.3.2 安装方法

方法1: 使用pip安装

# 检查Python版本
python --version

# 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

方法2: 使用conda安装

# CPU版本
conda install pytorch torchvision torchaudio cpuonly -c pytorch

# GPU版本
conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia

方法3: 从源码编译

# 克隆源码
git clone --recursive https://github.com/pytorch/pytorch
cd pytorch

# 安装依赖
pip install -r requirements.txt

# 编译安装
python setup.py install

1.3.3 验证安装

# 验证PyTorch安装
import torch
import torchvision
import torchaudio

def verify_installation():
    """验证PyTorch安装是否成功"""
    print("=== PyTorch安装验证 ===")
    
    # 版本信息
    print(f"PyTorch版本: {torch.__version__}")
    print(f"TorchVision版本: {torchvision.__version__}")
    print(f"TorchAudio版本: {torchaudio.__version__}")
    
    # CUDA支持
    print(f"CUDA可用: {torch.cuda.is_available()}")
    if torch.cuda.is_available():
        print(f"CUDA版本: {torch.version.cuda}")
        print(f"GPU数量: {torch.cuda.device_count()}")
        print(f"当前GPU: {torch.cuda.get_device_name(0)}")
    
    # MPS支持 (Apple Silicon)
    if hasattr(torch.backends, 'mps'):
        print(f"MPS可用: {torch.backends.mps.is_available()}")
    
    # 基本张量操作测试
    x = torch.randn(3, 3)
    y = torch.randn(3, 3)
    z = x + y
    print(f"张量运算测试: {z.shape}")
    
    print("✅ PyTorch安装验证成功!")
    return True

# 运行验证
verify_installation()

1.3.4 环境配置

创建虚拟环境

# 使用venv
python -m venv pytorch_env
source pytorch_env/bin/activate  # Linux/Mac
pytorch_env\Scripts\activate     # Windows

# 使用conda
conda create -n pytorch_env python=3.9
conda activate pytorch_env

配置Jupyter Notebook

# 安装Jupyter
pip install jupyter notebook

# 安装内核
python -m ipykernel install --user --name pytorch_env --display-name "PyTorch"

# 启动Jupyter
jupyter notebook

1.4 第一个PyTorch程序

1.4.1 Hello PyTorch

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

def hello_pytorch():
    """第一个PyTorch程序：线性回归"""
    print("🔥 Hello PyTorch!")
    
    # 设置随机种子
    torch.manual_seed(42)
    
    # 生成模拟数据
    n_samples = 100
    X = torch.randn(n_samples, 1)
    y = 3 * X + 2 + 0.1 * torch.randn(n_samples, 1)  # y = 3x + 2 + noise
    
    print(f"数据形状: X={X.shape}, y={y.shape}")
    
    # 定义线性模型
    class LinearModel(nn.Module):
        def __init__(self):
            super(LinearModel, self).__init__()
            self.linear = nn.Linear(1, 1)
        
        def forward(self, x):
            return self.linear(x)
    
    # 创建模型、损失函数和优化器
    model = LinearModel()
    criterion = nn.MSELoss()
    optimizer = optim.SGD(model.parameters(), lr=0.01)
    
    print(f"模型参数: {list(model.parameters())}")
    
    # 训练模型
    losses = []
    for epoch in range(1000):
        # 前向传播
        y_pred = model(X)
        loss = criterion(y_pred, y)
        
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        losses.append(loss.item())
        
        if (epoch + 1) % 200 == 0:
            print(f"Epoch [{epoch+1}/1000], Loss: {loss.item():.4f}")
    
    # 获取学习到的参数
    with torch.no_grad():
        weight = model.linear.weight.item()
        bias = model.linear.bias.item()
        print(f"学习到的参数: weight={weight:.3f}, bias={bias:.3f}")
        print(f"真实参数: weight=3.000, bias=2.000")
    
    # 可视化结果
    plt.figure(figsize=(12, 4))
    
    # 损失曲线
    plt.subplot(1, 2, 1)
    plt.plot(losses)
    plt.title('Training Loss')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.grid(True)
    
    # 拟合结果
    plt.subplot(1, 2, 2)
    with torch.no_grad():
        X_test = torch.linspace(-3, 3, 100).unsqueeze(1)
        y_test = model(X_test)
        
        plt.scatter(X.numpy(), y.numpy(), alpha=0.5, label='Data')
        plt.plot(X_test.numpy(), y_test.numpy(), 'r-', label='Fitted line')
        plt.xlabel('X')
        plt.ylabel('y')
        plt.title('Linear Regression Result')
        plt.legend()
        plt.grid(True)
    
    plt.tight_layout()
    plt.show()
    
    return model, losses

# 运行第一个程序
model, losses = hello_pytorch()

1.4.2 张量基础操作

def tensor_basics():
    """PyTorch张量基础操作演示"""
    print("\n=== 张量基础操作 ===")
    
    # 创建张量
    print("1. 创建张量:")
    a = torch.tensor([1, 2, 3, 4])
    b = torch.zeros(2, 3)
    c = torch.ones(2, 3)
    d = torch.randn(2, 3)
    
    print(f"a = {a}")
    print(f"b = \n{b}")
    print(f"c = \n{c}")
    print(f"d = \n{d}")
    
    # 张量属性
    print("\n2. 张量属性:")
    print(f"形状: {d.shape}")
    print(f"数据类型: {d.dtype}")
    print(f"设备: {d.device}")
    print(f"维度: {d.ndim}")
    print(f"元素总数: {d.numel()}")
    
    # 张量运算
    print("\n3. 张量运算:")
    x = torch.randn(2, 3)
    y = torch.randn(2, 3)
    
    print(f"x = \n{x}")
    print(f"y = \n{y}")
    print(f"x + y = \n{x + y}")
    print(f"x * y = \n{x * y}")
    print(f"x @ y.T = \n{x @ y.T}")
    
    # 形状变换
    print("\n4. 形状变换:")
    z = torch.randn(2, 3, 4)
    print(f"原始形状: {z.shape}")
    print(f"view(6, 4): {z.view(6, 4).shape}")
    print(f"reshape(-1, 2): {z.reshape(-1, 2).shape}")
    print(f"transpose(0, 2): {z.transpose(0, 2).shape}")
    
    # 索引和切片
    print("\n5. 索引和切片:")
    matrix = torch.arange(12).reshape(3, 4)
    print(f"matrix = \n{matrix}")
    print(f"matrix[0] = {matrix[0]}")
    print(f"matrix[:, 1] = {matrix[:, 1]}")
    print(f"matrix[1:, 2:] = \n{matrix[1:, 2:]}")
    
    return x, y, z

# 运行张量基础操作
x, y, z = tensor_basics()

1.4.3 GPU加速示例

def gpu_acceleration_demo():
    """GPU加速演示"""
    print("\n=== GPU加速演示 ===")
    
    # 检查GPU可用性
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"使用设备: {device}")
    
    if torch.cuda.is_available():
        print(f"GPU名称: {torch.cuda.get_device_name(0)}")
        print(f"GPU内存: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
    
    # 创建大型张量
    size = 5000
    print(f"\n创建 {size}x{size} 矩阵...")
    
    # CPU计算
    import time
    
    print("CPU计算:")
    start_time = time.time()
    a_cpu = torch.randn(size, size)
    b_cpu = torch.randn(size, size)
    c_cpu = torch.mm(a_cpu, b_cpu)
    cpu_time = time.time() - start_time
    print(f"CPU矩阵乘法时间: {cpu_time:.3f} 秒")
    
    # GPU计算 (如果可用)
    if torch.cuda.is_available():
        print("\nGPU计算:")
        start_time = time.time()
        a_gpu = torch.randn(size, size, device=device)
        b_gpu = torch.randn(size, size, device=device)
        torch.cuda.synchronize()  # 确保GPU操作完成
        
        start_time = time.time()
        c_gpu = torch.mm(a_gpu, b_gpu)
        torch.cuda.synchronize()
        gpu_time = time.time() - start_time
        print(f"GPU矩阵乘法时间: {gpu_time:.3f} 秒")
        print(f"加速比: {cpu_time/gpu_time:.1f}x")
        
        # 验证结果一致性
        c_gpu_cpu = c_gpu.cpu()
        print(f"结果一致性检查: {torch.allclose(c_cpu, c_gpu_cpu, atol=1e-4)}")
    else:
        print("GPU不可用，跳过GPU计算")

# 运行GPU加速演示
gpu_acceleration_demo()

1.5 开发环境配置

1.5.1 IDE配置

PyCharm配置

# PyCharm配置建议
pycharm_settings = {
    "解释器": "选择正确的Python环境",
    "代码风格": "PEP 8",
    "插件推荐": [
        "Python",
        "Jupyter",
        "Markdown",
        "Git Integration"
    ],
    "调试配置": {
        "断点": "支持条件断点",
        "变量查看": "支持张量可视化",
        "GPU调试": "CUDA调试支持"
    }
}

print("PyCharm配置建议:")
for key, value in pycharm_settings.items():
    print(f"{key}: {value}")

VS Code配置

// settings.json
{
    "python.defaultInterpreterPath": "./pytorch_env/bin/python",
    "python.linting.enabled": true,
    "python.linting.pylintEnabled": true,
    "python.formatting.provider": "black",
    "jupyter.askForKernelRestart": false,
    "files.associations": {
        "*.py": "python"
    }
}

1.5.2 调试工具

def debugging_tools():
    """调试工具演示"""
    print("=== PyTorch调试工具 ===")
    
    # 1. 张量信息查看
    def tensor_info(tensor, name="tensor"):
        print(f"\n{name} 信息:")
        print(f"  形状: {tensor.shape}")
        print(f"  数据类型: {tensor.dtype}")
        print(f"  设备: {tensor.device}")
        print(f"  是否需要梯度: {tensor.requires_grad}")
        print(f"  内存使用: {tensor.element_size() * tensor.numel()} bytes")
        if tensor.numel() <= 20:
            print(f"  数值: {tensor}")
        else:
            print(f"  数值范围: [{tensor.min():.3f}, {tensor.max():.3f}]")
    
    # 2. 梯度检查
    def check_gradients(model):
        print("\n梯度检查:")
        for name, param in model.named_parameters():
            if param.grad is not None:
                grad_norm = param.grad.norm().item()
                print(f"  {name}: 梯度范数 = {grad_norm:.6f}")
                if grad_norm == 0:
                    print(f"    ⚠️  {name} 梯度为零!")
                elif grad_norm > 10:
                    print(f"    ⚠️  {name} 梯度过大!")
            else:
                print(f"  {name}: 无梯度")
    
    # 3. 内存使用监控
    def memory_usage():
        if torch.cuda.is_available():
            print(f"\nGPU内存使用:")
            print(f"  已分配: {torch.cuda.memory_allocated() / 1e9:.2f} GB")
            print(f"  已缓存: {torch.cuda.memory_reserved() / 1e9:.2f} GB")
            print(f"  最大使用: {torch.cuda.max_memory_allocated() / 1e9:.2f} GB")
    
    # 示例使用
    x = torch.randn(100, 50, requires_grad=True)
    tensor_info(x, "输入张量")
    
    # 简单模型
    model = nn.Linear(50, 10)
    y = model(x)
    loss = y.sum()
    loss.backward()
    
    check_gradients(model)
    memory_usage()

# 运行调试工具演示
debugging_tools()

1.5.3 性能分析

def performance_profiling():
    """性能分析工具"""
    print("=== 性能分析工具 ===")
    
    # 1. 时间分析
    import torch.profiler
    
    def model_forward(x):
        model = nn.Sequential(
            nn.Linear(100, 200),
            nn.ReLU(),
            nn.Linear(200, 100),
            nn.ReLU(),
            nn.Linear(100, 10)
        )
        return model(x)
    
    # 使用profiler
    x = torch.randn(32, 100)
    
    with torch.profiler.profile(
        activities=[
            torch.profiler.ProfilerActivity.CPU,
            torch.profiler.ProfilerActivity.CUDA,
        ],
        record_shapes=True,
        profile_memory=True,
        with_stack=True
    ) as prof:
        for _ in range(10):
            y = model_forward(x)
    
    # 输出分析结果
    print("性能分析结果:")
    print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=10))
    
    # 2. 内存分析
    def memory_profiling():
        print("\n内存分析:")
        
        # 记录内存使用
        if torch.cuda.is_available():
            torch.cuda.reset_peak_memory_stats()
            
            x = torch.randn(1000, 1000, device='cuda')
            y = torch.randn(1000, 1000, device='cuda')
            z = torch.mm(x, y)
            
            print(f"峰值内存使用: {torch.cuda.max_memory_allocated() / 1e9:.2f} GB")
    
    memory_profiling()

# 运行性能分析
performance_profiling()

1.6 常见问题与解决方案

1.6.1 安装问题

def troubleshooting():
    """常见问题排查"""
    print("=== 常见问题排查 ===")
    
    # 1. 版本兼容性检查
    def check_compatibility():
        print("1. 版本兼容性检查:")
        import sys
        print(f"Python版本: {sys.version}")
        print(f"PyTorch版本: {torch.__version__}")
        
        # 检查CUDA兼容性
        if torch.cuda.is_available():
            print(f"CUDA版本: {torch.version.cuda}")
            print(f"cuDNN版本: {torch.backends.cudnn.version()}")
        
        # 版本建议
        recommendations = {
            "Python 3.8": "PyTorch 1.7+",
            "Python 3.9": "PyTorch 1.7+", 
            "Python 3.10": "PyTorch 1.11+",
            "Python 3.11": "PyTorch 1.13+"
        }
        
        python_version = f"Python {sys.version_info.major}.{sys.version_info.minor}"
        if python_version in recommendations:
            print(f"推荐PyTorch版本: {recommendations[python_version]}")
    
    # 2. 常见错误解决
    def common_errors():
        print("\n2. 常见错误及解决方案:")
        
        errors_solutions = {
            "CUDA out of memory": [
                "减少batch_size",
                "使用gradient_checkpointing",
                "清理GPU缓存: torch.cuda.empty_cache()",
                "使用混合精度训练"
            ],
            "RuntimeError: Expected all tensors to be on the same device": [
                "确保模型和数据在同一设备",
                "使用 .to(device) 移动张量",
                "检查模型定义中的设备一致性"
            ],
            "ImportError: No module named 'torch'": [
                "检查虚拟环境是否激活",
                "重新安装PyTorch",
                "检查Python路径"
            ]
        }
        
        for error, solutions in errors_solutions.items():
            print(f"\n错误: {error}")
            for i, solution in enumerate(solutions, 1):
                print(f"  {i}. {solution}")
    
    # 3. 性能优化建议
    def performance_tips():
        print("\n3. 性能优化建议:")
        
        tips = [
            "使用 torch.compile() 编译模型 (PyTorch 2.0+)",
            "启用 cudnn.benchmark = True",
            "使用 DataLoader 的 num_workers 参数",
            "避免频繁的 CPU-GPU 数据传输",
            "使用 torch.no_grad() 在推理时",
            "考虑使用 torch.jit.script() 优化模型"
        ]
        
        for i, tip in enumerate(tips, 1):
            print(f"{i}. {tip}")
    
    check_compatibility()
    common_errors()
    performance_tips()

# 运行问题排查
troubleshooting()

1.6.2 环境诊断脚本

def environment_diagnosis():
    """完整的环境诊断脚本"""
    print("🔍 PyTorch环境诊断报告")
    print("=" * 50)
    
    import sys
    import platform
    import subprocess
    
    # 系统信息
    print("📋 系统信息:")
    print(f"操作系统: {platform.system()} {platform.release()}")
    print(f"架构: {platform.machine()}")
    print(f"Python版本: {sys.version}")
    print(f"Python路径: {sys.executable}")
    
    # PyTorch信息
    print(f"\n🔥 PyTorch信息:")
    try:
        import torch
        print(f"PyTorch版本: {torch.__version__}")
        print(f"PyTorch路径: {torch.__file__}")
        print(f"编译版本: {torch.version.git_version}")
        
        # CUDA信息
        print(f"\n🚀 CUDA信息:")
        print(f"CUDA可用: {torch.cuda.is_available()}")
        if torch.cuda.is_available():
            print(f"CUDA版本: {torch.version.cuda}")
            print(f"cuDNN版本: {torch.backends.cudnn.version()}")
            print(f"GPU数量: {torch.cuda.device_count()}")
            for i in range(torch.cuda.device_count()):
                props = torch.cuda.get_device_properties(i)
                print(f"GPU {i}: {props.name}")
                print(f"  内存: {props.total_memory / 1e9:.1f} GB")
                print(f"  计算能力: {props.major}.{props.minor}")
        
        # 扩展库信息
        print(f"\n📦 扩展库信息:")
        extensions = ['torchvision', 'torchaudio', 'torchtext']
        for ext in extensions:
            try:
                module = __import__(ext)
                print(f"{ext}: {module.__version__}")
            except ImportError:
                print(f"{ext}: 未安装")
        
        # 性能测试
        print(f"\n⚡ 性能测试:")
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        x = torch.randn(1000, 1000, device=device)
        y = torch.randn(1000, 1000, device=device)
        
        import time
        start = time.time()
        z = torch.mm(x, y)
        if device.type == 'cuda':
            torch.cuda.synchronize()
        end = time.time()
        
        print(f"矩阵乘法 (1000x1000) 在 {device}: {(end-start)*1000:.2f} ms")
        
    except ImportError as e:
        print(f"❌ PyTorch导入失败: {e}")
    
    print("\n✅ 诊断完成!")

# 运行环境诊断
environment_diagnosis()

1.7 本章总结

1.7.1 关键概念回顾

def chapter_summary():
    """第1章关键概念总结"""
    print("📚 第1章总结：PyTorch基础概念与安装")
    print("=" * 50)
    
    key_concepts = {
        "PyTorch特点": [
            "动态计算图",
            "Pythonic设计", 
            "强大的GPU支持",
            "丰富的生态系统"
        ],
        "核心组件": [
            "torch - 核心张量库",
            "torch.nn - 神经网络模块",
            "torch.optim - 优化器",
            "torch.utils.data - 数据处理"
        ],
        "安装方式": [
            "pip install torch",
            "conda install pytorch",
            "从源码编译"
        ],
        "开发环境": [
            "PyCharm/VS Code配置",
            "Jupyter Notebook",
            "调试和性能分析工具"
        ]
    }
    
    for category, items in key_concepts.items():
        print(f"\n{category}:")
        for item in items:
            print(f"  • {item}")
    
    print(f"\n🎯 学习成果:")
    achievements = [
        "✅ 理解PyTorch的核心概念和优势",
        "✅ 成功安装和配置PyTorch环境", 
        "✅ 编写第一个PyTorch程序",
        "✅ 掌握基本的张量操作",
        "✅ 了解GPU加速的使用方法",
        "✅ 配置开发和调试环境"
    ]
    
    for achievement in achievements:
        print(f"  {achievement}")

# 显示章节总结
chapter_summary()

1.7.2 下一章预告

def next_chapter_preview():
    """下一章内容预告"""
    print(f"\n🔮 下一章预告：张量操作与自动微分")
    print("=" * 40)
    
    preview = [
        "🔢 深入理解PyTorch张量",
        "🔄 张量的创建、变换和操作",
        "📐 广播机制和高级索引",
        "🎯 自动微分系统详解",
        "📊 梯度计算和反向传播",
        "🧮 计算图的构建和优化"
    ]
    
    for item in preview:
        print(f"  {item}")
    
    print(f"\n💡 学习建议:")
    suggestions = [
        "确保本章的环境配置正确",
        "多练习基本的张量操作",
        "理解动态计算图的概念",
        "准备线性代数基础知识"
    ]
    
    for suggestion in suggestions:
        print(f"  • {suggestion}")

# 显示下一章预告
next_chapter_preview()

1.7.3 练习题

def practice_exercises():
    """本章练习题"""
    print(f"\n📝 本章练习题")
    print("=" * 30)
    
    exercises = {
        "基础练习": [
            "安装PyTorch并验证GPU支持",
            "创建不同类型的张量并查看属性",
            "实现简单的张量运算",
            "编写环境诊断脚本"
        ],
        "进阶练习": [
            "比较CPU和GPU的计算性能",
            "实现一个简单的线性回归模型",
            "使用profiler分析模型性能",
            "配置完整的开发环境"
        ],
        "项目练习": [
            "创建PyTorch项目模板",
            "实现数据加载和预处理管道",
            "构建可复用的训练框架",
            "编写完整的模型训练脚本"
        ]
    }
    
    for level, tasks in exercises.items():
        print(f"\n{level}:")
        for i, task in enumerate(tasks, 1):
            print(f"  {i}. {task}")
    
    print(f"\n🎯 完成建议:")
    print("  • 按难度顺序完成练习")
    print("  • 每个练习都要动手实践")
    print("  • 遇到问题及时查阅文档")
    print("  • 可以参考官方教程和示例")

# 显示练习题
practice_exercises()

---

🎉 恭喜完成第1章！

您已经成功完成了PyTorch基础概念与安装的学习。现在您应该：

• ✅ 理解PyTorch的核心概念和优势
• ✅ 成功安装和配置PyTorch环境
• ✅ 能够编写基本的PyTorch程序
• ✅ 掌握张量的基本操作
• ✅ 了解GPU加速的使用方法

下一步：继续学习第2章：张量操作与自动微分，深入理解PyTorch的核心数据结构和自动微分机制。

记住：深度学习是一门实践性很强的技能，多写代码、多做实验是成功的关键！🚀