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

torch入门_torch.ones

作者：煮酒与君饮 | 2024-07-16 03:10:20

赞

踩

torch.ones

张量的创建

  1. import torch
  2. import numpy as np
  3.  
  4. #创建一个张量
  5. x=torch.randn((5,3),dtype=torch.float16)
  6. #张量的形状
  7. x.shape
  8.  
  9. #创建一个空张量
  10. x=torch.empty((2,3),dtype=torch.float32)
  11.  
  12. #零张量
  13. x=torch.zeros((2,3),dtype=torch.long)
  14.  
  15. #1张量
  16. x=torch.ones(2,3)
  17.  
  18. #对角都是1
  19. x=torch.eye(3,4)
  20.  
  21. #从列表创建,并返回列表
  22. x=torch.tensor([[2,3,4],[2,3,6]],dtype=torch.float16)
  23. x.tolist()
  24.  
  25. #从arr创建，并返回arr
  26. a=np.random.random((2,2))
  27. x=torch.from_numpy(a)
  28. x.numpy()
  29.  
  30. '''
  31. 区别：from_numpy和torch.tensor
  32. from_numpy:如果arr变化，由arr创建的tensor也会变化
  33. torch.tensor：arr变化，由arr创建的tensor不会变化
  34. '''
  35.  
  36. #改变形状,reshape更强大
  37. x.reshape(1,-1)
  38. x.view(1,-1)

常见计算

  1. x=torch.tensor([[2,3,4],[2,3,6]])
  2. y=torch.tensor([[1,2,1],[2,6,0]])
  3.  
  4. x+y
  5.  
  6. x-y
  7.  
  8. x / y
  9.  
  10. x*y
  11.  
  12. #求两个tensor对应位置上的最大值
  13. torch.maximum(torch.tensor(3),x)
  14.  
  15. #平方
  16. torch.pow(x,2)
  17.  
  18. #某个轴的最大值
  19. torch.max(x,1)
  20.

梯度计算和梯度下降过程 

  1. x=np.linspace(0,100,10000)
  2. noise=np.random.uniform(size=(10000,))
  3.  
  4. #自定:w=10,b=10
  5. y=10*x+10+noise
  6.  
  7. x = torch.from_numpy(x)
  8. y = torch.from_numpy(y)
  9.  
  10. w=torch.randn(1,requires_grad=True)
  11. b=torch.randn(1,requires_grad=True)
  12.  
  13. #回归拟合
  14. for epoch in range(500000000):
  15.     #计算预测值
  16.     y_ = x * w + b
  17.     #计算损失
  18.     loss = torch.mean((y_ - y)**2)
  19.     
  20.     if epoch==0:
  21.  
  22.         #反向传播
  23.         loss.backward()
  24.        
  25.     else:
  26.         # 归零梯度
  27.         w.grad.zero_()
  28.         b.grad.zero_()
  29.         #反向传播
  30.         loss.backward()
  31.     #梯度更新,步长的选择是个讲究活，不然会发散，或者训练太慢
  32.     w.data = w.data - 2e-4 * w.grad.data
  33.     b.data = b.data - 2e-4 * b.grad.data
  34.     
  35.     if loss<0.1:
  36.         break
  37.     #print(w,b)
  38.     #w:10.0038;b:10.2498
  39.     
  40.     #print('epoch: {}, loss: {}'.format(epoch, loss.data))

使用矩阵乘法实现全连接层 

  1. x=torch.randn((4,5))
  2. w_true=torch.randint(1,10,size=(5,1),dtype=torch.float32)
  3. b_true=torch.tensor(20.0)
  4. noise=torch.randn(size=(4,1))
  5. #矩阵乘法
  6. y=x@w_true+b_true+noise
  7.  
  8. w=torch.zeros(size=(5,1),requires_grad=True,dtype=torch.float32)
  9. b=torch.zeros(1,requires_grad=True)
  10.  
  11. #训练
  12. for epoch in range(10000000):
  13.     y_=x@w+b
  14.     loss=torch.mean((y-y_)**2)
  15.     
  16.     if epoch==0:
  17.         loss.backward()
  18.     else:
  19.         w.grad.zero_()
  20.         b.grad.zero_()
  21.         
  22.         loss.backward()
  23.         
  24.     w.data=w.data - 2e-4 * w.grad.data
  25.     b.data=b.data - 2e-4 *b.grad.data
  26.     
  27.     if loss<0.1:
  28.         break
  29. '''
  30. #权重
  31. w:[[ 0.5081],
  32.         [ 5.0037],
  33.         [ 0.8767],
  34.         [ 4.9839],
  35.         [13.5279]]
  36. #偏置
  37. b:[14.1485]
  38. #损失
  39. loss:0.1000
  40. '''

