激活函数的使用

首先导入我们需要的包：
image.png
其中torch.nn.functional中的nn是神经网络模块
通过pytorch计算各个激活函数的值：
image.png
最后使用matpplotlib画出来：
image.png

Regression（回归）

  1. import torch
  2. import torch.nn.functional as F
  3. import matplotlib.pyplot as plt
  7. x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # x data (tensor), shape=(100, 1)  自己定义的数据
  8. y = x.pow(2) + 0.2*torch.rand(x.size())                 # noisy y data (tensor), shape=(100, 1)   自己定义的函数
  10. # torch can only train on Variable, so convert them to Variable
  11. # The code below is deprecated in Pytorch 0.4. Now, autograd directly supports tensors
  12. # x, y = Variable(x), Variable(y)
  14. # plt.scatter(x.data.numpy(), y.data.numpy())
  15. # plt.show()
  18. class Net(torch.nn.Module):              #用class来定义neural network 
  19.     def __init__(self, n_feature, n_hidden, n_output):       #其中包含了初始化层所需要的信息
  20.         super(Net, self).__init__()
  21.         self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer
  22.         self.predict = torch.nn.Linear(n_hidden, n_output)   # output layer
  24.     def forward(self, x):                 #network中前一项传递的过程
  25.         x = F.relu(self.hidden(x))      # activation function for hidden layer
  26.         x = self.predict(x)             # linear output
  27.         return x
  29. net = Net(n_feature=1, n_hidden=10, n_output=1)     # define the network
  30. print(net)  # net architecture
  32. optimizer = torch.optim.SGD(net.parameters(), lr=0.2)           #使用SGD方法对我们的函数进行优化，net.parameters()是net中所有的参数，lr是learning rate学习效率（不宜太低或太高）
  33. loss_func = torch.nn.MSELoss()  # this is for regression mean squared loss       主要用于回归问题，与分类问题不同
  35. plt.ion()   # something about plotting
  37. for t in range(200):
  38.     prediction = net(x)     # input x and predict based on x
  40.     loss = loss_func(prediction, y)     # must be (1. nn output, 2. target)
  42.     optimizer.zero_grad()   # clear gradients for next train
  43.     loss.backward()         # backpropagation, compute gradients
  44.     optimizer.step()        # apply gradients     更新参数
  46.     if t % 5 == 0:
  47.         # plot and show learning process
  48.         plt.cla()
  49.         plt.scatter(x.data.numpy(), y.data.numpy())
  50.         plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
  51.         plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color':  'red'})
  52.         plt.pause(0.1)
  54. plt.ioff()
  55. plt.show()

Classification(分类)

  1. import torch
  2. import torch.nn.functional as F
  3. import matplotlib.pyplot as plt
  5. # torch.manual_seed(1)    # reproducible
  7. # 自己制作的假的数据
  8. n_data = torch.ones(100, 2)
  9. x0 = torch.normal(2*n_data, 1)      # class0 x data (tensor), shape=(100, 2)
  10. y0 = torch.zeros(100)               # class0 y data (tensor), shape=(100, 1)
  11. x1 = torch.normal(-2*n_data, 1)     # class1 x data (tensor), shape=(100, 2)
  12. y1 = torch.ones(100)                # class1 y data (tensor), shape=(100, 1)
  13. x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # shape (200, 2) FloatTensor = 32-bit floating
  14. y = torch.cat((y0, y1), ).type(torch.LongTensor)    # shape (200,) LongTensor = 64-bit integer
  16. # The code below is deprecated in Pytorch 0.4. Now, autograd directly supports tensors
  17. # x, y = Variable(x), Variable(y)
  19. # plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
  20. # plt.show()
  23. class Net(torch.nn.Module):
  24.     def __init__(self, n_feature, n_hidden, n_output):
  25.         super(Net, self).__init__()
  26.         self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer
  27.         self.out = torch.nn.Linear(n_hidden, n_output)   # output layer
  29.     def forward(self, x):
  30.         x = F.relu(self.hidden(x))      # activation function for hidden layer
  31.         x = self.out(x)
  32.         return x
  34. net = Net(n_feature=2, n_hidden=10, n_output=2)     # define the network
  35. print(net)  # net architecture
  37. optimizer = torch.optim.SGD(net.parameters(), lr=0.02)
  38. loss_func = torch.nn.CrossEntropyLoss()  # 主要用于分类问题计算loss
  40. plt.ion()   # something about plotting
  42. for t in range(100):
  43.     out = net(x)                 # input x and predict based on x
  44.     loss = loss_func(out, y)     # must be (1. nn output, 2. target), the target label is NOT one-hotted
  46.     optimizer.zero_grad()   # clear gradients for next train
  47.     loss.backward()         # backpropagation, compute gradients
  48.     optimizer.step()        # apply gradients
  50.     if t % 2 == 0:
  51.         # plot and show learning process
  52.         plt.cla()
  53.         prediction = torch.max(out, 1)[1]
  54.         pred_y = prediction.data.numpy()
  55.         target_y = y.data.numpy()
  56.         plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, s=100, lw=0, cmap='RdYlGn')
  57.         accuracy = float((pred_y == target_y).astype(int).sum()) / float(target_y.size)
  58.         plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color':  'red'})
  59.         plt.pause(0.1)
  61. plt.ioff()
  62. plt.show()

