Pytorch

一、加载预训练模型

#-*- coding: utf-8 -*-
# Pytorch 加载预训练模型
import torch
import torch.nn as nn

import torchvision.models as models
 
 
## 1. 直接加载预训练模型
net = SNet()
net.load_state_dict(torch.load("model_1599.pkl"))

# 这种方式是针对于之前保存模型时以保存参数的格式使用的：
torch.save(net.state_dict(), "model/model_1599.pkl")
# pytorch官网更推荐上述模型保存方法，也据说这种方式比下一种更快一点。


# 下面介绍第二种模型保存和加载的方式：
net = SNet()
torch.save(net, "model_1599.pkl")

snet = torch.load("model_1599.pkl")
#这种方式会将整个网络保存下来，数据量会更大，会消耗更多的时间，占用内存也更高。

 

 
## 加载部分预训练模型
# 其实大多数时候我们需要根据我们的任务调节我们的模型，所以很难保证模型和公开的模型完全一样，
# 但是预训练模型的参数确实有助于提高训练的准确率，为了结合二者的优点，就需要我们加载部分预训练模型。

# 加载model，model是自己定义好的模型
resnet50 = models.resnet50(pretrained=True) 
model =Net(...) 
 
# 读取参数 
pretrained_dict =resnet50.state_dict() 
model_dict = model.state_dict() 
 
# 将pretrained_dict里不属于model_dict的键剔除掉 
pretrained_dict =  {k: v for k, v in pretrained_dict.items() if k in model_dict} 
 
# 更新现有的model_dict 
model_dict.update(pretrained_dict) 
 
# 加载我们真正需要的state_dict 
model.load_state_dict(model_dict)  

二、全连接神经网络

1. 分类

#-*- coding: utf-8 -*-
from __future__ import division
from __future__ import print_function

import torch 
from torch.autograd import Variable 
import torch.nn.functional as F 
import matplotlib.pyplot as plt 
 
# 生成数据 
# 分别生成2组各100个数据点，增加正态噪声，后标记以y0=0 y1=1两类标签，最后cat连接到一起 
n_data = torch.ones(100,2) 
# torch.normal(means, std=1.0, out=None) 
x0 = torch.normal(2*n_data, 1) # 以tensor的形式给出输出tensor各元素的均值，共享标准差 
y0 = torch.zeros(100) 
x1 = torch.normal(-2*n_data, 1) 
y1 = torch.ones(100) 
 
x = torch.cat((x0, x1), 0).type(torch.FloatTensor) # 组装（连接） 
y = torch.cat((y0, y1), 0).type(torch.LongTensor) 
 
# 置入Variable中 
x, y = Variable(x), Variable(y) 
 
class Net(torch.nn.Module): 
  def __init__(self, n_feature, n_hidden, n_output): 
    super(Net, self).__init__() 
    self.hidden = torch.nn.Linear(n_feature, n_hidden) 
    self.out = torch.nn.Linear(n_hidden, n_output) 
 
  def forward(self, x): 
    x = F.relu(self.hidden(x)) 
    x = self.out(x) 
    return x 
 
net = Net(n_feature=2, n_hidden=10, n_output=2) 
print(net) 
 
optimizer = torch.optim.SGD(net.parameters(), lr=0.012) 
loss_func = torch.nn.CrossEntropyLoss() 
 
plt.ion() 
plt.show() 
 
for t in range(100): 
  out = net(x) 
  loss = loss_func(out, y) # loss是定义为神经网络的输出与样本标签y的差别，故取softmax前的值 
 
  optimizer.zero_grad() 
  loss.backward() 
  optimizer.step() 
 
  if t % 2 == 0: 
    plt.cla() 
    # 过了一道 softmax 的激励函数后的最大概率才是预测值 
    # torch.max既返回某个维度上的最大值，同时返回该最大值的索引值 
    prediction = torch.max(F.softmax(out), 1)[1] # 在第1维度取最大值并返回索引值 
    pred_y = prediction.data.numpy().squeeze() 
    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 = sum(pred_y == target_y)/200 # 预测中有多少和真实值一样 
    plt.text(1.5, -4, 'Accu=%.2f' % accuracy, fontdict={'size': 20, 'color': 'red'}) 
    plt.pause(0.1) 
 