使用nn.Linear层

  1. from torch import nn
  2. from torch import optim
  3.  
  4. #构建网络
  5. net=nn.Linear(5,1,bias=True)
  6. #构建优化器
  7. optimizer=optim.Adam(net.parameters(),lr=2e-4)
  8.  
  9. for epoch in range(10000000):
  10.     y_=net(x)
  11.     loss=torch.mean((y-y_)**2)
  12.     
  13.    
  14.     #梯度归零
  15.     optimizer.zero_grad()
  16.     #计算梯度
  17.     loss.backward()
  18.     #更新梯度
  19.     optimizer.step()
  20.     
  21.     if loss<0.1:
  22.         break
  23.  
  24. #权重
  25. #[ 0.6655,  4.8166, -3.5347,  7.4862, 13.4877]
  26. net.weight.data
  27.  
  28.  
  29. #偏置
  30. #[13.6001]
  31. net.bias.data
  32.  
  33. #损失
  34. 0.0999

 激活函数

  1. #ELU
  2. def ELU_self(x, a=1.0):
  3.     x=torch.tensor(x)
  4.     x_0=torch.tensor(0)
  5.     return torch.maximum(x_0, x) + torch.minimum(x_0, a * (torch.exp(x) - 1))
  6.  
  7.  
  8. #LeakyReLU
  9. def LeakyReLU_self(x, a=1e-2):
  10.     x=torch.tensor(x)
  11.     x_0=torch.tensor(0)
  12.     return torch.maximum(x_0, x) + a * torch.minimum(x_0, x)
  13.  
  14.  
  15. #ReLU
  16. def ReLU_self(x):
  17.     x=torch.tensor(x)
  18.     x_0=torch.tensor(0)
  19.     return torch.maximum(x_0,x)
  20.  
  21.  
  22. #ReLU6
  23. def ReLU6_self(x):
  24.     x=torch.tensor(x)
  25.     x_0=torch.tensor(0)
  26.     x_6=torch.tensor(6)
  27.     return torch.minimum(torch.maximum(x_0, x), x_6)
  28.  
  29.  
  30. #SELU
  31. def SELU_self(x,
  32.               scale=1.0507009873554804934193349852946,
  33.               a=1.6732632423543772848170429916717):
  34.     x = torch.tensor(x)
  35.     x_0 = torch.tensor(0)
  36.     return scale * (torch.maximum(x_0, x) +
  37.                     torch.minimum(x_0, a * (torch.exp(x) - 1)))
  38.  
  39.  
  40. #CELU
  41. def CELU_self(x, a=1.0):
  42.     x = torch.tensor(x)
  43.     x_0 = torch.tensor(0)
  44.     return torch.maximum(x_0, x) + torch.minimum(x_0,
  45.                                                  a * (torch.exp(x / a) - 1.0))
  46.  
  47.  
  48. #Sigmoid
  49. def Sigmoid_self(x):
  50.     x = torch.tensor(x)
  51.     return 1.0 / (1 + torch.exp(-x))
  52.  
  53.  
  54. #LogSigmoid
  55. def LogSigmoid_self(x):
  56.     x = torch.tensor(x)
  57.     return torch.log(1.0 / (1 + torch.exp(-x)))
  58.  
  59.  
  60. #Tanh
  61. def Tanh_self(x):
  62.     x = torch.tensor(x)
  63.     return 1 - 2.0 / (torch.exp(2 * x) + 1)
  64.  
  65.  
  66. #Tanhshrink
  67. def Tanhshrink_self(x):
  68.     x = torch.tensor(x)
  69.     return x + 2.0 / (torch.exp(2 * x) + 1) - 1
  70.  
  71.  
  72. #Softplus
  73. def Softplus_self(x, b=1.0):
  74.     x = torch.tensor(x)
  75.     return 1 / b * torch.log(1 + torch.exp(x * b))
  76.  
  77.  
  78. #Softshrink,感觉就是中心化
  79. def Softshrink_self(x,lambd=0.5):
  80.     x_=torch.tensor(x)
  81.     
  82.     x_=torch.where(x_>lambd,x_-lambd,x_)
  83.     x_=torch.where(x_<-lambd,x_+lambd,x_)
  84.     x_[x==x_]=0
  85.     
  86.     return x_

