devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

PyTorch：开始入门的一些小代码上（from 莫烦）_accuracy = sum(pred_y == target_y)/200

作者：Monodyee | 2024-04-04 10:39:49

赞

踩

accuracy = sum(pred_y == target_y)/200


1.Tensor & numpy & Variable

  1. #torch和numpy的互相转化： .numpy()   .from_numpy()
  2. np_data = np.arange(6).reshape((2,3))
  3. torch_data = torch.from_numpy(np_data)
  4. tensor2array = torch_data.numpy()
  5. print(
  6.       '\nnumpy:',np_data,
  7.       '\ntorch:',torch_data,
  8.       '\ntensor2array:',tensor2array
  9.       )
  10.  
  11. #运算符：abs
  12. data = [-1,-2,1,2]
  13. tensor = torch.FloatTensor(data)  #32bit
  14. print(
  15.       '\nabs:',
  16.       '\nnumpy:',np.abs(data),
  17.       '\ntorch:',torch.abs(tensor)
  18.       )
  19. #运算符：sin
  20. print(
  21.       '\nsin:',
  22.       '\nnumpy:',np.sin(data),
  23.       '\ntorch:',torch.sin(tensor)
  24.       )
  25. #运算符：mean
  26. print(
  27.       '\nmean:',
  28.       '\nnumpy:',np.mean(data),
  29.       '\ntorch:',torch.mean(tensor)
  30.       )
  31.  
  32. #矩阵运算
  33. data = [[1,2],[3,4]]
  34. tensor = torch.FloatTensor(data)  #32bit
  35. print(
  36.       '\n矩阵相乘:',                     #Matrix Mutiply
  37.       '\nnumpy:',np.matmul(data,data),  
  38.       '\ntorch:',torch.mm(tensor,tensor)
  39.       )
  40. '''
  41. Tips:
  42. numpy矩阵相乘的另外一种方式:
  43. data = np.array(data)
  44. print(data.dot(data))
  46. 但是在torch里面这样做结果就不一样啦：
  47. print('torch:',tensor.dot(tensor))
  48. 输出结果是30.0
  49. 因为1*1+2*2+3*3+4*4=30
  51. '''
  52.  
  53. #Variable变量:tensor不能反向传播，但variable可以
  54. var = Variable(tensor,requires_grad=True)
  55. print('tensoe:\n',tensor)
  56. print('Variable:\n',var)
  57.  
  58. t_out = torch.mean(tensor*tensor)     #x^2
  59. v_out = torch.mean(var*var)
  60. print('tensor mean:\n',t_out)
  61. print('Variable mean:\n',v_out)
  62.  
  63. v_out.backward()  #backward propagation
  64. print('variable grad:\n',var.grad)  
  65. #因为v_out包含var,v_out = 1/4 * sum(var * var)
  66. #d(v_out)/d(var) = 1/4 * 2 * var = 1/2 * var
  67.  
  68. #print(var.data)
  69. #print(var.data.numpy())


2.激励函数 Activation Function

  1. #Activation Function:
  2. x = torch.linspace(-5,5,200)  #-5~5之间取200个点
  3. x = Variable(x)
  4. x_np = x.data.numpy()  #torch的数据格式不能被matplotlib识别，需要转化成numpy
  5.  
  6. y_relu = F.relu(x).data.numpy()
  7. y_sigmoid = F.sigmoid(x).data.numpy()
  8. y_tanh = F.tanh(x).data.numpy()
  9. y_softplus = F.softplus(x).data.numpy()
  10. #softmax计算的是分类问题的概率，对于线图无法做出
  11.  
  12. plt.figure(1,figsize=(8,6))
  13. plt.subplot(221)
  14. plt.plot(x_np,y_relu,c='red',label='relu')
  15. plt.ylim((-1,5))
  16. plt.legend(loc='best')
  17.  
  18. plt.subplot(222)
  19. plt.plot(x_np,y_sigmoid,c='red',label='sigmoid')
  20. plt.ylim((-0.2,1.2))
  21. plt.legend(loc='best')
  22.  
  23. plt.subplot(223)
  24. plt.plot(x_np,y_tanh,c='red',label='tanh')
  25. plt.ylim((-1.2,1.2))
  26. plt.legend(loc='best')
  27.  
  28. plt.subplot(224)
  29. plt.plot(x_np,y_softplus,c='red',label='softplus')
  30. plt.ylim((-0.2,6))
  31. plt.legend(loc='best')


