涉及资源
1.官网DEEP LEARNING WITH PYTORCH: A 60 MINUTE BLITZ
2.莫烦python 个人网站 、 b站视频、参考代码
3.函数搜索:https://pytorch.org/docs/stable/index.html
系列学习笔记:
Pytorch学习笔记(一)
Pytorch学习笔记(二)
Pytorch学习笔记(三)
本周学习内容:
Numpy torch对比
激励函数
pytorch实现Regression
pytorch实现Classification
pytorch快速搭建法实现Classification
pytorch实现网络的保存与提取
pytorch实现batch_train
pytorch实现optimizer性能比对
pytorch实现CNN,识别MNIST数据集
环境配置:
python=3.7; torch=1.6.0; torchvision=0.7.0
1、Regression
import torch
from torch.autograd import Variable
import torch.nn.functional as F # 拿到一些激励函数
import matplotlib.pyplot as plt
## data
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) # unsqueeze多加一维,因为Variable输入为二维
y = x.pow(2) + 0.2 * torch.rand(x.size())
# x, y = Variable(x), Variable(y) # 放在Varible的篮子里
# plt.scatter(x.data.numpy(), y.data.numpy())
# plt.show()
## NET
class Net(torch.nn.Module): # 继承torch的模块
def __init__(self, n_feature, n_hidden, n_output):# 定义层
super(Net, self).__init__()# 调用父类的初始化
self.hidden = torch.nn.Linear(n_feature, n_hidden)
self.predict = torch.nn.Linear(n_hidden, n_output)
def forward(self, x):# 前向传递,搭建神经网络,x = inputData
x = F. relu(self.hidden(x))
x = self.predict(x) # 回归预测的时候一般不用激励函数,加了relu无法预测负值
return x
## 训练 + 可视化过程
net = Net(1, 15, 1)
print(net)
plt.ion() # 实时打印
plt.show()
optimizer = torch.optim.SGD(net.parameters(), lr=0.5) # 网络优化.lr一般小于1
# loss_func = F.mse_loss()# 均方差
for t in range(100):# 训练100步
prediction = net(x)# output
loss = F.mse_loss(prediction, y)
# 优化
optimizer.zero_grad() # clear gradients for this training
loss.backward() # backpropagation, compute gradients
optimizer.step() # apply gradients
if t % 5 == 0:# 学习五步打印一次
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)
plt.ioff()
plt.show()
print(net)
Net(
(hidden): Linear(in_features=1, out_features=15, bias=True)
(predict): Linear(in_features=15, out_features=1, bias=True)
)
2、CLassification
import torch
from torch.autograd import Variable
import torch.nn.functional as F # 拿到一些激励函数
import matplotlib.pyplot as plt
## make fake data
n_data = torch.ones(100, 2)
x0 = torch.normal(2*n_data, 1) # class0 x data (tensor), shape=(100, 2)
y0 = torch.zeros(100) # class0 y data (tensor), shape=(100, 1)
x1 = torch.normal(-2*n_data, 1) # class1 x data (tensor), shape=(100, 2)
y1 = torch.ones(100) # class1 y data (tensor), shape=(100, 1)
# 数据和标签转换为 torch 中默认的形式
x = torch.cat((x0, x1), 0).type(torch.FloatTensor) # shape (200, 2) FloatTensor = 32-bit floating; cat合并
y = torch.cat((y0, y1), ).type(torch.LongTensor) # shape (200,) LongTensor = 64-bit integer
# 现在autograd 直接支持tensors了
# x, y = Variable(x), Variable(y) # 放在Varible的篮子里
plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=50, lw=0, cmap='RdYlGn')
plt.show()
## method 1
class Net(torch.nn.Module): # 继承torch的模块
def __init__(self, n_feature, n_hidden, n_output):# 定义层
super(Net, self).__init__()# 调用父类的初始化
self.hidden = torch.nn.Linear(n_feature, n_hidden)
self.predict = torch.nn.Linear(n_hidden, n_output)
def forward(self, x):# 前向传递,搭建神经网络,x = inputData
x = F. relu(self.hidden(x))
x = self.predict(x) # 回归预测的时候一般不用激励函数,加了relu无法预测负值
return x
## 训练 + 可视化过程
net1 = Net(2, 10, 2)
## method 2
net2 = torch.nn.Sequential(# 一层一层
torch.nn.Linear(2, 10),
torch.nn.ReLU(),# 区别
torch.nn.Linear(10, 2),
)
print(net1)
print(net2)
plt.ion() # 实时打印
plt.show()
optimizer = torch.optim.SGD(net2.parameters(), lr=0.01) # 网络优化.lr一般小于1
for t in range(100):# 训练100步
out = net2(x)
loss = F.cross_entropy(out, y) # 交叉熵,用于多分类问题
# 优化
optimizer.zero_grad() # pytorch计算梯度不是覆盖,与上一次的求和,net.parameters手动清0
loss.backward() # Variable反向传递
optimizer.step() # 更新参数
if t % 2 == 0:
# plot and show learning process
plt.cla()
prediction = torch.max(out, 1)[1] # softmax变成prediction,概率
pred_y = prediction.data.numpy()
target_y = y.data.numpy()
plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, s=100, lw=0, cmap='RdYlGn')
accuracy = float((pred_y == target_y).astype(int).sum()) / float(target_y.size)
plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color': 'red'})
plt.pause(0.1)
plt.ioff()
plt.show()
print(net1)
Net(
(hidden): Linear(in_features=2, out_features=10, bias=True)
(predict): Linear(in_features=10, out_features=2, bias=True)
)
print(net2)
Sequential(
(0): Linear(in_features=2, out_features=10, bias=True)
(1): ReLU()
(2): Linear(in_features=10, out_features=2, bias=True)
)
3、save_reload
import torch
import matplotlib.pyplot as plt
import torch.nn.functional as F
# torch.manual_seed(1) # reproducible
# data
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) # x data (tensor), shape=(100, 1)
y = x.pow(2) + 0.2*torch.rand(x.size()) # noisy y data (tensor), shape=(100, 1)
# Pytorch 0.4可以直接用tensors
# x, y = Variable(x, requires_grad=False), Variable(y, requires_grad=False)
def save():
# save net1
net1 = torch.nn.Sequential(
torch.nn.Linear(1, 10),
torch.nn.ReLU(),
torch.nn.Linear(10, 1)
)
optimizer = torch.optim.SGD(net1.parameters(), lr=0.5)
# loss_func = torch.nn.MSELoss()
for t in range(100):
prediction = net1(x)
loss = F.mse_loss(prediction, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
# plot result
plt.figure(1, figsize=(10, 3))
plt.subplot(131)
plt.title('Net1')
plt.scatter(x.data.numpy(), y.data.numpy())
plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
# 2 ways to save the net
torch.save(net1, 'net.pkl') # save entire net,以pkl形式保存
torch.save(net1.state_dict(), 'net_params.pkl') # save only the parameters
def restore_net():
net2 = torch.load('net.pkl')
prediction = net2(x)
# plot result
plt.subplot(132)
plt.title('Net2')
plt.scatter(x.data.numpy(), y.data.numpy())
plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
def restore_params():
net3 = torch.nn.Sequential(
torch.nn.Linear(1, 10),
torch.nn.ReLU(),
torch.nn.Linear(10, 1)
)
# copy net1's parameters into net3
net3.load_state_dict(torch.load('net_params.pkl'))
prediction = net3(x)
# plot result
plt.subplot(133)
plt.title('Net3')
plt.scatter(x.data.numpy(), y.data.numpy())
plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
plt.show()
save()
restore_net()
restore_params()
4、batch_train
import torch
import torch.utils.data as Data
# BATCH_SIZE = 5
BATCH_SIZE = 8
x = torch.linspace(1, 10, 10) # torch tensor
y = torch.linspace(10,1,10) # torch tensor
torch_dataset = Data.TensorDataset(x, y)
loader = Data.DataLoader(
dataset=torch_dataset,
batch_size=BATCH_SIZE,
shuffle=True,#打乱数据
num_workers=0,# 2线程
)
for epoch in range(3):
for step, (batch_x, batch_y) in enumerate(loader):
# training
print('Epoch: ',epoch,'| Step: ', step, '| batch x: ',batch_x.numpy(), '| batch y: ', batch_y.numpy())
数据个数为10,BATCH_SIZE = 8,EPOCH = 3时
Epoch: 0 | Step: 0 | batch x: [ 2. 1. 8. 9. 4. 5. 10. 3.] |batch y: [ 9. 10. 3. 2. 7. 6. 1. 8.]
Epoch: 0 | Step: 1 |batch x: [6. 7.] | batch y: [5. 4.]
Epoch: 1 | Step: 0 | batch x: [ 1. 10. 6. 9. 2. 5. 4. 8.] | batch y: [10. 1. 5. 2. 9. 6.7. 3.]
Epoch: 1 | Step: 1 | batch x: [3. 7.] | batch y: [8. 4.]
Epoch: 2 | Step: 0 | batch x: [ 4. 7. 10. 8. 9. 6. 5. 2.] | batch y: [7. 4. 1. 3. 2. 5. 6. 9.]
Epoch: 2 | Step: 1 | batch x: [1. 3.] | batch y: [10. 8.]
数据个数为10,BATCH_SIZE = 5,EPOCH = 3时
Epoch: 0 | Step: 0 | batch x: [ 7. 10. 5. 1. 8.] | batch y: [4. 1. 6. 10. 3.]
Epoch: 0 | Step: 1 | batch x: [6. 3. 2. 9. 4.] | batch y: [5. 8. 9. 2. 7.]
Epoch: 1 | Step: 0 | batch x: [4. 7. 2. 5. 1.] | batch y: [ 7. 4. 9. 6. 10.]
Epoch: 1 | Step: 1 | batch x: [ 9. 10. 8. 3. 6.] | batch y: [2. 1. 3. 8. 5.]
Epoch: 2 | Step: 0 | batch x: [ 7. 4. 8. 10. 1.] | batch y: [ 4. 7. 3. 1. 10.]
Epoch: 2 | Step: 1 | batch x: [6. 5. 9. 3. 2.] | batch y: [5. 6. 2. 8. 9.]
5、optimizer
import torch
import torch.utils.data as Data
import torch.nn.functional as F
import matplotlib.pyplot as plt
# hyper para
LR = 0.01
BATCH_SIZE = 32
EPOCH = 12
# fake dataset
x = torch.unsqueeze(torch.linspace(-1, 1, 1000), dim=1)# unsqueeze多加一维
y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size()))
# put dateset into torch dataset
torch_dataset = Data.TensorDataset(x, y)
loader = Data.DataLoader(
dataset=torch_dataset,
batch_size=BATCH_SIZE,
shuffle=True, # 打乱数据
num_workers=0, # 2线程
)
# default network
class Net(torch.nn.Module):
def __init__(self):
super(Net, self).__init__()
self.hidden = torch.nn.Linear(1, 20) # hidden layer
self.predict = torch.nn.Linear(20, 1) # output layer
def forward(self, x):
x = F.relu(self.hidden(x)) # activation function for hidden layer
x = self.predict(x) # linear output
return x
if __name__ == '__main__':
# different nets
net_SGD = Net()
net_Momentum = Net()
net_RMSprop = Net()
net_Adam = Net()
nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam] #放在一个list当中
# different optimizers
opt_SGD = torch.optim.SGD(net_SGD.parameters(), lr=LR)
opt_Momentum = torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8)
opt_RMSprop = torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)
opt_Adam = torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))
optimizers = [opt_SGD, opt_Momentum, opt_RMSprop, opt_Adam]
losse_his = [[],[],[],[]] # record loss
for epoch in range(EPOCH):
print(epoch)
for step,(batch_x, batch_y) in enumerate(loader):
for net, opt, l_his in zip(nets, optimizers, losse_his):
output = net(batch_x) # get output for every net
loss = F.mse_loss(output, batch_y) # compute loss for every net
l_his.append(loss.data.numpy()) # loss recoder
opt.zero_grad() # clear gradients for next train
loss.backward() # backpropagation, compute gradients
opt.step() # apply gradients
labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
for i, l_his, in enumerate(losse_his):
plt.plot(l_his, label=labels[i])
plt.legend(loc='best')
plt.xlabel('Steps')
plt.ylabel('Loss')
plt.ylim((0, 0.2))
plt.show()
优化器理论可参考:https://blog.csdn.net/weixin_40170902/article/details/80092628