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

a.pyimport 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.pyfrom 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)

原文地址：https://www.cnblogs.com/dudu1992/p/8977288.html