# CPU 版本
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu

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

import torch

# 创建张量的几种方式
tensor1 = torch.tensor([1, 2, 3])  # 从列表创建
tensor2 = torch.zeros(2, 3)       # 创建一个 2x3 的全 0 张量
tensor3 = torch.ones(3, 3)        # 创建一个 3x3 的全 1 张量
tensor4 = torch.rand(2, 2)        # 创建一个 2x2 的随机张量(0-1之间)
tensor5 = torch.arange(0, 10, 2)  # 创建等差数列张量，从0到10步长为2的一维张量，结果是tensor([0, 2, 4, 6, 8])
tensor6 = torch.linspace(0, 1, 5) # 创建线性等分张量，在指定区间上均匀分布的一维张量，结果是tensor([0.0000, 0.2500, 0.5000, 0.7500, 1.0000])

# 从NumPy数组创建
import numpy as np
np_array = np.array([[1, 2], [3, 4]])
tensor7 = torch.from_numpy(np_array)

# 将张量转换回NumPy数组
np_array_back = tensor7.numpy()

# 在指定设备（CPU/GPU）上创建张量
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
d = torch.randn(2, 3, device=device)
print(d)

tensor = torch.rand(3, 4)

print(tensor.shape)    # 张量形状: torch.Size([3, 4])
print(tensor.size())   # 与shape相同
print(tensor.dtype)    # 数据类型: torch.float32
print(tensor.device)   # 设备: cpu或cuda:0等
print(tensor.requires_grad)  # 是否需要梯度: False

# 形状操作
tensor = torch.rand(4, 4)
reshaped = tensor.view(2, 8)  # 改变形状
flattened = tensor.flatten()  # 展平张量
transposed = tensor.t()       # 转置(仅适用于2维张量)

# 数学运算
a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])

print(a + b)      # 加法   tensor([5, 7, 9])
print(torch.add(a, b))  # 加法的另一种形式  tensor([5, 7, 9])
print(a * b)      # 乘法   tensor([ 4, 10, 18])
print(torch.matmul(a, b))  # 矩阵乘法(点积)  tensor(32)  

# 索引和切片
tensor = torch.rand(3, 4)
print(tensor[0])      # 第一行
print(tensor[:, 0])   # 第一列
print(tensor[1:3, 1:3])  # 切片

# 创建需要计算梯度的张量
x = torch.tensor([2.0], requires_grad=True)
y = x **2 + 3*x + 1

# 反向传播计算梯度
y.backward()

# 查看梯度
print(x.grad)  # 输出 tensor([7.])，因为y对x的导数是2x+3，当x=2时为7

import torch
import torch.nn as nn

class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()  # 初始化父类
        # 定义网络层（如全连接层）
        self.fc = nn.Linear(in_features=10, out_features=2)

    def forward(self, x):
        # 定义前向传播：输入x → 经过fc层 → 输出
        return self.fc(x)

import torch.nn.functional as F

# ReLU 激活
output = F.relu(input_tensor)

# Sigmoid 激活
output = torch.sigmoid(input_tensor)

# Tanh 激活
output = torch.tanh(input_tensor)

# 均方误差损失
criterion = nn.MSELoss()

# 交叉熵损失
criterion = nn.CrossEntropyLoss()

# 二分类交叉熵损失
criterion = nn.BCEWithLogitsLoss()

import torch.optim as optim

# 使用 SGD 优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 使用 Adam 优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 定义转换流水线
transform = transforms.Compose([
    transforms.ToTensor(),  # 将图像转换为张量
    # 对张量进行标准化处理,参数为均值和标准差，这里使用MNIST数据集的全局均值0.1307和标准差0.3081
    transforms.Normalize((0.1307,), (0.3081,))
])

# 加载训练数据集
# root: 数据保存路径
# train=True: 加载训练集
# download=True: 如果数据不存在则自动下载
# transform: 应用上面定义好的预处理操作
train_dataset = datasets.MNIST(
    root='./data', 
    train=True, 
    download=True, 
    transform=transform     # 这里将数据应用了定义好的换行流水线transform进行数据预处理
)

# 加载测试数据集
# train=False: 加载测试集
test_dataset = datasets.MNIST(
    root='./data',
    train=False,
    download=True,
    transform=transform
)

