x = torch.arange(-8.0, 8.0, 0.1, requires_grad=True)
y = torch.relu(x)
d2l.plot(x.detach(), y.detach(), 'x', 'relu(x)', figsize=(5, 2.5))

import torch
from torch import nn
from d2l import torch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

num_inputs, num_outputs, num_hiddens = 784, 10, 256

W1 = nn.Parameter(torch.randn(num_inputs, num_hiddens, requires_grad=True) * 0.01)

b1 = nn.Parameter(torch.zeros(num_hiddens, requires_grad=True))

W2 = nn.Parameter(torch.randn(num_hiddens, num_outputs, requires_grad=True) * 0.01)

b2 = nn.Parameter(torch.zeros(num_outputs, requires_grad=True))

params = [W1, b1, W2, b2]

def relu(X):
    a = torch.zeros_like(X)
    return torch.max(X, a)

def net(X):
    X = X.reshape((-1, num_inputs))
    H = relu(X@W1 + b1)  # 这里“@”代表矩阵乘法
    return (H@W2 + b2)

loss = nn.CrossEntropyLoss(reduction='none')

num_epochs, lr = 10, 0.1
updater = torch.optim.SGD(params, lr=lr)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)

import torch
from torch import nn
from d2l import torch as d2l

net = nn.Sequential(nn.Flatten(),
                    nn.Linear(784, 256),
                    nn.ReLU(),
                    nn.Linear(256, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights);

batch_size, lr, num_epochs = 256, 0.1, 10
loss = nn.CrossEntropyLoss(reduction='none')
trainer = torch.optim.SGD(net.parameters(), lr=lr)

train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

#获取K折验证数据集
def get_k_fold_data(k, i, X, y):

    """
       参数:
    - k (int): K折交叉验证中的“折”（fold）数，表示将数据集分割成多少份。
    - i (int): 指定当前迭代使用哪一折作为验证集，范围从0到k-1。
    - X (Tensor): 完整的特征数据集，假设其形状为 (样本数, 特征数)。
    - y (Tensor): 与X对应的标签数据集，假设其形状为 (样本数,) 或 (样本数, 标签数)。
    """
     # 确保k大于1，因为至少需要分成两折才能进行交叉验证
    assert k > 1
    # 计算每一折的大小，整数除法
    fold_size = X.shape[0] // k
    
    # 初始化训练集和验证集
    X_train, y_train = None, None
    
    # 遍历每一折
    for j in range(k):
        # 为当前折生成索引，使用切片(slice)来获取数据的一个子集
        idx = slice(j * fold_size, (j + 1) * fold_size)
        
        # 根据索引提取当前折的数据部分
        X_part, y_part = X[idx, :], y[idx]
        
        # 如果当前折是验证集
        if j == i:
            # 直接将当前折设为验证集
            X_valid, y_valid = X_part, y_part
        # 如果是第一个训练折
        elif X_train is None:
            # 初始化训练集
            X_train, y_train = X_part, y_part
        else:
            # 如果已经有训练数据，将当前折的数据添加到训练集中
            X_train = torch.cat([X_train, X_part], 0)
            y_train = torch.cat([y_train, y_part], 0)
    
    # 返回训练数据集、训练标签、验证数据集、验证标签
    return X_train, y_train, X_valid, y_valid

def k_fold(k, X_train, y_train, num_epochs, learning_rate, weight_decay, batch_size):
    """
    执行K折交叉验证。
    参数:
     - k (int): 折数，即将数据集分成多少份。
     - X_train (Tensor): 完整的训练数据特征。
     - y_train (Tensor): 完整的训练数据标签。
     - num_epochs (int): 每次训练时的迭代轮数。
     - learning_rate (float): 学习率。
     - weight_decay (float): 权重衰减（L2惩罚）。
     - batch_size (int): 批量大小。

    返回:
     - train_l_sum / k (float): K折交叉验证的平均训练损失。
     - valid_l_sum / k (float): K折交叉验证的平均验证损失。
     """

# 初始化总的训练和验证损失
train_l_sum, valid_l_sum = 0, 0

# 对每一折进行迭代
for i in range(k):
    # 获取当前折的训练和验证数据
    data = get_k_fold_data(k, i, X_train, y_train)
    
    # 初始化模型
    net = get_net()
    
    # 训练模型，并获取训练和验证损失列表
    train_ls, valid_ls = train(net, *data, num_epochs, learning_rate, weight_decay, batch_size)
    
    # 累加最后一次迭代的训练和验证损失
    train_l_sum += train_ls[-1]
    valid_l_sum += valid_ls[-1]
    
    # 如果是第一折，绘制训练和验证损失的变化曲线
    if i == 0:
        d2l.plot(list(range(1, num_epochs + 1)), [train_ls, valid_ls],
                 xlabel='epoch', ylabel='rmse', xlim=[1, num_epochs],
                 legend=['train', 'valid'], yscale='log')
    
    # 打印当前折的训练和验证损失
    print(f'折{i + 1}，训练log rmse{float(train_ls[-1]):f}, '
          f'验证log rmse{float(valid_ls[-1]):f}')

# 计算并返回K折交叉验证的平均训练和验证损失
return train_l_sum / k, valid_l_sum / k

def init_params():
    w = torch.normal(0, 1, size=(num_inputs, 1), requires_grad=True)
    b = torch.zeros(1, requires_grad=True)
    return [w, b]

def l2_penalty(w):
    return torch.sum(w.pow(2)) / 2

def train(lambd):
    w, b = init_params()
    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss
    num_epochs, lr = 100, 0.003
    animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log',
                            xlim=[5, num_epochs], legend=['train', 'test'])
    for epoch in range(num_epochs):
        for X, y in train_iter:
            # 增加了L2范数惩罚项，
            # 广播机制使l2_penalty(w)成为一个长度为batch_size的向量
            l = loss(net(X), y) + lambd * l2_penalty(w)
            l.sum().backward()
            d2l.sgd([w, b], lr, batch_size)
        if (epoch + 1) % 5 == 0:
            animator.add(epoch + 1, (d2l.evaluate_loss(net, train_iter, loss),
                                     d2l.evaluate_loss(net, test_iter, loss)))
    print('w的L2范数是：', torch.norm(w).item())

