學習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)