PyTorch 循序渐进建立一个简单的神经网络模型

最新推荐文章于 2025-03-02 03:59:03 发布

音无八重

最新推荐文章于 2025-03-02 03:59:03 发布

阅读量580

点赞数 2

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

本文链接：https://blog.csdn.net/Rhiney_97/article/details/120517125

版权

深度学习专栏收录该内容

3 篇文章

订阅专栏

该博客展示了如何使用PyTorch构建和训练神经网络模型。首先通过torch.nn.Sequential建立简单模型，然后使用nn.Module创建自定义类进行模型搭建。数据集通过Dataset类实现，使用SGD优化器和MSELoss损失函数进行训练。

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

例子一：建立一个简单的神经网络模型，主体是使用torch.nn.Sequential完成神经网络的模型建立，使用SGD方法优化模型参数，代价函数选择torch.nn.MSELoss()完成（均方误差代价函数）

注意：程序是在jupytpycharmer notebook完成的，和pycharm之类的可能有细微不同（比如print）

import torch
import torch.nn as nn
import numpy as np
import torch.nn.functional as F
from torch.utils.data import Dataset,DataLoader, RandomSampler

#仅限jupyter notebook上使用（没什么重要意义）
#from IPython.core.interactiveshell import InteractiveShell
#InteractiveShell.ast_node_interactivity = 'all'

#数据构建——方法一：直接建
#构建输入集
x = np.array([
    [0,0],
    [0,1],
    [1,0],
    [1,1]
])
x = torch.tensor(x).float()
#labels
y = np.array([
    [1],
    [0],
    [0],
    [1]
])
y = torch.tensor(y).float()

#搭建网络——方法一
LinearModel = nn.Sequential(
    nn.Linear(2,10),  #输入2，输出10
    nn.ReLU(),
    nn.Linear(10,1),  #输入10，输出1
    nn.Sigmoid()
)
print(LinearModel)

#设置优化器
#采用SGD方法训练优化，传入网络参数和学习率
optimizer = torch.optim.SGD(LinearModel.parameters(),lr=0.05)  
loss_func = nn.MSELoss()   #代价函数选择的MSE（均方误差代价函数）

#训练网络
for epoch in range(1000):  #训练迭代500次
    #1. 数据放入模型，计算出结果
    out = LinearModel(x)
    #2. 计算误差
    loss = loss_func(out,y)
    #3. 清除梯度（是为了每一次重新迭代时清除上一步所求出的梯度）
    optimizer.zero_grad()
    #4. 误差反向传播
    loss.backward()
    #5. 优化参数
    optimizer.step()

#测试
#tensor变量包含两部分：tensor数据+tensor自动求导参数  不加.data全部显示
print(LinearModel(x).data)

例子二：数据建立方式不变，模型采用nn.Module继承类建立，需要训练参数的网络层放在__init__()构造函数里；不需要训练参数的层（比如ReLU，dropout）放在forward()中，需要使用torch.nn.functional来构建。forward()函数就是用来定义网络层间的连接情况。

nn.Module继承方法可以查看这篇博客，讲的很清晰：pytorch教程之nn.Module类详解——使用Module类来自定义模型

import torch
import torch.nn as nn
import numpy as np
import torch.nn.functional as F
from torch.utils.data import Dataset,DataLoader, RandomSampler

#from IPython.core.interactiveshell import InteractiveShell
#InteractiveShell.ast_node_interactivity = 'all'

#数据构建——方法一：直接建
#构建输入集
x = np.array([
    [0,0],
    [0,1],
    [1,0],
    [1,1]
])
x = torch.tensor(x).float()
#labels
y = np.array([
    [1],
    [0],
    [0],
    [1]
])
y = torch.tensor(y).float()

#搭建网络——方法二
class LModel(nn.Module):
    def __init__(self):
        super(LModel,self).__init__()
        self.linear1 = nn.Linear(2,10)
        self.linear2 = nn.Linear(10,1)
    def forward(self,x):
        x = self.linear1(x)
        x = F.relu(x)
        x = self.linear2(x)
        x = F.sigmoid(x)
        return x
        