train(lambd=0)

train(lambd=3)

def train_concise(wd):
    # 创建一个简单的线性模型
    net = nn.Sequential(nn.Linear(num_inputs, 1))
    # 初始化模型参数
    for param in net.parameters():
        param.data.normal_()
    # 使用均方误差作为损失函数
    loss = nn.MSELoss(reduction='none')
    # 设置训练的轮数和学习率
    num_epochs, lr = 100, 0.003
    # 配置优化器，为权重参数应用L2正则化，但偏置参数不应用衰减
    trainer = torch.optim.SGD([
        {"params":net[0].weight,'weight_decay': wd},  # 为权重参数应用权重衰减
        {"params":net[0].bias}], lr=lr)  # 偏置参数没有衰减
    # 用于绘图的实用工具
    animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log',
                            xlim=[5, num_epochs], legend=['train', 'test'])
    # 训练循环
    for epoch in range(num_epochs):
        for X, y in train_iter:
            trainer.zero_grad()  # 清除之前的梯度
            l = loss(net(X), y)  # 计算当前批次的损失
            l.mean().backward()  # 反向传播
            trainer.step()  # 更新模型参数
        # 每5个epoch评估一次模型的训练和测试损失，并更新绘图
        if (epoch + 1) % 5 == 0:
            animator.add(epoch + 1,
                         (d2l.evaluate_loss(net, train_iter, loss),
                          d2l.evaluate_loss(net, test_iter, loss)))
    # 打印权重的L2范数，以观察权重大小
    print('w的L2范数：', net[0].weight.norm().item())

import torch
from torch import nn
from d2l import torch as d2l

def dropout_layer(X, dropout):
    # 确保dropout概率值在0到1之间
    assert 0 <= dropout <= 1
    # 如果dropout概率为1，意味着丢弃所有元素，直接返回一个全0的张量
    if dropout == 1:
        return torch.zeros_like(X)
    # 如果dropout概率为0，意味着保留所有元素，直接返回输入张量
    if dropout == 0:
        return X
    # 生成一个随机张量，其形状与输入X相同，元素值介于0到1之间
    mask = (torch.rand(X.shape) > dropout).float()
    # 应用生成的mask来随机丢弃一部分元素，通过与mask相乘实现
    # 然后对剩下的元素进行缩放，以保持其总体期望值不变
    return mask * X / (1.0 - dropout)

num_inputs, num_outputs, num_hiddens1, num_hiddens2 = 784, 10, 256, 256

# 定义两个丢弃率：对于第一个隐藏层是20%，对于第二个隐藏层是50%
dropout1, dropout2 = 0.2, 0.5

# 定义神经网络类Net，继承自nn.Module
class Net(nn.Module):
    # 初始化网络结构
    def __init__(self, num_inputs, num_outputs, num_hiddens1, num_hiddens2,
                 is_training = True):
        super(Net, self).__init__()  # 调用父类的初始化方法
        self.num_inputs = num_inputs  # 输入层的维度
        self.training = is_training  # 标记是否为训练模式
        # 定义第一个隐藏层，连接输入层和第一个隐藏层
        self.lin1 = nn.Linear(num_inputs, num_hiddens1)
        # 定义第二个隐藏层，连接第一个和第二个隐藏层
        self.lin2 = nn.Linear(num_hiddens1, num_hiddens2)
        # 定义输出层，连接第二个隐藏层和输出层
        self.lin3 = nn.Linear(num_hiddens2, num_outputs)
        # 定义ReLU激活函数
        self.relu = nn.ReLU()

    # 定义模型的前向传播路径
    def forward(self, X):
        # 将输入数据X通过第一个全连接层，然后应用ReLU激活函数
        H1 = self.relu(self.lin1(X.reshape((-1, self.num_inputs))))
        # 如果是训练模式，对第一个隐藏层的输出应用丢弃法
        if self.training == True:
            H1 = dropout_layer(H1, dropout1)
        # 将处理过的数据通过第二个全连接层，然后应用ReLU激活函数
        H2 = self.relu(self.lin2(H1))
        # 如果是训练模式，对第二个隐藏层的输出应用丢弃法
        if self.training == True:
            H2 = dropout_layer(H2, dropout2)
        # 将处理过的数据通过输出层得到最终输出
        out = self.lin3(H2)
        return out

# 实例化网络模型，指定输入、输出和隐藏层的维度
net = Net(num_inputs, num_outputs, num_hiddens1, num_hiddens2)

num_epochs, lr, batch_size = 10, 0.5, 256
loss = nn.CrossEntropyLoss(reduction='none')
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
trainer = torch.optim.SGD(net.parameters(), lr=lr)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

net = nn.Sequential(nn.Flatten(),
        nn.Linear(784, 256),
        nn.ReLU(),
        # 在第一个全连接层之后添加一个dropout层
        nn.Dropout(dropout1),
        nn.Linear(256, 256),
        nn.ReLU(),
        # 在第二个全连接层之后添加一个dropout层
        nn.Dropout(dropout2),
        nn.Linear(256, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights);