Pytorch 初识

文章目录

• 一个简单的回归网络的例子
• 再来一个例子
• 官方教程上图片识别的例子

import torch
import torch.nn as nn
import torch.nn.functional as F
import matplotlib.pyplot as plt #这个一直想学，还没学，代码从莫烦python那copy的
import torchvision
import torchvision.transforms as transforms
import numpy as np

很遗憾，看了半天还是没怎么学会，只能先记录俩个例子放在这里了。然后Pytorch就先告一段落吧。

一个简单的回归网络的例子

这个例子是对莫烦python那例子的一个修改（主要是自己玩了下，懒得弄回去了）

x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) # x data (tensor), shape=(100, 1)
y = 4 * x ** 3 + x ** 2 + 3 * x + 0.2*torch.rand(x.size())

class Net(torch.nn.Module):  # 继承 torch 的 Module
    def __init__(self):
        super(Net, self).__init__()     # 继承 __init__ 功能
        # 定义每层用什么样的形式
        self.hidden = nn.Linear(1, 7)   # 隐藏层线性输出
        #self.hidden2 = torch.nn.Linear(3, 7)
        self.predict = nn.Linear(7, 1)   # 输出层线性输出
        self.active = nn.Tanh()  # 这里的激活函数玩得挺多的，带ReLU的一般效果都不错，还有Softshrink 有正有负效果也很好啊

    def forward(self, x):   # 这同时也是 Module 中的 forward 功能
        # 正向传播输入值, 神经网络分析出输出值
        x = self.active(self.hidden(x))      # 激励函数(隐藏层的线性值)
        #x = self.active(self.hidden2(x))
        x = self.predict(x)             # 输出值
        return x

net = Net()

plt.ion()   # 画图
plt.show()

optimizer = torch.optim.SGD(net.parameters(), lr=0.1, momentum=0.9)  # 传入 net 的所有参数, 学习率
loss_func = nn.MSELoss()
for t in range(100):

    prediction = net(x)     # 喂给 net 训练数据 x, 输出预测值
    loss = loss_func(prediction, y)     # 计算两者的误差
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    # 接着上面来
    if t % 20 == 0:
        # plot and show learning process
        plt.cla()
        plt.scatter(x.data.numpy(), y.data.numpy())
        plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
        plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color':  'red'})
        plt.pause(0.1)

有很多很有趣的现象，主要就是跟参数有关的东西：

self.hidden = nn.Linear(1, 100)
self.predict = nn.Linear(100, 1)

可能会出现下面的情况：

增加一个隐藏层也往往会这样。这个就是所谓的梯度爆炸？这类名字我也只是听过，到时候再深入吧，在此记一笔。

Tanh() 改为 Softshrink 就没问题了（因为Softshrink有正有负所以会有所抵消？）

再者：

x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) * 3

一样会炸，所以要很小心才行啊（对了，调小学习率可以应付这种情况）。

没一会功夫，最大参数的值就突破天际了。

再来一个例子

class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(3, 7)
        #self.fc2 = nn.Linear(7, 5)
        self.fc3 = nn.Linear(7, 1)
        self.active = nn.ReLU()

    def forward(self, x):

        x = self.active(self.fc1(x))
        #x = self.active(self.fc2(x))
        x = self.fc3(x)

        return x

net = Net()
print(net)

# y =  x1 ** 3 + x2 ** 2 + x3 + e
x = torch.rand(100, 3)
y = x[:,0] ** 3 + x[:,1] ** 2 + x[:, 2] + torch.randn(100) * 0.05

optimizer = torch.optim.SGD(net.parameters(), lr=0.005, momentum = 0.9)
loss_func = nn.MSELoss()
for t in range(200):

    pre = net(x)
    loss = loss_func(pre, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    #print('step: {0} | loss: {1}'.format(t, loss))

#结果很遗憾，最后都会趋于一个值，咋搞，弄不明白啊。

官方教程上图片识别的例子

图片是 3×32×323 \times 32 \times 323×32×32的

transform = transforms.Compose(   #转换格式
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,  #训练样本
                                        download=False, transform=transform) #我下好了所以是False
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=0) #num_workers 好像是线程进程的处理，但是我用了这个会崩，就改成0  shuffle 打扰顺序， batch_size,一个数据分成几堆，批训练。
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=False, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=0)
classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
def imshow(img):
    img = img / 2 + 0.5     # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()    

dataiter = iter(trainloader)
images, labels = dataiter.next()
imshow(torchvision.utils.make_grid(images))

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)  # (3,6,5) in_channel:3,out_channel:6,kernel_size:5 * 5
	#说人话就是，输入的图片是3个通道的（RGB），卷积后的图片是6个通道的，就是6层的矩阵
        self.pool = nn.MaxPool2d(2, 2)  #池化
        self.conv2 = nn.Conv2d(6, 16, 5) #卷积
        self.fc1 = nn.Linear(16 * 5 * 5, 120)  #全连接层
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x))) #图片大小转换：(3,32,32)->(6,28,28)->(6,14,14)
        x = self.pool(F.relu(self.conv2(x))) #图片大小转换: (6,14,14)->(16,10,10)->(16,5,5)
        x = x.view(-1, 16 * 5 * 5)  #这玩意儿是用来排列图像的 (16,5,5)是从上面得到的
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()                    

criterion = nn.CrossEntropyLoss() #交叉熵
optimizer = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
for epoch in range(2):  # loop over the dataset multiple times 整体数据走2遍
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs
        inputs, labels = data

        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # print statistics
        running_loss += loss.item()
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')                                                                                          

#测试数据
dataiter = iter(testloader)
images, labels = dataiter.next()

imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

outputs = net(images)

_, predicted = torch.max(outputs, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
                              for j in range(4)))