《PyTorch深度学习实践》课上代码笔记 三

最新推荐文章于 2023-03-12 21:32:57 发布
最新推荐文章于 2023-03-12 21:32:57 发布
阅读量785 收藏 3
点赞数 4
分类专栏： pytorch课程代码笔记 文章标签： 深度学习 pytorch 神经网络 机器学习 卷积神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglw882/article/details/109282886
版权

自学笔记

课程老师：刘二大人 河北工业大学教师 https://liuii.github.io
课程来源：https://www.bilibili.com/video/BV1Y7411d7Ys

推荐一个服务器租赁的平台

相比于阿里腾讯等平台，亲测性价比要高，显卡有1080Ti、2080Ti、3080Ti等，运行速度自然比自己的笔记本快，也能保护自己心爱的笔记本，实例中有Jupyter Notebook、Visual Studio Code编辑器，编写调试程序方便，适合新手上手。
链接：https://featurize.cn?s=85167577b36f44299a332f2c8dff344f

网页主界面网页主界面
进入实例后的界面
进入实例后的界面

八、Softmax_Classifier_Linear

#导入相应的包
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim

#小训练集大小
batch_size = 64

#数据集的处理

#图片变换:转换成Tensor,标准化
transform = transforms.Compose([ transforms.ToTensor(),
                                transforms.Normalize((0.1307, ),(0.3081, ))])
#创建训练数据集
train_dataset = datasets.MNIST(root='../dataset/mnist/',
                               train=True, download=True,
                               transform=transform)
#导入训练数据集
train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)
#创建测试数据集
test_dataset = datasets.MNIST(root='../dataset/mnist/',
                              train=False,
                              download=True,
                              transform=transform)
#导入测试数据集
test_loader = DataLoader(test_dataset,
                          shuffle=False,
                          batch_size=batch_size)

#设计模型(全连接的线性模型)
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        #图片像素是28*28,所以输入为784=28*28
        self.l1 = torch.nn.Linear(784, 512)
        self.l2 = torch.nn.Linear(512, 256)
        self.l3 = torch.nn.Linear(256, 128)
        self.l4 = torch.nn.Linear(128, 64)
        self.l5 = torch.nn.Linear(64, 10)
    def forward(self, x):
        #变形成784列，行数自动计算
        x = x.view(-1, 784)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        return self.l5(x)
#实例化
model = Net()

#损失函数及反馈
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

#封装训练函数
def train(epoch):
    #初始化训练损失
    running_loss = 0.0
    #训练
    for batch_idx,data in enumerate(train_loader, 0):
        #导入数据
        inputs, target = data
        #梯度归零
        optimizer.zero_grad()
        # 前馈 + 反馈 + 更新
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        #计算总损失
        running_loss += loss.item()
        #每300次训练，输出一次
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0

#封装测试函数
def test():
    #初始化准确率
    correct = 0
    total = 0
    #不计算梯度，节省内存
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)
            #计算所有的测试个数
            total += labels.size(0)
            #计算正确的个数
            correct += (predicted == labels).sum().item()
    #输出平均准确率
    print('Accuracy on test set: %d %%' % (100 * correct / total))

if __name__ == '__main__':
    #训练10次
    for epoch in range(10):
        #训练
        train(epoch)
        #测试
        test()

九、Softmax_Classifier_CNN

#导入相应的包
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim

#小训练集大小
batch_size = 64

#数据集的处理
#图片变换:转换成Tensor,标准化
transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.1307,),(0.3081,))])
#创建训练数据集
train_dataset = datasets.MNIST(root='../dataset/mnist/',
                               train=True, download=True,
                               transform=transform)
#导入训练数据集
train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)
#创建测试数据集
test_dataset = datasets.MNIST(root='../dataset/mnist/',
                              train=False,
                              download=True,
                              transform=transform)
#导入测试数据集
test_loader = DataLoader(test_dataset,
                          shuffle=False,
                          batch_size=batch_size)