plt.ioff() 
plt.show() 

2. 回归

#-*- coding: utf-8 -*
# 参考： https://www.jb51.net/article/139098.htm
import os
import sys
from torchsummary import summary

import torch 
from torch.autograd import Variable 
import torch.nn.functional as F 
import matplotlib.pyplot as plt 


save_folder = './'

# 将1维的数据转换为2维数据 https://blog.csdn.net/xiexu911/article/details/80820028
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) 
print (x.size())
b = torch.rand(x.size()) 
print(b.size())
y = x.pow(2) + 0.2 
  
# 将tensor置入Variable中 
x, y = Variable(x), Variable(y) 
x, y = x.cuda(), y.cuda()
#plt.scatter(x.data.numpy(), y.data.numpy()) 
#plt.show() 
  
# 定义一个构建神经网络的类 
class Net(torch.nn.Module): # 继承torch.nn.Module类 
  def __init__(self, n_feature, n_hidden, n_output): 
    super(Net, self).__init__() # 获得Net类的超类（父类）的构造方法 
    # 定义神经网络的每层结构形式 
    # 各个层的信息都是Net类对象的属性 
    self.hidden = torch.nn.Linear(n_feature, n_hidden) # 隐藏层线性输出 
    self.predict = torch.nn.Linear(n_hidden, n_output) # 输出层线性输出 
  
  # 将各层的神经元搭建成完整的神经网络的前向通路 
  def forward(self, x): 
    x = F.relu(self.hidden(x)) # 对隐藏层的输出进行relu激活 
    x = self.predict(x) 
    return x 
  
# 定义神经网络 
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # PyTorch v0.4.0
net = Net(1, 20, 1).to(device)
print(net) # 打印输出net的结构 

# 定义优化器和损失函数 
optimizer = torch.optim.SGD(net.parameters(), lr=0.5) # 传入网络参数和学习率 
loss_function = torch.nn.MSELoss() # 最小均方误差 

# Print model architecture.
summary(net, (100, 1))
f = open(os.path.join(save_folder, 'arch.txt'), 'w')
sys.stdout = f
summary(net, (100, 1))
sys.stdout = sys.__stdout__
f.close()


# 神经网络训练过程 
plt.ion()  # 动态学习过程展示 
plt.show() 
  
for t in range(600): 
  y_pred = net(x) # 把数据x喂给net，输出预测值 
  loss = loss_function(y_pred, y) # 计算两者的误差，要注意两个参数的顺序 
  optimizer.zero_grad() # 清空上一步的更新参数值 
  loss.backward() # 误差反相传播，计算新的更新参数值 
  optimizer.step() # 将计算得到的更新值赋给net.parameters() 


  # 可视化训练过程 
  if (t+1) % 10 == 0: 
    plt.cla() 
    plt.scatter(x.data.cpu().numpy(), y.data.cpu().numpy()) 
    plt.plot(x.data.cpu().numpy(), y_pred.data.cpu().numpy(), 'r-', lw=5) 
    plt.text(-0.2, 1.1, 'L=%.4f' % loss.item(), fontdict={'size': 20, 'color': 'red'}) 
    plt.ylabel("y")
    plt.xlabel("x")
    plt.pause(0.1)
    
'''
plt 相关函数说明
1. plt.scatter(x, y, s, c ,marker, alpha)  散点图
    x,y: x轴与y轴的数据
    s: 点的面积
    c: 点的颜色
    marker: 点的形状
    alpha: 透明度
 
2. plt.plot   
   参考：https://blog.csdn.net/u014539580/article/details/78207537
'''

// An highlighted block
var foo = 'bar';