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

从零开始深度学习0611——pytorch入门之Pytorch 与 numpy  区别+variable+activation+regression+classification+快速搭建_numpy scatter和pytorch

作者：小惠珠哦 | 2024-06-22 18:46:47

赞

踩

numpy scatter和pytorch

--------------------- Pytorch 与 numpy  区别----------------------------

#########################################################

#########################################################

 

 

Numpy与torch 数据格式的转换

Torch为tensor 张量的形式

 

 

  1. np_data = np.arange(6).reshape((2, 3))
  2. torch_data = torch.from_numpy(np_data)
  3. tensor2array = torch_data.numpy()
  4. print(
  5.     '\nnumpy array:', np_data,          # [[0 1 2], [3 4 5]]
  6.     '\ntorch tensor:', torch_data,      #  0  1  2 \n 3  4  5    [torch.LongTensor of size 2x3]
  7.     '\ntensor to array:', tensor2array, # [[0 1 2], [3 4 5]]
  8. )

运行结果：

 

 

绝对值，平均值，sin值  写法都是一样基本

需要先将数据转换成tensor的形式  torch.FloatTensor(data)

 

  1. # abs
  2.  
  3. data = [-1, -2, 1, 2]
  4.  
  5. tensor = torch.FloatTensor(data)  # 32-bit floating point
  6.  
  7. print(
  8.  
  9.     '\nabs',
  10.  
  11.     '\nnumpy: ', np.abs(data),          # [1 2 1 2]
  12.  
  13.     '\ntorch: ', torch.abs(tensor)      # [1 2 1 2]
  14.  
  15. )
  16.  
  17.  
  18.  
  19. # sin
  20.  
  21. print(
  22.  
  23.     '\nsin',
  24.  
  25.     '\nnumpy: ', np.sin(data),      # [-0.84147098 -0.90929743  0.84147098  0.90929743]
  26.  
  27.     '\ntorch: ', torch.sin(tensor)  # [-0.8415 -0.9093  0.8415  0.9093]
  28.  
  29. )
  30.  
  31.  
  32.  
  33. # mean
  34.  
  35. print(
  36.  
  37.     '\nmean',
  38.  
  39.     '\nnumpy: ', np.mean(data),         # 0.0
  40.  
  41.     '\ntorch: ', torch.mean(tensor)     # 0.0
  42.  
  43. )

 

矩阵乘法

原始数据的话，Numpy是直接np.matmul()

或者将原始数据变为array的形式  data = np.array(data)  然后用numpy中另一种矩阵乘法的形式  data.dot(data)

Torch 计算矩阵乘法为 torch.mm(tensor,tensor)

  1. # matrix multiplication
  2.  
  3. data = [[1,2], [3,4]]
  4.  
  5. tensor = torch.FloatTensor(data)  # 32-bit floating point
  6.  
  7. # correct method
  8.  
  9. print(
  10.  
  11.     '\nmatrix multiplication (matmul)',
  12.  
  13.     '\nnumpy: ', np.matmul(data, data),     # [[7, 10], [15, 22]]
  14.  
  15.     '\ntorch: ', torch.mm(tensor, tensor)   # [[7, 10], [15, 22]]
  16.  
  17. )
  18.  
  19. # incorrect method
  20.  
  21. data = np.array(data)
  22.  
  23. print(
  24.  
  25.     '\nmatrix multiplication (dot)',
  26.  
  27.     '\nnumpy: ', data.dot(data),        # [[7, 10], [15, 22]]
  28.  
  29.     '\ntorch: ', tensor.dot(tensor)     # this will convert tensor to [1,2,3,4], you'll get 30.0
  30.  
  31. )

 

 

 

 

 

-------------------------variable-----------------------------------------------

##################################################################

##################################################################

 

  1.  
  2. tensor = torch.FloatTensor([[1,2],[3,4]])
  3.  
  4. variable = Variable(tensor,requires_grad=True)  #false 反向传播时不会计算当前节点的梯度
  5.  
  6. print(tensor)
  7.  
  8. print(variable)
  9.  
  10.  
  11.  
  12. print(tensor*tensor)
  13.  
  14.  
  15.  
  16. t_out = torch.mean(tensor*tensor)
  17.  
  18. v_out = torch.mean(variable*variable)
  19.  
  20. print(t_out)
  21.  
  22. print(v_out)
  23.  
  24.  
  25.  
  26. v_out.backward()    # backpropagation from v_out
  27.  
  28. # v_out = 1/4 * sum(variable*variable)
  29.  
  30. # the gradients w.r.t the variable, d(v_out)/d(variable) = 1/4*2*variable = variable/2
  31.  
  32. print(variable.grad)
  33.  
  34.  
  35.  
  36. print(variable)     # this is data in variable format
  37.  
  38.  
  39.  
  40. print(variable.data)    # this is data in tensor format   转换成tensor
  41.  
  42.  
  43.  
  44. print(variable.data.numpy())  # numpy format   将variables 转出成numpy需要转成成tensor  再换成numpy

 

 