#设计模型(CNN)
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        #卷积层1，输入1，输出10，卷积核5*5
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)
        #卷积层2，输入10，输出20，卷积核5*5
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=5)
        #最大池化层
        self.pooling = torch.nn.MaxPool2d(2)
        #线性层
        self.fc = torch.nn.Linear(320, 10)

    #封装前馈函数
    def forward(self, x):
        #训练子集大小
        batch_size = x.size(0)
        x = F.relu(self.pooling(self.conv1(x)))
        x = F.relu(self.pooling(self.conv2(x)))
        #变形成 batch_size 行
        x = x.view(batch_size, -1)
        x = self.fc(x)
        return x
#实例化
model = Net()

#损失函数及反馈
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

#封装训练函数
def train(epoch):
    #初始化训练损失
    running_loss = 0.0
    #训练
    for batch_idx,data in enumerate(train_loader, 0):
        #导入数据
        inputs, target = data
        #梯度归零
        optimizer.zero_grad()
        # 前馈 + 反馈 + 更新
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        #计算总损失
        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0

#封装测试函数
def test():
    correct = 0
    total = 0
    #不计算梯度，节省内存
    with torch.no_grad():
        for data in test_loader:
            #导入测试数据
            images, labels = data
            #带入模型，得到输出
            outputs = model(images)
            #找到输出中概率最大的下标及值
            _, predicted = torch.max(outputs.data, dim=1)
            #计算所有的测试个数
            total += labels.size(0)
            #计算正确的个数
            correct += (predicted == labels).sum().item()
    #输出准确率
    print('Accuracy on test set: %d %%' % (100 * correct / total))

if __name__ == '__main__':
    #训练10次
    for epoch in range(10):
        #训练
        train(epoch)
        #测试
        test()

十、Softmax_Classifier_CNN_plus

课上老师留的作业，用了三个卷积层、三个pooling、三个relu，仅改动模型那块即可。

#导入相应的包
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim

#小训练集大小
batch_size = 64

#数据集的处理
#图片变换:转换成Tensor,标准化
transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.1307,),(0.3081,))])
#创建训练数据集
train_dataset = datasets.MNIST(root='../dataset/mnist/',
                               train=True, download=True,
                               transform=transform)
#导入训练数据集
train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)
#创建测试数据集
test_dataset = datasets.MNIST(root='../dataset/mnist/',
                              train=False,
                              download=True,
                              transform=transform)
#导入测试数据集
test_loader = DataLoader(test_dataset,
                          shuffle=False,
                          batch_size=batch_size)

#设计模型(CNN)
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        #卷积层1，输入1，输出10，卷积核5*5
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)
        #卷积层2，输入10，输出20，卷积核3*3
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=3)
        #卷积层3，输入20，输出30，卷积核3*3，padding为1
        self.conv3 = torch.nn.Conv2d(20, 30, kernel_size=3,padding=1)
        #最大池化层
        self.pooling = torch.nn.MaxPool2d(2)
        #线性层
        self.fc = torch.nn.Linear(120, 10)

    def forward(self, x): 
        # Flatten data from (n, 1, 28, 28) to (n, 784)
        batch_size = x.size(0)
        x = F.relu(self.pooling(self.conv1(x)))
        x = F.relu(self.pooling(self.conv2(x)))
        x = F.relu(self.pooling(self.conv3(x)))
        x = x.view(batch_size, -1) # flatten
        x = self.fc(x)
        return x
#实例化
model = Net()

#损失函数及反馈
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

#训练
def train(epoch):
    running_loss = 0.0
    for batch_idx,data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()
        # forward + backward + update
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0

def test():
    correct = 0
    total = 0
    #不计算梯度，节省内存
    with torch.no_grad():
        for data in test_loader:
            #导入测试数据
            images, labels = data
            #带入模型，得到输出
            outputs = model(images)
            #找到输出中概率最大的下标及值
            _, predicted = torch.max(outputs.data, dim=1)
            #计算所有的测试个数
            total += labels.size(0)
            #计算正确的个数
            correct += (predicted == labels).sum().item()
    #输出准确率
    print('Accuracy on test set: %d %%' % (100 * correct / total))

if __name__ == '__main__':
    #训练10次
    for epoch in range(10):
        #训练
        train(epoch)
        #测试
        test()
