莫烦

1. Numpy VS Torch

#相互转换
np_data = torch_data.numpy()
torch_data = torch.from_numpy(np_data)
#abs
data = [1, 2, -2, -1] #array
tensor = torch.FloatTensor(data) #32bit 传入普通数组
np.abs(data); torch.abs(tensor);
#矩阵相乘
data.dot(data) #但是要先转换为numpy的data data=np.array(data)
torch.mm(tensor, tensor)

2. Variable

#引入
from torch.autograd import Variable
#声明
variable = Varible(tensor, requires_grad=True)
variable.data #type是tensor

3. Activation Function 激励函数

y = AF(Wx) 画图

#引入
import torch.nn.function as F
import matplotlib.pyplot as plt
#fake data
x = torch.linspace(-5, 5, 200)
x = Variable(x)
x_np = x.data.numpy() ***
#activation
y_relu = F.relu(x).data.numpy() ***

plt.plot(x_np, y_relu, c='red', label='relu')

4. Regression 回归

# 动态更新画图
plt.ion()
plt.show()

#for循环中的if条件内部
  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, fontdict={'size':20, 'color': 'red'})
  plt.pause(0.1)
  
#for外部
plt.ioff()
plt.show()

#net层的定义看regression代码！

5. Classification 分类

#二元分类 模拟数据 及 画图
n_data = torch.ones(100, 2) # shape(100, 2)
x0 = torch.normal(2*n_data, 1)
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)).type(torch.LongTensor) #label 只能是integer类型

x, y = Variable(x), Variable(y)

plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
plt.show()

#输入二维 hiddenlayer10个神经元 输入也是二维
net = Net(2, 10, 2)

#优化使用
loss_func = torch.nn.CrossEntropyLoss()

#for循环内部 区分out 和 prediction
out = net(x) #此时的out格式是很乱的
loss = loss_func(out, y) #两者的误差

prediction = torch.max(F.softmax(out), 1)[1] # 过了一道 softmax 的激励函数后的最大概率才是预测值
accuracy = sum(pre_y == target_y) / 200 #预测有多少和真实值一样

6. 快速搭建法

net = torch.nn.Sequential(
	torch.nn.Linear(2, 10),
	torch.nn.ReLU(),
	torch.nn.Linear(10, 2)
)

7. 保存提取

使用两种方式提取整个神经网络：提取整个网络或只提取参数。

两段式声明，在save中保存，在restore中提取，最后显示。

def save():
  #建网络#
  #训练#
  #保存
  torch.save(net1, 'net.pkl') #保存整个网络
  torch.save(net1.state_dict(), 'net_params.pkl') #只保存网络中的参数

#提取整个网络
def restore_net():
  net2 = torch.load('net.pkl')
  prediction = net2(x)
  
#只提取网络参数
def restore_params():
  net3 = ... #net3 = net1
  net3.load_state_dict(torch.load('net_params.pkl'))
  prediction = net3(x)
  
#显示结果
save()
restore_net()
restore_params()

8. 批数据训练

#数据引入
import torch.utils.data as Data
# 先定义batchsize
BATCH_SIZE = 5
# 转换torch为Dataset
torch_dataset = Data.TensorDataset(x, y) #(1)
loader = Data.DataLoader(...)
#for循环内的读取
for step, (batch_x, batch_y) in enumerate(loader):
#如果在loader中开了多线程
if __name__ == '__main__': #加上双线程的入口
  #(1)

9. Optimizer 优化器

#给每个优化器优化一个神经网络
net_SGD         = Net()
net_Momentum    = Net()
net_RMSprop     = Net()
net_Adam        = Net()
nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam]

#创建不同的优化器来训练不同的网络，并创建loss_func来计算误差
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]

loss_func = torch.nn.MSELoss()
losses_his = [[], [], [], []]   # 记录 training 时不同神经网络的 loss

#训练每个优化器，优化属于自己的神经网络
for epoch in range(EPOCH):
    print('Epoch: ', epoch)
    for step, (b_x, b_y) in enumerate(loader):
        for net, opt, l_his in zip(nets, optimizers, losses_his): #都是列表
            output = net(b_x)              # get output for every net
            loss = loss_func(output, b_y)  # compute loss for every net
            opt.zero_grad()                # clear gradients for next train
            loss.backward()                # backpropagation, compute gradients
            opt.step()                     # apply gradients
            l_his.append(loss.data.numpy())     # loss recoder
            
#画图
labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
for i, l_his in enumerate(losses_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()