---------------------------activation-------------------------------------------

##################################################################

##################################################################

 

先通过torch.linspace() 生成一些假的点

再x.data.numpy() 变成numpy array的形式

因为画图的时候 matplot 需要识别numpy的数据

再绘制torch自带的激活函数

 

 

完整程序：

 

  1.  
  2. # fake data
  3.  
  4. x = torch.linspace(-5, 5, 200)  # x data (tensor), shape=(100, 1)
  5.  
  6. x = Variable(x)
  7.  
  8. x_np = x.data.numpy()   # numpy array for plotting  画图的时候 matplot 需要识别numpy的数据
  9.  
  10.  
  11.  
  12. # following are popular activation functions
  13.  
  14. y_relu = torch.relu(x).data.numpy()
  15.  
  16. y_sigmoid = torch.sigmoid(x).data.numpy()
  17.  
  18. y_tanh = torch.tanh(x).data.numpy()
  19.  
  20. y_softplus = F.softplus(x).data.numpy() # there's no softplus in torch
  21.  
  22. # y_softmax = torch.softmax(x, dim=0).data.numpy() softmax is a special kind of activation function, it is about probability
  23.  
  24.  
  25.  
  26. # plt to visualize these activation function
  27.  
  28. plt.figure(1, figsize=(8, 6))
  29.  
  30. plt.subplot(221)
  31.  
  32. plt.plot(x_np, y_relu, c='red', label='relu')
  33.  
  34. plt.ylim((-1, 5))
  35.  
  36. plt.legend(loc='best')
  37.  
  38.  
  39.  
  40. plt.subplot(222)
  41.  
  42. plt.plot(x_np, y_sigmoid, c='red', label='sigmoid')
  43.  
  44. plt.ylim((-0.2, 1.2))
  45.  
  46. plt.legend(loc='best')
  47.  
  48.  
  49.  
  50. plt.subplot(223)
  51.  
  52. plt.plot(x_np, y_tanh, c='red', label='tanh')
  53.  
  54. plt.ylim((-1.2, 1.2))
  55.  
  56. plt.legend(loc='best')
  57.  
  58.  
  59.  
  60. plt.subplot(224)
  61.  
  62. plt.plot(x_np, y_softplus, c='red', label='softplus')
  63.  
  64. plt.ylim((-0.2, 6))
  65.  
  66. plt.legend(loc='best')
  67.  
  68.  
  69.  
  70. plt.show()

 

 

 

运行结果：

 

 

 

---------------------------regression-------------------------------------------

###################################################################################################################################

 

先通过torch.linespace() 生成数据  模拟拟合曲线

再建类 搭建简单的网络结构

实例化网络

定义优化器和损失函数

训练

 

 

 

 torch.unsqueeze()  将原始数据1维变成2维，因为在torch中只能处理2维的数据

 

Net类的固定写法  记住就好

  1. class Net(torch.nn.Module):  #继承torch.nn.Module的模块
  2.  
  3.     def __init__(self, n_feature, n_hidden, n_output):
  4.  
  5.         super(Net, self).__init__()
  6.  
  7.         self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer    torch.nn.Linear  返回的是一个方法
  8.  
  9.         self.predict = torch.nn.Linear(n_hidden, n_output)   # output layer
  10.  
  11.  
  12.  
  13.     def forward(self, x):
  14.  
  15.         x = F.relu(self.hidden(x))      # activation function for hidden layer
  16.  
  17.         x = self.predict(x)             # linear output
  18.  
  19.         return x

 

 

  1. optimizer.zero_grad()   # 每次训练的梯度清零
  2.  
  3. loss.backward()         # 反向传播，计算梯度
  4.  
  5. optimizer.step()        # 作用到每步上

 

 

 

 