卷积层原理和使用 

  1. import matplotlib.pyplot as plt
  2. #用来读取图片
  3. from PIL import Image
  4. import torch.nn as nn
  5. from torchvision import transforms
  6. from torchkeras import summary
  7.  
  8. image=Image.open('tu.jpg')
  9.  
  10. # 把图片数据转化成张量
  11. img_transform = transforms.Compose([transforms.ToTensor()])
  12. img_tensor = img_transform(image)
  13.  
  14. #卷积的输入是4维张量
  15. #'_'操作是就地更改
  16. img_tensor.unsqueeze_(dim=0)
  17.  
  18. flag=0
  19. if flag:
  20.     #输入通道，卷积个数，卷积核大小，步长，填充
  21.     conv_layer = nn.Conv2d(in_channels=3,out_channels=1,kernel_size=5,stride=1,padding=2)
  22.     # 初始化卷积层权值
  23.     nn.init.xavier_normal_(conv_layer.weight.data)
  24.     # nn.init.xavier_uniform_(conv_layer.weight.data)
  25.  
  26.     # calculation
  27.     img_conv = conv_layer(img_tensor)
  28. else:
  29.     #转置卷积
  30.     conv_layer_ts = nn.ConvTranspose2d(in_channels=3,out_channels=1,kernel_size=5,stride=1,padding=2)
  31.     nn.init.xavier_normal_(conv_layer_ts.weight.data)
  32.     img_conv_ts = conv_layer_ts(img_tensor)

参数的计算 

参数=卷积个数*卷积核大小*通道数+ 卷积个数

76 = 1*5*5*3+1

#参数个数
32*5*5*1+32

卷基层大小 

  1. #(输入大小-卷积核大小+2倍的填充)/步长+1
  2.  
  3. #500=(500-5+2*2)/1+1
  4.  
  5. img_conv.shape
  6.  
  7. torch.Size([1, 1, 500, 500])

画图展示

  1. img_tensor.squeeze_(dim=0)
  2. img_conv.squeeze_(dim=0)
  3. img_conv_ts.squeeze_(dim=0)
  4.  
  5. plt.subplot(131).imshow(np.transpose(img_tensor.data.numpy(),[1,2,0]))
  6. plt.axis('off')
  7. plt.subplot(132).imshow(np.transpose(img_conv.data.numpy(),[1,2,0]))
  8. plt.axis('off')
  9. plt.subplot(133).imshow(np.transpose(img_conv_ts.data.numpy(),[1,2,0]))
  10. plt.tight_layout()
  11. plt.axis('off')
  12. plt.show()

损失函数

  1. #标准的使用流程
  2. criterion=Losscriterion()
  3. loss=criterion(y_,y)

