pytorch搭建简单神经网络

Posted 2023-05-16

参考技术A 一个基本的神经网络结构如图1和图2所示。图1是只有一个神经元的示意图，图2是一个含有隐藏层的简单神经网络。

如图1所示，当我们有一系列特征（input signals）为x1, x2, …xm，我们为其赋予对应的权重wk1,wk2,…xkm，对应相乘再相加，得到了x1wk1 + x2wk2 + x3wk3 + ... + xmwkm。我们再加上一个偏置（bias），得到一个总和sum。然后将这个值代入一个激活函数（比如sigmoid/relu等），得到最终值，输出。

图2是在图1的基础上，加入了隐藏层。我们对于LayerL1中的输入，赋予多组权重，计算可以得到Layer L2中的值，再对其中的值赋予权重a1, a2, a3，求出sum值，经过激活函数激活，输出。

以下用pytorch实现一个简单网络：

我们看看loss的分布：

学习pytorch-使用Torch搭建一个简单神经网络

a.py
import torch
import numpy as np
#生成一个五行四列的二维矩阵
print(torch.Tensor(5, 4))
# 返回的数组大小是5x4的矩阵，初始化是0~1的均匀分布
x=torch.rand(5, 4)
print(torch.randn(5, 4))
print(x)
#查看x的形状
print(x.size())
# numpy 类似的返回5x4大小的矩阵
print(np.ones((5, 4)))
#  类似的返回5x4大小的张量
print(torch.ones(5,4))
#返回5x4大小的张量 对角线上全1，其他全0
print(torch.eye(5,4))
print(torch.arange(1,5,1))
print(torch.linspace(1,5,2))
#服从正太分布
#print(torch.normal(-1,2))
print(torch.randperm(2))
#numpy转换成Tensor
a = torch.ones(5)
b=a.numpy()
print(b)
#Tensor转换成numpy
a= np.ones(5)
b=torch.from_numpy(a)
print(b)
#True支持GPU，False不支持
print(torch.cuda.is_available())

b.py
#torch.autograd.Variable 实现自动求导
"""
本质上Variable和Tensor没有什么区别，
不过Variable会放在一个计算图里面，
可以进行前向传播和反向传播以及求导
"""
import torch
from torch.autograd import Variable
# requires_grad 表示是否对其求梯度，默认是False
x = Variable(torch.Tensor([3]), requires_grad=True)
y = Variable(torch.Tensor([5]), requires_grad=True)
z = 2 * x * x + y * y + 4
# 对 x 和 y 分别求导
z.backward()
# x 的导数和 y 的导数
#x =3*2*2
#y = 5*2
print(‘dz/dx: {}‘.format(x.grad.data))
print(‘dz/dy: {}‘.format(y.grad.data))

c.py
from torch import nn
import torch
from torch.autograd import Variable
import torch.nn.functional as F
"""所依赖的主要是 torch.nn 和 torch.nn.functional

torch.nn 里面有着所有的神经网络的层的操作，其用来构建网络，
只有执行一次网络的运算才执行一次

torch.nn.functional 表示的是直接对其做一次向前运算操作"""


# 基本的网络构建类模板
class net_name(nn.Module):
    def __init__(self,opt):
        super(net_name, self).__init__()
        # 可以添加各种网络层
        self.maina = nn.Sequential(
         # #使用反卷积  没有零填充，单位步幅。
         nn.ConvTranspose2d(100, opt.nz * 8, 3, 1,0, bias=False),
         nn.BatchNorm2d(opt.nz * 8),
         nn.ReLU(True),
         #计算公式 o = i+(k-1) = 7
         #10*512*7*7

          # 使用反卷积  有填充，单位步幅。
         # nn.ConvTranspose2d(100, opt.nz * 8, 3, 1, 1, bias=False),
         # nn.BatchNorm2d(opt.nz * 8),
         # nn.ReLU(True),
         # 计算公式 o = i+(k-1)-2p = 2 +2 -2=2
         # 10*512*2*2

         # 使用反卷积  全填充。
         # nn.ConvTranspose2d(100, opt.nz * 8, 3, 1, 2, bias=False),
         # nn.BatchNorm2d(opt.nz * 8),
         # nn.ReLU(True),
         # 计算公式 o = i-(k-)*2
         # 10*512*3*3

        nn.Conv2d(opt.nz * 8, opt.nz * 16, 3, 1, 0, bias=False),
        nn.BatchNorm2d(opt.nz * 16),
        nn.ReLU(True),

         #计算公式 o = (i-k)+1
         #10*256*2*2
        )
        # 具体每种层的参数可以去查看文档

    def forward(self, input):
        return self.maina(input)
class Config(object):

    nz = 64
    gpu = False  # 是否使用GPU
    gen_img = ‘2018.png‘
opt = Config()
if __name__ == ‘__main__‘:
    a = torch.randn(10, 100,5,5)
    noises = Variable(a, volatile=True)
    d = net_name(opt).forward(noises)
    print(d)