快速搭建神经网络

  1. class Net(torch.nn.Module):
  2.     def __init__(self, n_feature, n_hidden, n_output):
  3.         super(Net, self).__init__()
  4.         self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer
  5.         self.predict = torch.nn.Linear(n_hidden, n_output)   # output layer
  7.     def forward(self, x):
  8.         x = F.relu(self.hidden(x))      # activation function for hidden layer
  9.         x = self.predict(x)             # linear output
  10.         return x
  12. net1 = Net(1, 10, 1)
  14. net2 = torch.nn.Sequential(
  15.     torch.nn.Linear(1, 10),
  16.     torch.nn.ReLU(),
  17.     torch.nn.Linear(10, 1)
  18. )

两种方法的结果，大致相同
image.png

保存和提取神经网络

  1. import torch
  2. import matplotlib.pyplot as plt
  4. # torch.manual_seed(1)    # reproducible
  6. # fake data
  7. x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # x data (tensor), shape=(100, 1)
  8. y = x.pow(2) + 0.2*torch.rand(x.size())  # noisy y data (tensor), shape=(100, 1)
  10. # The code below is deprecated in Pytorch 0.4. Now, autograd directly supports tensors
  11. # x, y = Variable(x, requires_grad=False), Variable(y, requires_grad=False)
  14. def save():
  15.     # save net1
  16.     net1 = torch.nn.Sequential(
  17.         torch.nn.Linear(1, 10),
  18.         torch.nn.ReLU(),
  19.         torch.nn.Linear(10, 1)
  20.     )
  21.     optimizer = torch.optim.SGD(net1.parameters(), lr=0.5)
  22.     loss_func = torch.nn.MSELoss()
  24.     #训练
  25.     for t in range(100):
  26.         prediction = net1(x)
  27.         loss = loss_func(prediction, y)
  28.         optimizer.zero_grad()
  29.         loss.backward()
  30.         optimizer.step()
  32.     # plot result
  33.     plt.figure(1, figsize=(10, 3))
  34.     plt.subplot(131)
  35.     plt.title('Net1')
  36.     plt.scatter(x.data.numpy(), y.data.numpy())
  37.     plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
  39.     # 2 ways to save the net
  40.     torch.save(net1, 'net.pkl')  # 保存整个神经网络
  41.     torch.save(net1.state_dict(), 'net_params.pkl')   # 保存神经网络中的参数
  44. def restore_net():
  45.     # 提取net1并赋给net2
  46.     net2 = torch.load('net.pkl')    
  47.     prediction = net2(x)
  49.     # plot result
  50.     plt.subplot(132)
  51.     plt.title('Net2')
  52.     plt.scatter(x.data.numpy(), y.data.numpy())
  53.     plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
  56. def restore_params():
  57.     # 提取net1中的参数赋值给net3，首先要创建一个和net1相同结构的net3，再进行赋值
  58.     net3 = torch.nn.Sequential(
  59.         torch.nn.Linear(1, 10),
  60.         torch.nn.ReLU(),
  61.         torch.nn.Linear(10, 1)
  62.     )
  64.     # 对net3进行赋值
  65.     net3.load_state_dict(torch.load('net_params.pkl'))
  66.     prediction = net3(x)
  68.     # plot result
  69.     plt.subplot(133)
  70.     plt.title('Net3')
  71.     plt.scatter(x.data.numpy(), y.data.numpy())
  72.     plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
  73.     plt.show()
  75. # save net1
  76. save()
  78. # restore entire net (may slow)
  79. restore_net()
  81. # restore only the net parameters
  82. restore_params()

批处理

  1. import torch
  2. import torch.utils.data as Data
  4. torch.manual_seed(1)    # reproducible
  6. BATCH_SIZE = 5
  7. # BATCH_SIZE = 8
  9. x = torch.linspace(1, 10, 10)       # this is x data (torch tensor)
  10. y = torch.linspace(10, 1, 10)       # this is y data (torch tensor)
  12. torch_dataset = Data.TensorDataset(x, y)
  13. loader = Data.DataLoader(
  14.     dataset=torch_dataset,      # torch TensorDataset format
  15.     batch_size=BATCH_SIZE,      # 在一个epoch中每次batch读取多少个数据
  16.     shuffle=True,               # 是否要打乱进行读取
  17.     num_workers=2,              # subprocesses for loading data
  18. )
  21. def show_batch():
  22.     for epoch in range(3):   #全部数据共训练3次
  23.         for step, (batch_x, batch_y) in enumerate(loader):  # for each training step
  24.             # train your data...
  25.             print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',
  26.                   batch_x.numpy(), '| batch y: ', batch_y.numpy())
  29. if __name__ == '__main__':
  30.     show_batch()

当BATCH_SIZE=5，shuffle = Ture时：
image.png
当BATCH_SIZE=8，shuffle = Fause时：
image.png