常见loss的使用

  1. #BCELoss，二分类损失
  2. #y_pred在前，y_true在后
  3. loss=nn.BCELoss()
  4.  
  5. m=nn.Sigmoid()
  6. x=torch.randn(3,requires_grad=True)
  7. y_=m(x)
  8. y=torch.randint(0,2,size=(3,),dtype=torch.float)
  9. loss=loss(y_,y)
  10. with torch.no_grad():
  11.     loss.backward()
  12. loss
  13.  
  14.  
  15. # NLLLoss，多分类损失
  16. loss=nn.NLLLoss()
  17. m=nn.Softmax(dim=1)
  18. x=torch.randn((3,4),requires_grad=True)
  19. y_=m(x)
  20. y=torch.randint(0,4,size=(3,))
  21. loss=loss(y_,y)
  22. with torch.no_grad():
  23.     loss.backward()
  24. loss
  25.  
  26. #L1Loss,MAE
  27. loss=nn.L1Loss()
  28. y_=torch.randn((1,5),requires_grad=True)
  29. y=torch.randn((1,5))
  30. loss=loss(y_,y)
  31. with torch.no_grad():
  32.     loss.backward()
  33. loss
  34.  
  35. #MSELoss
  36. loss=nn.MSELoss()
  37. y_=torch.randn((1,5),requires_grad=True)
  38. y=torch.randn((1,5))
  39. loss=loss(y_,y)
  40. with torch.no_grad():
  41.     loss.backward()
  42. loss

优化器的使用 

  1. from torch import optim
  2.  
  3. #一般的流程
  4. #定义优化器
  5. optimizer=Optim()
  6. #导数归零
  7. optimizer.zero_grad()
  8. #更新
  9. optimizer.step()
  1. x = torch.randn((4,5),requires_grad=False)
  2. w_true = torch.randint(1, 10, size=(5, 1), dtype=torch.float)
  3. b_true = torch.tensor(20.0)
  4. noise = torch.randn(size=(4, 1))
  5. y = x @ w_true + b_true + noise
  6.  
  7.  
  8. result = {}
  9. for lr in [0.01, 0.1, 0.5]:
  10.     #每次要重新更新网络
  11.     net = nn.Linear(5, 1, bias=True)
  12.     #定义优化器
  13.     optimizer = optim.SGD(net.parameters(), lr=lr)
  14.     #定义损失
  15.     mseloss = nn.MSELoss()
  16.  
  17.     for epoch in range(10000000):
  18.         #梯度清零
  19.         optimizer.zero_grad()
  20.         #计算损失
  21.         loss = mseloss(net(x), y)
  22.         #反向传播
  23.         loss.backward()
  24.         #更新
  25.         optimizer.step()
  26.  
  27.         if loss.item() < 0.1 or epoch >= 10000:
  28.             result[lr] = {'loss': loss.item(), 'epoch': epoch}
  29.             break
  30. #结果
  31. #当lr过大时,发散了，不能收敛
  32. result=
  33. {0.01: {'loss': 0.09930270910263062, 'epoch': 766},
  34.  0.1: {'loss': 0.0925668329000473, 'epoch': 76},
  35.  0.5: {'loss': nan, 'epoch': 10000}}

池化层

  1.  
  2. x=torch.randn(10,3,128,128)
  3.  
  4. #MaxPool2d
  5. maxp=nn.MaxPool2d(5,3)
  6. #42=(128-5+0*2)/3+1,是向下取整
  7. maxp(x).shape
  8.  
  9. torch.Size([10, 3, 42, 42])
  10.  
  11. maxp(x)[0,0,0,4]
  12. tensor(1.9936)
  13.  
  14. #AvgPool2d，取窗口的平均值
  15. avgp=nn.AvgPool2d(5,3)
  16. #42=(128-5+0*2)/3+1,是向下取整
  17. avgp(x).shape
  18.  
  19. torch.Size([10, 3, 42, 42])
  20.  
  21. avgp(x)[0,0,0,4]
  22. tensor(-0.1445)

归一化层

  1. BN 层去加速训练和帮助模型更好收敛
  2. BN 层仅在 batch size 足够大时才有明显的效果
  1. x=torch.randint(0,256,size=(10,3,128,128)).float()
  2.  
  3. #BN
  4. bn=nn.BatchNorm2d(3)
  5. bn(x)[0,0,0,2]
  6.  
  7. tensor(1.1019, grad_fn=<SelectBackward>)
  8.  
  9. #GN
  10. #num_channels需要被num_groups整除
  11. gn=nn.GroupNorm(num_groups=3,num_channels=3)
  12. gn(x)[0,0,0,2]
  13.  
  14. tensor(1.0831, grad_fn=<SelectBackward>)
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/煮酒与君饮/article/detail/832086
推荐阅读
相关标签

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

  

闽ICP备14008679号