完整程序：

 

  1.  
  2. # torch.manual_seed(1)    # reproducible
  3.  
  4.  
  5.  
  6. x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # x data (tensor), shape=(100, 1)   将1维数据变成2维  因为在torch中只能处理2维的数据
  7.  
  8. y = x.pow(2) + 0.2*torch.rand(x.size())                 # noisy y data (tensor), shape=(100, 1)
  9.  
  10.  
  11.  
  12. # torch can only train on Variable, so convert them to Variable
  13.  
  14. # The code below is deprecated in Pytorch 0.4. Now, autograd directly supports tensors
  15.  
  16. # x, y = Variable(x), Variable(y)
  17.  
  18.  
  19.  
  20. # plt.scatter(x.data.numpy(), y.data.numpy())   #打印散点图
  21.  
  22. # plt.show()
  23.  
  24.  
  25.  
  26.  
  27.  
  28. class Net(torch.nn.Module):  #继承torch.nn.Module的模块
  29.  
  30.     def __init__(self, n_feature, n_hidden, n_output):
  31.  
  32.         super(Net, self).__init__()
  33.  
  34.         self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer    torch.nn.Linear  返回的是一个方法
  35.  
  36.         self.predict = torch.nn.Linear(n_hidden, n_output)   # output layer
  37.  
  38.  
  39.  
  40.     def forward(self, x):
  41.  
  42.         x = F.relu(self.hidden(x))      # activation function for hidden layer
  43.  
  44.         x = self.predict(x)             # linear output
  45.  
  46.         return x
  47.  
  48.  
  49.  
  50. net = Net(n_feature=1, n_hidden=10, n_output=1)     # define the network
  51.  
  52. print(net)  # net architecture   会输出搭建的网络的结构
  53.  
  54.  
  55.  
  56. optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
  57.  
  58. loss_func = torch.nn.MSELoss()  # this is for regression mean squared loss   回归问题用均方差误差就可以了
  59.  
  60.  
  61.  
  62. plt.ion()   # something about plotting
  63.  
  64.  
  65.  
  66. for t in range(200):
  67.  
  68.     prediction = net(x)     # input x and predict based on x   这里的net调用的是forward函数
  69.  
  70.  
  71.  
  72.     loss = loss_func(prediction, y)     # must be (1. nn output, 2. target)
  73.  
  74.  
  75.  
  76.     optimizer.zero_grad()   # clear gradients for next train  每次训练的梯度清零
  77.  
  78.     loss.backward()         # backpropagation, compute gradients  
  79.  
  80.     optimizer.step()        # apply gradients
  81.  
  82.  
  83.  
  84.     if t % 5 == 0:
  85.  
  86.         # plot and show learning process
  87.  
  88.         plt.cla()
  89.  
  90.         plt.scatter(x.data.numpy(), y.data.numpy())
  91.  
  92.         plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
  93.  
  94.         plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color':  'red'})
  95.  
  96.         plt.pause(0.1)
  97.  
  98.  
  99.  
  100. plt.ioff()
  101.  
  102. plt.show()

 

运行结果：

 

 

---------------------------classification-----------------------------------------

####################################################################################################################################

 

 

合并数据 torch.cat()   x默认是FloatTensor的形式

 Y默认是LongTensor的形式

x = torch.cat((x0, x1), 0).type(torch.FloatTensor) 

y = torch.cat((y0, y1), ).type(torch.LongTensor)

 

回归问题就用MSE 均方误差  分类问题的话就要使用CrossEntropyLoss的损失函数

 

optimizer.zero_grad()   #清空上一步的残余更新参数值
loss.backward()         #误差反向传播, 计算参数更新值
optimizer.step()        # 将参数更新值施加到 net 的 parameters 上

 

 

torch.max(out, 1)[1]

# torch.max(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)   按维度dim 返回最大值
# torch.max(out, 1) 表示返回每一行中最大值的那个元素，且返回其索引（返回最大元素在这一行的列索引）  index [0,1] ==>  [元素，索引值]
# 这里第一个1 表示维度的意思   第二个1 表示获得第二个位置的东西
# 前面损失函数是CrossEntropyLoss  计算的softmax概率值

# 这里，因为上面合并数据后，x是每一行都有一个x0的点，一个x1的点    y是对应的标签x0是0 x1标签是1
# 所以softmax计算完的概率 通过 torch.max(out, 1)[1]  得到每个点最大概率的索引值也是0或者1  正好和标签0,1对应

 

 