Zhanglw882
关注
专栏目录
刘二大人pytorch代码（自用）
qq_42706542的博客
10-14 1644
自用刘二大人pytroch代码
PyTorch深度学习实践代码 第十三讲
m0_46166352的博客
03-09 886
#引入torch import torch #引入time计时 import time #引入math数学函数 import math #引入numpy import numpy as np #引入plt import matplotlib.pyplot as plt #从torch的工具的数据引入数据集，数据加载器 from torch.utils.data import Dataset,DataLoader #从torch的神经网络的数据的rnn中引入包装填充好的序列。作用是将填充的pad去掉，然后根.
自我记录：Python学习之Pytorch 04 逻辑回归
weixin_42294553的博客
08-02 147
代码取自B站刘二老师的《Pytorch深度学习实践》视频教程 import torch import numpy as np import matplotlib.pyplot as plt x_data = torch.Tensor([[1.0], [2.0], [3.0]]) y_data = torch.Tensor([[0], [0], [1]]) # trian_set=torchvision.datasets.MNIST(root='../dataset/mnist',train=True,
自我记录：Python学习之Pytorch 03 反向传播
weixin_42294553的博客
08-01 164
代码取自B站刘二老师的《Pytorch深度学习实践》视频教程 import torch x_data = [1.0, 2.0, 3.0] y_data = [2.0, 4.0, 6.0] w = torch.tensor([1.0]) w.requires_grad = True # 需要计算梯度 def forward(x): return x * w def loss(x, y): y_pred = forward(x) return (y_pred - y) **
Pytorch深度学习——多分类问题、MNIST训练实例（B站刘二大人P9学习笔记）
Learning_AI的博客
01-18 4188
本节课以深度学习经典数据集MNIST数据集为例展开，详细介绍Softmax激活函数，NLLLoss损失函数，CrossEntropyLoss损失函数、单通道与多通道图像、以及MNIST训练从数据集的准备、模型的建立到训练的全过程代码详解。
【深度学习】PyTorch深度学习实践 - Lecture_10_Basic_CNN
知不足而奋进，望远山而前行
12-12 2万+
如下图所示，MaxPooling=（2，2），即将输入数据分成四个（2，2）无交集的区域，然后选取每个区域的最大值作为输出数据。：在输入数据的四周进行扩展的数量，比如Padding = （1，1）代表在输入数据的四周一圈扩展并填充0。如Stride =（2，2）分别表示宽和高方向上的滑动步长。当卷积核大小为n×n时：Padding=（m，m），其中 m =（n-1）/2，n为奇数。当卷积核大小为3×3时：Padding=（1，1）当卷积核大小为5×5时：Padding=（2，2）最常用的下采样方法是。
PyTorch深度学习实践代码 第七讲
m0_46166352的博客
03-01 442
#引入numpy import numpy as np #引入torch import torch #引入数据集,用np中的加载文本功能，加载文本。分割符为逗号。数据类型为32位浮点型 xy = np.loadtxt('diabetes.csv',delimiter=',',dtype=np.float32) #x的数据是用torch中的来自numpy提取数据，：代表所有行，：-1代表除了最后一列的所有列。 x_data = torch.from_numpy(xy[:,:-1]) #y的数据是torch.
【B站_刘二大人pytorch深度学习实践】笔记作业代码合集
最新发布
m0_58586235的博客
03-12 2915
手动训练：线性模型，梯度下降，BP Pytorch框架训练：线性回归，LogisticRegression，多维特征输入，加载数据集，多分类，CNN，RNN
《Pytorch深度学习实践》课程合集（刘二大人）笔记
竦貊的博客
05-30 4750
2 线性模型 深度学习步骤 数据集 —— 拿到的训练集，要分成两部分，训练集，交叉验证集 和 测试集 模型 训练 推理 ML常用损失函数
《PyTorch深度学习实践》学习笔记(1)
t28383993的博客
01-24 1726
深度学习，刘二大人
PyTorch：我的PyTorch深度学习笔记本
02-16
《PyTorch深度学习探索——基于个人笔记本的实践与理解》 PyTorch，作为一款由Facebook开发的开源机器学习库，以其灵活易用、动态计算图的优势在深度学习领域备受青睐。它不仅适合研究者进行快速原型设计，也适用于...
刘二大人《PyTorch深度学习实践》
baimenglin的博客
09-12 3287
刘二大人《PyTorch深度学习实践》线性模型 线性模型 损失函数是针对一个样本的 training set得到的是一个平均平方误差MSE 穷举法绘制损失曲线：numpy和matplotlib import numpy as np import matplotlib.pyplot as plt #数据集 x_data = [1.0,2.0,3.0] y_data = [2.0,4.0,6.0] #定义模型 def forward(x): return x * w #定义损失函数 def loss
用PyTorch实现MNIST手写数字识别（最新，非常详细）
热门推荐
qq_45588019的博客
01-20 7万+
1 MNIST数据集(提取码: zm7q )
PyTorch深度学习实践代码 第九讲
m0_46166352的博客
03-01 556
#引入torch import torch #从torchvision中引入图像转换 from torchvision import transforms #从torchvision中引入数据集 from torchvision import datasets #从torch的工具中的数据引入数据加载器 from torch.utils.data import DataLoader #引入torch中的神经网络的激活函数(relu) import torch.nn.f.unctional as F #引入.
Pytorch深度学习——用卷积神经网络实现MNIST数据集分类
Learning_AI的博客
01-24 1万+
选择下图结构的卷积神经网络来进行训练：
PyTorch学习（九）--用CNN模型识别手写数字数据集MNIST
weixin_44841652的博客
04-01 8366
什么是MNIST数据集？ 直接看图！！他就是一套手写数字的图片，他的规格是（1x28x28）,单通道，横竖都是28个像素，下面是前20个图片。我们今天的目的就是用卷积神经网络去识别这些数字到底是多少。 话不多说，咱们边看代码边聊，相信你一定能和我一起看懂他。 import torch from torch.utils.data import DataLoader #我们要加载数据集的 from...
基于pytorch的GAN网络搭建
qq_37320084的博客
01-04 4161
本次的主要任务是利用pytorch实现对GAN网络的搭建，并实现对手写数字的生成。GAN网络主要包含两部分网络，一部分是生成器，一部分是判别器。本次采用的数据库还是MNIST数据集，这里对数据的获取不在赘述。 1、生成器 生成器的主要功能是生成我们所需要的样本，这里是28*28的图片。首先生成长度为100的高斯噪声，并且将噪声通过线性模型升维到784维。激活函数采用Relu。 # 定义判别器 #####Generator######使用多层网络来作为判别器 # 输入一个100维的0～1之间的高斯分
Pytorch深度学习——用全连接神经网络实现MNIST数据集分类
Learning_AI的博客
01-24 7469
我们之前学习的案例中，输入x都是一个向量；在MNIST数据集中，我们需要输入的是一个图像，怎样，图像怎么才能输入到模型中进行训练呢？一种方法是我们可以把图像映射成一个矩向量，再输入到模型中进行训练。 怎样将一个图像映射成一个向量？ 如图所示是MNIST数据集中一个方格的图像，它是由28x28=784个像素组成，其中越深的地方数值越接近0，越亮的地方数值越接近1。 因此可以将此图像按照对应的像素和数值映射成一个28x28的一个矩阵，如下...
TensorFlow解决分类问题+示例+命令解释
qq_44004117的博客
03-07 451
shape: 对于输入x.shape= [样本数，单个样本的特征长度（打平或不打平）]。 对于输出y.shape=[样本数，输出数]。 import os os.environ['TF_CPP_MIN_LOG_LEVEL']='2' import tensorflow as tf from tensorflow import keras from tensorflo...
Pytorch深度学习之旅：刘二大人课程笔记与实践
本文是关于B站刘二大人Pytorch课程的学习笔记，涵盖了从基础到进阶的多个主题，包括Pytorch环境搭建、线性模型、梯度下降、反向传播、线性回归、逻辑斯蒂回归、处理多维特征、加载数据集、多分类问题、卷积神经网络...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值