lmodel = LModel()
print(lmodel)

#设置优化器
#采用SGD方法训练优化，传入网络参数和学习率
optimizer = torch.optim.SGD(lmodel.parameters(),lr=0.05)  
loss_func = nn.MSELoss()   #代价函数选择的MSE（均方误差代价函数）

#训练网络
for epoch in range(1000):  #训练迭代500次
    #1. 数据放入模型，计算出结果
    out = lmodel(x)
    #2. 计算误差
    loss = loss_func(out,y)
    #3. 清除梯度（是为了每一次重新迭代时清除上一步所求出的梯度）
    optimizer.zero_grad()
    #4. 误差反向传播
    loss.backward()
    #5. 优化参数
    optimizer.step()
    
#测试
#tensor变量包含两部分：tensor数据+tensor自动求导参数  不加.data全部显示
print(lmodel(x).data)

例子三：数据使用torch.utils.data中的Dataset继承类来实现，因此数据集中的各类属性可以在类中设置，模型还是使用nn.Module继承类

import torch
import torch.nn as nn
import numpy as np
import torch.nn.functional as F
from torch.utils.data import Dataset,DataLoader, RandomSampler

#from IPython.core.interactiveshell import InteractiveShell
#InteractiveShell.ast_node_interactivity = 'all'

#构建输入集
x = np.array([
    [0,0],
    [0,1],
    [1,0],
    [1,1]
])
x = torch.tensor(x).float()
#labels
y = np.array([
    [1],
    [0],
    [0],
    [1]
])
y = torch.tensor(y).float()

#数据构建——方法二：使用Dataset类
class MyDataset(Dataset):
    def __init__(self, dataset, labels):
        self.dataset = dataset
        self.labels = labels
        self.nums = len(dataset)
        
    def __getitem__(self, index):
        data = {'dataset': self.dataset[index],
                'labels': self.labels[index]}
        return data
    
    def __len__(self):
        return self.nums
    
train_dataset = MyDataset(x,y)
train_dataset

train_sampler = RandomSampler(train_dataset)    #将训练集打乱
train_loader = DataLoader(dataset=train_dataset,   #按batch_size加载训练集
                          batch_size=2, 
                          sampler=train_sampler,
                          num_workers=0)

"""
#把第一个batch_data拿出来看看
cnt=0
for step, batch_data in enumerate(train_loader):
    #print(step)
    #print(batch_data)
    cnt = cnt+1
    if cnt>=1:
        break
print(batch_data)
batch_data['dataset']
batch_data['labels']
"""

#搭建网络——方法二
class LModel(nn.Module):
    def __init__(self):
        super(LModel,self).__init__()
        self.linear1 = nn.Linear(2,10)
        self.linear2 = nn.Linear(10,1)
    def forward(self,x):
        x = self.linear1(x)
        x = F.relu(x)
        x = self.linear2(x)
        x = F.sigmoid(x)
        return x
        
lmodel = LModel()
print(lmodel)

#设置优化器
#采用SGD方法训练优化，传入网络参数和学习率
optimizer = torch.optim.SGD(lmodel.parameters(),lr=0.05)  
loss_func = nn.MSELoss()   #代价函数选择的MSE（均方误差代价函数）

#训练网络
for epoch in range(1000):  #训练迭代500次
    for step, batch_data in enumerate(train_loader):
        #1. 数据放入模型，计算出结果
        #lmodel.train()
        out = lmodel(batch_data['dataset'])
        #2. 计算误差
        loss = loss_func(out,batch_data['labels'])
        #loss = lmodel(**batch_data)[0]    #应该就是训练后的loss值，误差计算
        #3. 清除梯度（是为了每一次重新迭代时清除上一步所求出的梯度）
        optimizer.zero_grad()
        #4. 误差反向传播
        loss.backward()
        #5. 优化参数
        optimizer.step()

#测试
#tensor变量包含两部分：tensor数据+tensor自动求导参数  不加.data全部显示
print(lmodel(x).data)