# 创建数据加载器，用于批量加载数据
# batch_size=64: 每个批次包含64个样本
# shuffle=True: 训练时打乱数据顺序，增加随机性
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# 测试数据加载器
# 批量更大(1000)，不需要打乱顺序
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

from torchvision import transforms

# 定义转换流水线
transform_pipeline = transforms.Compose([
    转换操作1,
    转换操作2,
    ...,
    转换操作N
])

from torch.utils.data import DataLoader

data_loader = DataLoader(
    dataset,          # 必需参数：数据集对象
    batch_size=1,     # 批次大小，默认1
    shuffle=False,    # 是否打乱数据，默认False
    sampler=None,     # 采样器，用于自定义数据采样方式
    batch_sampler=None,# 批次采样器，与batch_size、shuffle等互斥
    num_workers=0,    # 数据加载的进程数，默认0（主进程加载）
    collate_fn=None,  # 自定义批处理函数
    pin_memory=False, # 是否将数据存入CUDA固定内存
    drop_last=False,  # 是否丢弃最后一个不完整批次
    timeout=0,        # 加载数据的超时时间
    worker_init_fn=None, # 工作进程初始化函数
    multiprocessing_context=None # 多进程上下文
)

# 创建 DataLoader 后，可以通过迭代器的方式获取数据
for batch_idx, (data, labels) in enumerate(train_loader):
    # data: 一个批次的输入数据（形状为 [64, ...]，取决于数据集）
    # labels: 对应批次的标签
    # 在这里编写模型训练代码（前向传播、计算损失、反向传播等）

# 神经网络模型
class MNISTNet(nn.Module):
    # 初始化方法，定义网络结构
    def __init__(self):
        # 调用父类的初始化方法
        super().__init__()

        # 定义第一个全连接层
        # 输入特征数：28*28（MNIST图像的像素展开）
        # 输出特征数：256（自定义的隐藏层大小）
        self.fc1 = nn.Linear(28 * 28, 256)

        # 定义第二个全连接层
        # 输入特征数：256（上一层的输出）
        # 输出特征数：128
        self.fc2 = nn.Linear(256, 128)

        # 定义输出层
        # 输入特征数：128
        # 输出特征数：10（对应10个数字类别）
        self.fc3 = nn.Linear(128, 10)

        # 定义Dropout层，用于防止过拟合
        # 参数0.2表示有20%的概率随机丢弃神经元
        self.dropout = nn.Dropout(0.2)

    # 定义前向传播过程
    # x: 输入数据
    def forward(self, x):
        # 将输入图像展平：从(batch_size, 1, 28, 28)变为(batch_size, 784)
        # -1表示自动计算该维度的大小，保持批次大小不变
        x = x.view(-1, 28 * 28)

        # 第一个全连接层的输出经过ReLU激活函数
        x = torch.relu(self.fc1(x))

        # 应用Dropout
        x = self.dropout(x)

        # 第二个全连接层的输出经过ReLU激活函数
        x = torch.relu(self.fc2(x))

        # 输出层，不使用激活函数（因为损失函数会处理）
        x = self.fc3(x)

        return x

# 创建模型实例
model = MNISTNet()

# 定义损失函数：交叉熵损失
# 适用于多分类问题，内置了Softmax函数
criterion = nn.CrossEntropyLoss()

# 定义优化器：Adam优化器
# model.parameters(): 需要优化的模型参数
# lr=0.001: 学习率，控制参数更新的步长
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 4. 定义训练函数
def train(epochs):
    # 将模型设置为训练模式
    # 这会启用Dropout等训练时特有的功能
    model.train()

    # 训练指定的轮次
    for epoch in range(epochs):
        # 记录本轮的累计损失
        running_loss = 0.0

        # 遍历训练数据加载器中的每个批次，每次循环加载64个图像数据
        # batch_idx: 批次索引
        # data: 图像数据
        # target: 对应的标签（真实值）
        for batch_idx, (data, target) in enumerate(train_loader):
            # 清零优化器的梯度
            # 因为PyTorch会累积梯度，所以每次迭代前需要清零
            optimizer.zero_grad()

            # 前向传播：将数据输入模型，得到预测结果
            output = model(data)    # 模型基类nn.Module中定义了__call__方法，所以可以直接调用模型的forward函数

            # 计算损失：预测结果与真实标签的差距
            loss = criterion(output, target)

            # 反向传播：计算损失对各参数的梯度
            loss.backward()  # 计算损失函数对所有模型参数的梯度，并将这些梯度存储在各参数的.grad属性中

            # 更新参数：根据梯度调整模型参数
            optimizer.step()    # 会读取参数的梯度值，并使用指定Adam算法来更新每个参数的值

            # 累加损失值
            running_loss += loss.item()

            # 每100个批次打印一次训练信息
            if batch_idx % 100 == 99:   # 索引从0开始，所以是99
                # 计算平均损失并打印
                print(f'第 {epoch + 1}轮, 第 {batch_idx + 1}个批次, 平均损失: {running_loss / 100:.4f}')
                # 重置累计损失
                running_loss = 0.0