3.Regression回归 & Classification分类

  1. #Regression
  2. x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  
  3. # x data (tensor), shape=(100, 1)
  4. #将linespace的一维处理成二维，这样才能被torch处理
  5. y = x.pow(2) + 0.2*torch.rand(x.size())  
  6. # noisy y data (tensor), shape=(100, 1)
  7. # x^2 + noise
  8.  
  9. # torch can only train on Variable, so convert them to Variable
  10. x, y = Variable(x), Variable(y)
  11. #plt.scatter(x.data.numpy(), y.data.numpy())  #打印散点图
  12. #plt.show()
  13.  
  14. #Define My Neural Network:
  15. class Net(torch.nn.Module):
  16.     #initialization
  17.     def __init__(self, n_feature, n_hidden, n_output):
  18.         super(Net, self).__init__()     #继承（官方步骤）
  19.         self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer
  20.         self.predict = torch.nn.Linear(n_hidden, n_output)   # output layer
  21.  
  22.     #forward propagation：input->Linear->ReLU->Linear->output
  23.     def forward(self, x):
  24.         x = F.relu(self.hidden(x))      # activation function for hidden layer
  25.         x = self.predict(x)             # linear output
  26.         return x
  27.  
  28. #net的实现：
  29. net = Net(n_feature=1, n_hidden=10, n_output=1)     # define the network
  30. print(net)  # net architecture
  31.  
  32. #net的优化：
  33. optimizer = torch.optim.SGD(net.parameters(), lr=0.5)     #随机梯度下降优化
  34. loss_func = torch.nn.MSELoss()  # 损失函数： mean squared loss ，MSE 均方差
  35.  
  36. plt.ion()   # something about plotting
  37.  
  38. for t in range(100):        #训练步数：100
  39.     prediction = net(x)     # input x and predict based on x
  40.     loss = loss_func(prediction, y)     # must be (1. nn output, 2. target)
  41.     
  42.     optimizer.zero_grad()   # clear gradients for next train
  43.     loss.backward()         # backpropagation, compute gradients
  44.     optimizer.step()        # apply and optimize gradients
  45.     
  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[0], fontdict={'size': 20, 'color':  'red'})
  52.         plt.pause(0.5)
  53.  
  54. plt.ioff()
  55. plt.show()

  1. #Classification :
  2.  
  3. torch.manual_seed(1)    # reproducible 设定生成随机数的种子，返回一个 torch._C.Generator 对象.
  4.  
  5. # make fake data
  6. n_data = torch.ones(100, 2)
  7. #class 0 :
  8. x0 = torch.normal(2*n_data, 1)      # class0 x data (tensor), shape=(100, 2)
  9. y0 = torch.zeros(100)               # class0 y data (tensor), shape=(100, 1)
  10. #class 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. #两类数据分别以(2,2)、(-2,-2)为中心正态分布，标签分别为0和1
  14.  
  15. #需要修改到torch可以运行的数据形式
  16. x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # shape (200, 2) FloatTensor = 32-bit floating
  17. y = torch.cat((y0, y1), ).type(torch.LongTensor)    # shape (200,) LongTensor = 64-bit integer
  18.  
  19. # torch can only train on Variable, so convert them to Variable
  20. x, y = Variable(x), Variable(y)
  21.  
  22. #plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
  23. #plt.show()
  24.  
  25. #Define My Neural Network:
  26. class Net(torch.nn.Module):
  27.  
  28.     def __init__(self, n_feature, n_hidden, n_output):
  29.         super(Net, self).__init__()
  30.         self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer
  31.         self.out = torch.nn.Linear(n_hidden, n_output)   # output layer
  32.  
  33.     def forward(self, x):
  34.         x = F.relu(self.hidden(x))      # activation function for hidden layer
  35.         x = self.out(x)
  36.         return x
  37.  
  38. net = Net(n_feature=2, n_hidden=10, n_output=2)     # define the network
  39. #二分类输出属于每一类的概率，例如[1,0]表示是第一类，[0,1]表示是第二类
  40. print(net)  # net architecture
  41.  
  42. optimizer = torch.optim.SGD(net.parameters(), lr=0.02)
  43. loss_func = torch.nn.CrossEntropyLoss()  # the target label is NOT an one-hotted
  44.  
  45. plt.ion()   # something about plotting
  46. #Train：
  47. for t in range(100):
  48.     out = net(x)                 # input x and predict based on x
  49.     loss = loss_func(out, y)     # must be (1. nn output, 2. target), the target label is NOT one-hotted
  50.     
  51.     optimizer.zero_grad()   # clear gradients for next train
  52.     loss.backward()         # backpropagation, compute gradients
  53.     optimizer.step()        # apply and optimize gradients
  54.     
  55.     if t % 2 == 0:
  56.         # plot and show learning process
  57.         plt.cla()
  58.         prediction = torch.max(F.softmax(out), 1)[1]  #因为输出的是每一类的可能，所以用softmax转换成概率，然后取最大
  59.         pred_y = prediction.data.numpy().squeeze()
  60.         target_y = y.data.numpy()
  61.         plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, s=100, lw=0, cmap='RdYlGn')
  62.         accuracy = sum(pred_y == target_y)/200.
  63.         plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color':  'red'})
  64.         plt.pause(1.0)
  65.  
  66. plt.ioff()
  67. plt.show()