完整程序：

 

  1.  
  2. # torch.manual_seed(1)    # reproducible
  3.  
  4. # make fake data
  5. n_data = torch.ones(100, 2)         # 数据的基本形态
  6. x0 = torch.normal(2*n_data, 1)      # class0 x data (tensor), shape=(100, 2)  正态分布
  7. y0 = torch.zeros(100)               # class0 y data (tensor), shape=(100, 1)  给x0的标签，都是0
  8. x1 = torch.normal(-2*n_data, 1)     # class1 x data (tensor), shape=(100, 2)  正态分布
  9. y1 = torch.ones(100)                # class1 y data (tensor), shape=(100, 1)  给x1的标签，都是1
  10. # 注意 x, y 数据的数据形式是一定要像下面一样 (torch.cat 是在合并数据)
  11. # 按列合并数据   x0是第一列，x1是第二列 所以每一行是有一个x0的点 一个x1的点  所以下面 输入值n_feature=2
  12. x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # shape (200, 2) FloatTensor = 32-bit floating   在torch中 它的数据默认一定是FloatTensor的形式
  13. y = torch.cat((y0, y1), ).type(torch.LongTensor)    # shape (200,) LongTensor = 64-bit integer  在torch中 它的标签默认一定是LongTenser的形式
  14.  
  15. # The code below is deprecated in Pytorch 0.4. Now, autograd directly supports tensors
  16. # x, y = Variable(x), Variable(y)
  17.  
  18. # plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
  19. # plt.show()
  20.  
  21.  
  22. class Net(torch.nn.Module):
  23.     def __init__(self, n_feature, n_hidden, n_output):
  24.         super(Net, self).__init__()
  25.         self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer
  26.         self.out = torch.nn.Linear(n_hidden, n_output)   # output layer
  27.  
  28.     def forward(self, x):
  29.         x = F.relu(self.hidden(x))      # activation function for hidden layer
  30.         x = self.out(x)
  31.         return x
  32.  
  33. net = Net(n_feature=2, n_hidden=10, n_output=2)     # define the network
  34. print(net)  # net architecture
  35.  
  36. optimizer = torch.optim.SGD(net.parameters(), lr=0.02)
  37. loss_func = torch.nn.CrossEntropyLoss()  # the target label is NOT an one-hotted  回归问题就用MSE 均方误差  分类问题的话就要使用CrossEntropyLoss的损失函数
  38.  
  39. plt.ion()   # something about plotting
  40.  
  41. for t in range(100):
  42.     out = net(x)                 # input x and predict based on x
  43.     loss = loss_func(out, y)     # must be (1. nn output, 2. target), the target label is NOT one-hotted
  44.  
  45.     optimizer.zero_grad()   # clear gradients for next train       清空上一步的残余更新参数值
  46.     loss.backward()         # backpropagation, compute gradients   误差反向传播, 计算参数更新值
  47.     optimizer.step()        # apply gradients                      将参数更新值施加到 net 的 parameters 上
  48.  
  49.     if t % 2 == 0:
  50.         # plot and show learning process
  51.         plt.cla()
  52.         prediction = torch.max(out, 1)[1]
  53.         # torch.max(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)   按维度dim 返回最大值
  54.         # torch.max(out, 1) 表示返回每一行中最大值的那个元素，且返回其索引（返回最大元素在这一行的列索引）  index [0,1] ==>  [元素，索引值]
  55.         # 这里第一个1 表示维度的意思   第二个1 表示获得第二个位置的东西
  56.         # 前面损失函数是CrossEntropyLoss  计算的softmax概率值
  57.  
  58.         # 这里，因为上面合并数据后，x是每一行都有一个x0的点，一个x1的点    y是对应的标签x0是0 x1标签是1
  59.         # 所以softmax计算完的概率 通过 torch.max(out, 1)[1]  得到每个点最大概率的索引值也是0或者1  正好和标签0,1对应
  60.  
  61.         pred_y = prediction.data.numpy()
  62.         target_y = y.data.numpy()
  63.         plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, s=100, lw=0, cmap='RdYlGn')
  64.         accuracy = float((pred_y == target_y).astype(int).sum()) / float(target_y.size)  # 预测中有多少和真实值一样
  65.         plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color':  'red'})
  66.         plt.pause(0.1)
  67.  
  68. plt.ioff()
  69. plt.show()

 

运行结果:

 

--------------------------快速搭建---------------------------------------------

####################################################################################################################################

 

F.relu()   relu为一个功能

 

torch.nn.Sequential  中  torch.nn.ReLU(),   ReLU()为一个类

 

 

完整程序：

 

  1.  
  2. # replace following class code with an easy sequential network
  3. class Net(torch.nn.Module):
  4.     def __init__(self, n_feature, n_hidden, n_output):
  5.         super(Net, self).__init__()
  6.         self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer
  7.         self.predict = torch.nn.Linear(n_hidden, n_output)   # output layer
  8.  
  9.     def forward(self, x):
  10.         x = F.relu(self.hidden(x))      # activation function for hidden layer
  11.         x = self.predict(x)             # linear output
  12.         return x
  13.  
  14. net1 = Net(1, 10, 1)
  15.  
  16. # easy and fast way to build your network
  17. net2 = torch.nn.Sequential(
  18.     torch.nn.Linear(1, 10),
  19.     torch.nn.ReLU(),    
  20.     torch.nn.Linear(10, 1)
  21. )
  22.  
  23. print(net1)     # net1 architecture
  24. print(net2)     # net2 architecture

 

运行结果：

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小惠珠哦/article/detail/747352
推荐阅读
相关标签

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

  

闽ICP备14008679号