# 5. 定义测试函数
def test():
    # 将模型设置为评估模式
    # 这会禁用Dropout等训练时特有的功能
    model.eval()

    # 记录正确预测的数量和总样本数
    correct = 0
    total = 0

    # 关闭梯度计算，节省内存并加速计算
    # 测试时不需要计算梯度，因为不需要更新参数
    with torch.no_grad():
        # 遍历测试数据加载器中的每个批次
        for data, target in test_loader:
            # 前向传播：得到预测结果
            output = model(data)

            # 找到预测概率最大的类别索引
            # torch.max返回最大值和对应的索引，我们只需要索引
            _, predicted = torch.max(output.data, 1)   # output.data是output的数据部分，但不包含计算图信息

            # 累加总样本数
            total += target.size(0)

            # 累加正确预测的数量
            correct += (predicted == target).sum().item()

    # 计算并打印测试准确率
    print(f'准确率: {100 * correct / total:.2f}%')

tensor([[0.2, 0.1, 5.3, 0.8, 2.1, 0.5, 1.2, 3.7, 0.9, 0.3],  # 第1个样本的10类分数，索引2分数最高，预测类别为数字2
        [1.5, 4.2, 0.1, 0.3, 0.8, 2.1, 0.7, 0.2, 3.5, 0.6],  # 第2个样本的10类分数
        [0.4, 0.2, 0.1, 6.8, 0.5, 1.2, 0.9, 0.3, 0.7, 2.1]]) # 第3个样本的10类分数
        ...

# 训练5轮
train(5)
# 测试模型性能
test()

# 导入必要的库
import torch
# 导入PyTorch的神经网络模块
import torch.nn as nn
# 导入PyTorch的优化器模块
import torch.optim as optim
# 导入数据加载工具
from torch.utils.data import DataLoader
# 导入计算机视觉相关的数据集和变换工具
from torchvision import datasets, transforms

# 1. 数据准备：加载MNIST数据集并进行预处理
# 定义数据预处理管道
# Compose用于将多个变换操作组合在一起
transform = transforms.Compose([
    # 将PIL图像转换为PyTorch张量（Tensor）
    # 同时会将像素值从0-255归一化到0.0-1.0
    transforms.ToTensor(),
    # 对张量进行标准化处理
    # 参数为均值和标准差，这里使用MNIST数据集的全局均值和标准差
    transforms.Normalize((0.1307,), (0.3081,))
])

# 加载训练数据集
# root: 数据保存路径
# train=True: 加载训练集
# download=True: 如果数据不存在则自动下载
# transform: 应用定义好的预处理
train_dataset = datasets.MNIST(
    root='./data',
    train=True,
    download=True,
    transform=transform
)

# 加载测试数据集
# train=False: 加载测试集
test_dataset = datasets.MNIST(
    root='./data',
    train=False,
    download=True,
    transform=transform
)

# 创建数据加载器，用于批量加载数据
# batch_size=64: 每个批次包含64个样本
# shuffle=True: 训练时打乱数据顺序，增加随机性
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# 测试数据加载器
# 批量更大(1000)，不需要打乱顺序
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)