快速定义网络：

  1. import numpy as np
  2. import torch
  3. from torch.autograd import Variable
  4. #import torch.nn as nn
  5. import torch.nn.functional as F
  6. import matplotlib.pyplot as plt
  7.  
  8. # replace following class code with an easy sequential network
  9.  
  10. #Method 1:定义类的方法
  11. class Net(torch.nn.Module):
  12.     def __init__(self, n_feature, n_hidden, n_output):
  13.         super(Net, self).__init__()
  14.         self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer
  15.         self.predict = torch.nn.Linear(n_hidden, n_output)   # output layer
  16.  
  17.     def forward(self, x):
  18.         x = F.relu(self.hidden(x))      # activation function for hidden layer
  19.         x = self.predict(x)             # linear output
  20.         return x
  21.  
  22. net1 = Net(1, 10, 1)
  23.  
  24.  
  25. # easy and fast way to build your network
  26. #Method 2:
  27. net2 = torch.nn.Sequential(
  28.     torch.nn.Linear(1, 10),
  29.     torch.nn.ReLU(),
  30.     torch.nn.Linear(10, 1)
  31. )
  32.  
  33. #2种方法是等价的，只不过在print的时候输出有所不同
  34.  
  35. print(net1)     # net1 architecture
  36.  
  37. """
  38. Net (
  39.   (hidden): Linear (1 -> 10)
  40.   (predict): Linear (10 -> 1)
  41. )
  42. """
  43.  
  44. print(net2)     # net2 architecture
  45.  
  46. """
  47. Sequential (
  48.   (0): Linear (1 -> 10)
  49.   (1): ReLU ()
  50.   (2): Linear (10 -> 1)
  51. )
  52. """

