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