Pytorch的nn.module

最新推荐文章于 2025-02-19 09:42:34 发布

转载最新推荐文章于 2025-02-19 09:42:34 发布 · 290 阅读

Pytorch 专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一个使用PyTorch实现的卷积神经网络（CNN）模型，并通过具体的代码示例展示了如何构建网络结构、设置训练过程及评估模型性能。文章详细解释了各层的参数配置以及训练过程中使用的优化器和损失函数。

部署运行你感兴趣的模型镜像

包引入

import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable

定义类

class net(nn.Module):
	def __init__(self):
		super(net, self).__init__()
		self.conv1 = nn.sequential(
			nn.Conv2d(1, 16, kernal_size=5, padding = 1 ),
			 #输入深度1，输入深度16，卷积核5*5，0填充为1
			nn.BatchNorm2d(16),     #归一化
			nn.ReLU(),
			nn.MaxPool2d(2)), #池化，核是2
			
		self.conv2 = nn.sequential(
			nn.Conv2d(16, 32, kernal_size=2, padding = 1 ),
			 #输入深度1，输入深度16，卷积核5*5，0填充为1
			nn.BatchNorm2d(32),     #归一化
			nn.ReLU(),
			nn.MaxPool2d(3)), #池化，核是3
	
		self.fc = nn.Linear(32,2)  #全连接层
	
	def forward(self, x):
		out = self.conv1(x)
		out = self.conv2(out)
		out = out.view(out.size(0), -1) #一维是out.size(0)，剩下的在2维
		out = self.fc(out)
		return out

注意：view函数只能由于contiguous的张量上，具体而言，就是在内存中连续存储的张量。具体而言，可以参看link。所以，当tensor之前调用了transpose, permute函数就会是tensor内存中变得不再连续，就不能调用view函数。
所以，应该提前做tensor.contiguous()的操作！

训练

def main():
    torch.set_default_tensor_type("torch.DoubleTensor")
    trainx = np.array([[[[0.0, 0, 1, 0, 0],
                         [0, 1, 1, 0, 0],
                         [0, 0, 1, 0, 0],
                         [0, 0, 1, 0, 0],
                         [1, 1, 1, 1, 1]]],
                       [[[0, 1, 1, 0, 0],
                         [1, 1, 1, 1, 0],
                         [1, 0, 1, 1, 0],
                         [0, 1, 1, 0, 0],
                         [1, 1, 1, 1, 1]]]])
    trainy = np.array([[1, 0.0], [0, 1]])
    N = net()

    trainx = torch.from_numpy(trainx)
    trainy = torch.from_numpy(trainy)
    print(trainx.shape)
    input()
    criterion = nn.MSELoss()  #平方损失函数
    optimizer = optim.SGD(N.parameters(), lr=1e-4) #随机梯度下降
    num_epochs = 10000

    for epoch in range(num_epochs):
        inputs = Variable(trainx)
        target = Variable(trainy)

        out = N(inputs)
        loss = criterion(out, target)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if (epoch) % 50 == 0:
            print("loss:{}".format(loss.data))

    N.eval() #转变为测试模式
    predict = N(Variable(trainx))
    predict = predict.data.numpy()
    print(predict)
    pass


main()

在这里插入图片描述