神经网络的储存和提取： 
  1. torch.manual_seed(1)    # reproducible
  2.  
  3. # fake data
  4. x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # x data (tensor), shape=(100, 1)
  5. y = x.pow(2) + 0.2*torch.rand(x.size())  # noisy y data (tensor), shape=(100, 1)
  6.  
  7. x, y = Variable(x, requires_grad=False), Variable(y, requires_grad=False)
  8.  
  9. def save():
  10.     # save net1
  11.     net1 = torch.nn.Sequential(
  12.         torch.nn.Linear(1, 10),
  13.         torch.nn.ReLU(),
  14.         torch.nn.Linear(10, 1)
  15.     )
  16.     optimizer = torch.optim.SGD(net1.parameters(), lr=0.5)
  17.     loss_func = torch.nn.MSELoss()
  18.  
  19.     for t in range(100):
  20.         prediction = net1(x)
  21.         loss = loss_func(prediction, y)
  22.         optimizer.zero_grad()
  23.         loss.backward()
  24.         optimizer.step()
  25.  
  26.     # plot result
  27.     plt.figure(1, figsize=(10, 3))
  28.     plt.subplot(131)
  29.     plt.title('Net1')
  30.     plt.scatter(x.data.numpy(), y.data.numpy())
  31.     plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
  32.  
  33.     # 2 ways to save the net
  34.     torch.save(net1, 'net.pkl')  # save entire net
  35.     torch.save(net1.state_dict(), 'net_params.pkl')   # save only the parameters
  36.  
  37. def restore_net():
  38.     # restore entire net1 to net2
  39.     net2 = torch.load('net.pkl')  #提取整个网络
  40.     prediction = net2(x)
  41.  
  42.     # plot result
  43.     plt.subplot(132)
  44.     plt.title('Net2')
  45.     plt.scatter(x.data.numpy(), y.data.numpy())
  46.     plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
  47.  
  48.  
  49. def restore_params():
  50.     # restore only the parameters in net1 to net3
  51.     net3 = torch.nn.Sequential(
  52.         torch.nn.Linear(1, 10),
  53.         torch.nn.ReLU(),
  54.         torch.nn.Linear(10, 1)
  55.     )
  56.  
  57.     # copy net1's parameters into net3
  58.     #首先要建立一个和net1一样结构的网络，才能成功提取它的参数
  59.     net3.load_state_dict(torch.load('net_params.pkl'))
  60.     prediction = net3(x)
  61.  
  62.     # plot result
  63.     plt.subplot(133)
  64.     plt.title('Net3')
  65.     plt.scatter(x.data.numpy(), y.data.numpy())
  66.     plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
  67.     plt.show()
  68.  
  69. # save net1
  70. save()
  71.  
  72. # restore entire net (may slow)
  73. restore_net()
  74.  
  75. # restore only the net parameters
  76. restore_params()
  77.  
  78. #据说提取参数的方法会比提取整个网络快一点
批数据训练： 
  1. import torch
  2. import torch.utils.data as Data
  3.  
  4. torch.manual_seed(1)    # reproducible
  5.  
  6. BATCH_SIZE = 5
  7. # BATCH_SIZE = 8 如果取8但总共数据集只有10个点，则第一个batch8个，第二个2个
  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)
  11.  
  12. torch_dataset = Data.TensorDataset(data_tensor=x, target_tensor=y)
  13.  
  14. #将数据分批
  15. #shuffile如果不定义的话（即DataLoader的()内为空），则默认按顺序提取batch数据
  16. #shuffile为True则会打乱顺序进行提取
  17. #num_workers定义每次提取batch用的线程数
  18. loader = Data.DataLoader(
  19.     dataset=torch_dataset,      # torch TensorDataset format
  20.     batch_size=BATCH_SIZE,      # mini batch size
  21.     shuffle=True,               # random shuffle for training
  22.     num_workers=2,              # subprocesses for loading data
  23. )
  24.  
  25. #epoch：表示一个批处理周期，在这个周期内，
  26. #将数据分成batch_size的大小，全部训练完毕为一个epoch
  27. for epoch in range(3):   # train entire dataset 3 times
  28.  
  29.     for step, (batch_x, batch_y) in enumerate(loader):  # for each training step
  30.         # train your data...
  31.         print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',
  32.               batch_x.numpy(), '| batch y: ', batch_y.numpy())