# 2. 定义神经网络模型
# 继承nn.Module，这是PyTorch中所有神经网络模块的基类
class MNISTNet(nn.Module):
    # 初始化方法，定义网络结构
    def __init__(self):
        # 调用父类的初始化方法
        super().__init__()

        # 定义第一个全连接层
        # 输入特征数：28*28（MNIST图像的像素展开）
        # 输出特征数：256（自定义的隐藏层大小）
        self.fc1 = nn.Linear(28 * 28, 256)

        # 定义第二个全连接层
        # 输入特征数：256（上一层的输出）
        # 输出特征数：128
        self.fc2 = nn.Linear(256, 128)

        # 定义输出层
        # 输入特征数：128
        # 输出特征数：10（对应10个数字类别）
        self.fc3 = nn.Linear(128, 10)

        # 定义Dropout层，用于防止过拟合
        # 参数0.2表示有20%的概率随机丢弃神经元
        self.dropout = nn.Dropout(0.2)

    # 定义前向传播过程
    # x: 输入数据
    def forward(self, x):
        # 将输入图像展平：从(batch_size, 1, 28, 28)变为(batch_size, 784)
        # -1表示自动计算该维度的大小，保持批次大小不变
        x = x.view(-1, 28 * 28)

        # 第一个全连接层的输出经过ReLU激活函数
        x = torch.relu(self.fc1(x))

        # 应用Dropout
        x = self.dropout(x)

        # 第二个全连接层的输出经过ReLU激活函数
        x = torch.relu(self.fc2(x))

        # 输出层，不使用激活函数（因为损失函数会处理）
        x = self.fc3(x)

        return x


# 3. 初始化模型、损失函数和优化器
# 创建模型实例
model = MNISTNet()

# 定义损失函数：交叉熵损失
# 适用于多分类问题，内置了Softmax函数
criterion = nn.CrossEntropyLoss()

# 定义优化器：Adam优化器
# model.parameters(): 需要优化的模型参数
# lr=0.001: 学习率，控制参数更新的步长
optimizer = optim.Adam(model.parameters(), lr=0.001)


# 4. 定义训练函数
def train(epochs):
    # 将模型设置为训练模式
    # 这会启用Dropout等训练时特有的功能
    model.train()

    # 训练指定的轮次
    for epoch in range(epochs):
        # 记录本轮的累计损失
        running_loss = 0.0

        # 遍历训练数据加载器中的每个批次，每次循环加载64个图像数据
        # batch_idx: 批次索引
        # data: 图像数据
        # target: 对应的标签（真实值）
        for batch_idx, (data, target) in enumerate(train_loader):
            # 清零优化器的梯度
            # 因为PyTorch会累积梯度，所以每次迭代前需要清零
            optimizer.zero_grad()

            # 前向传播：将数据输入模型，得到预测结果
            output = model(data)    # 模型基类nn.Module中定义了__call__方法，所以可以直接调用模型的forward函数

            # 计算损失：预测结果与真实标签的差距
            loss = criterion(output, target)

            # 反向传播：计算损失对各参数的梯度
            loss.backward()  # 计算损失函数对所有模型参数的梯度，并将这些梯度存储在各参数的.grad属性中

            # 更新参数：根据梯度调整模型参数
            optimizer.step()    # 会读取参数的梯度值，并使用指定Adam算法来更新每个参数的值

            # 累加损失值
            running_loss += loss.item()

            # 每100个批次打印一次训练信息
            if batch_idx % 100 == 99:   # 索引从0开始，所以是99
                # 计算平均损失并打印
                print(f'第 {epoch + 1}轮, 第 {batch_idx + 1}个批次, 平均损失: {running_loss / 100:.4f}')
                # 重置累计损失
                running_loss = 0.0


# 5. 定义测试函数
def test():
    # 将模型设置为评估模式
    # 这会禁用Dropout等训练时特有的功能
    model.eval()

    # 记录正确预测的数量和总样本数
    correct = 0
    total = 0

    # 关闭梯度计算，节省内存并加速计算
    # 测试时不需要计算梯度，因为不需要更新参数
    with torch.no_grad():
        # 遍历测试数据加载器中的每个批次
        for data, target in test_loader:
            # 前向传播：得到预测结果
            output = model(data)

            # 找到预测概率最大的类别索引
            # torch.max返回最大值和对应的索引，我们只需要索引
            _, predicted = torch.max(output.data, 1)   # output.data是output的数据部分，但不包含计算图信息

            # 累加总样本数
            total += target.size(0)

            # 累加正确预测的数量
            correct += (predicted == target).sum().item()

    # 计算并打印测试准确率
    print(f'准确率: {100 * correct / total:.2f}%')


# 执行训练和测试
# 训练5轮
train(5)
# 测试模型性能
test()