【动手学pytorch】课程笔记

最新推荐文章于 2024-09-01 23:18:48 发布

司瑾sj

最新推荐文章于 2024-09-01 23:18:48 发布

阅读量332

点赞数

CC 4.0 BY-SA版权

分类专栏： Pytorch 文章标签：神经网络机器学习深度学习

本文链接：https://blog.youkuaiyun.com/weixin_36688519/article/details/104311315

Pytorch 专栏收录该内容

1 篇文章

订阅专栏

本文深入探讨了深度学习的关键概念和技术，包括多层感知机、循环神经网络、卷积神经网络等，解析了过拟合、欠拟合及梯度消失等问题的解决方案，并介绍了K折交叉验证方法，同时覆盖了LeNet、ResNet、DenseNet等多种经典网络结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

https://github.com/ShusenTang/Dive-into-DL-PyTorch

多层感知机

在这里插入图片描述

过拟合、欠拟合及其解决方案

在这里插入图片描述

梯度消失、梯度爆炸

在这里插入图片描述
K折交叉验证：

def get_k_fold_data(k, i, X, y):
    # 返回第i折交叉验证时所需要的训练和验证数据
    assert k > 1
    fold_size = X.shape[0] // k
    X_train, y_train = None, None
    for j in range(k):
        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), dim=0)
            y_train = torch.cat((y_train, y_part), dim=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):
    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(X_train.shape[1])
        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.semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'rmse',
                         range(1, num_epochs + 1), valid_ls,
                         ['train', 'valid'])
        print('fold %d, train rmse %f, valid rmse %f' % (i, train_ls[-1], valid_ls[-1]))
    return train_l_sum / k, valid_l_sum / k

循环神经网络

在这里插入图片描述

卷积神经网络基础

在这里插入图片描述

LeNet

在这里插入图片描述

批量归一化（BatchNormalization）

在这里插入图片描述

net = nn.Sequential(
            nn.Conv2d(1, 6, 5), # in_channels, out_channels, kernel_size
            nn.BatchNorm2d(6),
            nn.Sigmoid(),
            nn.MaxPool2d(2, 2), # kernel_size, stride
            nn.Conv2d(6, 16, 5),
            nn.BatchNorm2d(16),
            nn.Sigmoid(),
            nn.MaxPool2d(2, 2),
            d2l.FlattenLayer(),
            nn.Linear(16*4*4, 120),
            nn.BatchNorm1d(120),
            nn.Sigmoid(),
            nn.Linear(120, 84),
            nn.BatchNorm1d(84),
            nn.Sigmoid(),
            nn.Linear(84, 10)
        )

optimizer = torch.optim.Adam(net.parameters(), lr=lr)
d2l.train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)