4.Optimizer 
  1. import torch
  2. import torch.utils.data as Data
  3. import torch.nn.functional as F
  4. from torch.autograd import Variable
  5. import matplotlib.pyplot as plt
  6.  
  7.  
  8. torch.manual_seed(1)    # reproducible
  9.  
  10. #一些超参数，常用全大写的变量来命名
  11. LR = 0.01
  12. BATCH_SIZE = 32
  13. EPOCH = 12
  14.  
  15. # fake dataset
  16. x = torch.unsqueeze(torch.linspace(-1, 1, 1000), dim=1)
  17. y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size()))
  18.  
  19. # plot dataset
  20. #plt.scatter(x.numpy(), y.numpy())
  21. #plt.show()
  22.  
  23. # put dateset into torch dataset
  24. torch_dataset = Data.TensorDataset(data_tensor=x, target_tensor=y)
  25. loader = Data.DataLoader(dataset=torch_dataset, batch_size=BATCH_SIZE, shuffle=True) #这里本来还有个参数，但是不知道为什么一加上这个程序就运行不了
  26.  
  27. # default network
  28. class Net(torch.nn.Module):
  29.     def __init__(self):
  30.         super(Net, self).__init__()
  31.         self.hidden = torch.nn.Linear(1, 20)   # hidden layer
  32.         self.predict = torch.nn.Linear(20, 1)   # output layer
  33.  
  34.     def forward(self, x):
  35.         x = F.relu(self.hidden(x))      # activation function for hidden layer
  36.         x = self.predict(x)             # linear output
  37.         return x
  38.  
  39. # different nets
  40. net_SGD         = Net()
  41. net_Momentum    = Net()
  42. net_RMSprop     = Net()
  43. net_Adam        = Net()
  44.  
  45. #将4个神经网络定义在一个list中，以便之后在for循环中循环训练
  46. nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam]
  47.  
  48. # different optimizers
  49. opt_SGD         = torch.optim.SGD(net_SGD.parameters(), lr=LR)
  50. opt_Momentum    = torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8)
  51. opt_RMSprop     = torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)
  52. opt_Adam        = torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))
  53.  
  54. optimizers = [opt_SGD, opt_Momentum, opt_RMSprop, opt_Adam]
  55.  
  56.  
  57. loss_func = torch.nn.MSELoss()
  58. losses_his = [[], [], [], []]   # record loss
  59.  
  60. # training
  61. for epoch in range(EPOCH):
  62.     print('Epoch: ', epoch)
  63.     for step, (batch_x, batch_y) in enumerate(loader):          # for each training step
  64.         #此前的类型是tensor，需要封装在Variable中才能被nn处理
  65.         b_x = Variable(batch_x) 
  66.         b_y = Variable(batch_y)
  67.         
  68.         for net, opt, l_his in zip(nets, optimizers, losses_his):
  69.             output = net(b_x)              # get output for every net
  70.             loss = loss_func(output, b_y)  # compute loss for every net
  71.             opt.zero_grad()                # clear gradients for next train
  72.             loss.backward()                # backpropagation, compute gradients
  73.             opt.step()                     # apply gradients
  74.             l_his.append(loss.data[0])     # loss recoder
  75.  
  76. labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
  77. for i, l_his in enumerate(losses_his):
  78.     plt.plot(l_his, label=labels[i])
  79.  
  80. plt.legend(loc='best')
  81. plt.xlabel('Steps')
  82. plt.ylabel('Loss')
  83. plt.ylim((0, 0.2))
  84.  
  85. plt.show()





本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/358115
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号