即看即用 && 数学操作 ( Math operations) && Pytorch官方文档总结 && 笔记 (五)

已于 2022-05-08 21:16:04 修改
阅读量673 收藏
点赞数 1
分类专栏： Pytorch_python 文章标签： pytorch 深度学习 神经网络 人工智能 python
于 2022-05-08 21:14:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54185421/article/details/124653184
版权

*************************************************SUGGEST*************************************************

有时间可以把以下函数全熟记，没时间需要多看几遍，因为在训练神经网络的时候，会和大量的数据打交道，数学操作必不可少，可以做到事半功倍。

**************************************************************************************************************

（1）本文涉及函数的列表（注释在代码中）

  1. torch.abs                                        # 绝对值
  2. torch.acos                                      # 反余弦
  3. torch.add                                       # 张量+标量值 / input+(other∗value)
  4. torch.addcdiv                                # 相除、相乘、相加
  5. torch.asin                                      # 反正弦函数
  6. torch.atan                                      # 反正切函数
  7. torch.atan2                                    # 两个张量的反正切函数
  8. torch.ceil                                       # 天井函数，向上取整
  9. torch.clamp                                   # 归化到指定区间[min, max]
  10. torch.cos                                       # 余弦
  11. torch.cosh                                     # 双曲余弦
  12. torch.div                                        # 张量逐个元素除以标量value
  13. torch.floor                                     # 床函数，返回不小于元素的最大整数
  14. torch.fmod                                    # 计算除法余数(余数的正负与被除数相同)
  15. torch.frac                                      # 返回分数部分
  16. torch.lerp                                     # 线性插值 outi=starti+weight∗(endi−starti)
  17. torch.log                                       # 自然对数
  18. torch.log1p                                   # (input + 1) 的自然对数
  19. torch.mul                                      # 乘法
  20. torch.neg                                      # 负数
  21. torch.pow                                     # 指数（三种形式）
  22. torch.reciprocal                           # 倒数
  23. torch.remainder                           # 除法余数（余数与除数有相同的符号）
  24. torch.round                                  # 四舍五入取整
  25. torch.rsqrt                                    # 平方根倒数
  26. torch.sigmoid                               # sigmoid 值
  27. torch.sign                                     # 符号函数，返回正负
  28. torch.sin                                       # 正弦
  29. torch.sinh                                     # 双曲正弦
  30. torch.sqrt                                     # 平方根
  31. torch.tan                                      # 正切
  32. torch.tanh                                    # 双曲正弦
  33. torch.trunc                                   # 有符号数的小数部分被舍弃

（2）常见数学曲线（三角函数）

 

（3）代码示例（含注释） 

"""
数学操作 Math operations
"""
import torch

# # 计算输入张量的每个元素绝对值
obj1 = torch.abs(torch.tensor([-1, -2, 4, 8]))

# # 返回一个新张量，包含输入张量每个元素的反余弦。
t = torch.randn(4)
obj2 = torch.acos(t)

# # 对输入张量 input 逐元素加上标量值 value，并返回结果到一个新的张量 out，即 out=tensor+value。
# # 如果输入 input 是 FloatTensor or DoubleTensor 类型，则 value 必须为实数，否则须为整数。
obj3 = torch.add(torch.tensor([2, 4, 5]), 2)

# # other 张量的每个元素乘以一个标量值 value，并加到 iput 张量上。返回结果到输出张量 out。
# input (Tensor) – 第一个输入张量
# value (Number) – 用于第二个张量的尺寸因子
# other (Tensor) – 第二个输入张量
# out=input+(other∗value)
# obj4 = torch.add(torch.tensor([2, 4, 5]), 3, other=torch.tensor([1, 2, 3]))

# # 用 tensor2 对 tensor1 逐元素相除，然后乘以标量值 value 并加到 tensor。
# # 如果输入是 FloatTensor or DoubleTensor 类型，则 value 必须为实数，否则须为整数。
# tensor (Tensor) – 张量，对 tensor1 ./ tensor 进行相加
# value (Number, optional) – 标量，对 tensor1 ./ tensor2 进行相乘
# tensor1 (Tensor) – 张量，作为被除数(分子)
# tensor2 (Tensor) –张量，作为除数(分母)
t = torch.randn(2, 3)
t1 = torch.randn(2, 3)
t2 = torch.randn(2, 3)
obj5 = torch.addcdiv(t, 1, t1, t2)

# # 返回一个新张量，包含输入 input 张量每个元素的反正弦函数
obj6 = torch.asin(torch.randn(4))

# # 返回一个新张量，包含输入 input 张量每个元素的反正切函数
t = torch.randn(4)
obj7 = torch.atan(t)

# # 返回一个新张量，包含两个输入张量 input1 和 input2 的反正切函数
# # input1(i) / input2(i) 的反正切函数
obj8 = torch.atan2(t, torch.randn(4))

# # 天井函数！
# # 对输入 input 张量每个元素向上取整, 即取不小于每个元素的最小整数，并返回结果到输出。
obj9 = torch.ceil(torch.tensor([1.2, 3.3, 0.4]))

# # 将输入 input 张量每个元素的夹紧到区间 [min,max]，并返回结果到一个新张量。
# [1.2, 3.3, 0.4] >>> [1.2000, 3.0000, 0.4000]
obj10 = torch.clamp(torch.tensor([1.2, 3.3, 0.4]), min=0, max=3)

# # 返回一个新张量，包含输入 input 张量每个元素的余弦。
obj11 = torch.cos(torch.randn(3))

# # 返回一个新张量，包含输入 input 张量每个元素的双曲余弦。
obj12 = torch.cosh(torch.randn(3))

# # 将 input 逐元素除以标量值 value，并返回结果到输出张量 out。
obj13 = torch.div(torch.tensor([1, 2, 3]), 2)
obj14 = torch.div(torch.tensor([1, 2, 3]), torch.tensor([1, 1, 1]))

# # 返回一个新张量，包含输入 input 张量每个元素的指数。
obj15 = torch.exp(torch.tensor([6, 2, 1]))

# # 床函数: 返回一个新张量，包含输入 input 张量每个元素的 floor，即不小于元素的最大整数。
obj16 = torch.floor(torch.tensor([20.0, 1.2, 2.6]))

# # 计算除法余数。余数的正负与被除数相同。
obj17 = torch.fmod(torch.Tensor([-3, -2, -1, 1, 2, 3]), 2)

# # 返回每个元素的分数部分，例如：1.6的分数部分为0.6
obj18 = torch.frac(torch.tensor([1, 2.5, 3/2]))

# # 对两个张量以 start，end 做线性插值。
# outi=starti+weight∗(endi−starti)
start = torch.arange(1.0, 5.0)  # float
end = torch.Tensor(4).fill_(10)  # float
weight = 0.5  # float
obj19 = torch.lerp(start, end, weight=weight)  # float

# # 计算 input 的自然对数
obj20 = torch.log(torch.tensor([1, 10, 6]))

# # 计算 input+1 的自然对数 yi=log(xi+1)
# # 注意：对值比较小的输入，此函数比 torch.log()更准确。
obj21 = torch.log1p(torch.tensor([0, 9, 5]))

# # 用标量值 value 乘以输入 input 的每个元素，并返回一个新的结果张量。out=tensor∗value
obj22 = torch.mul(torch.tensor([1, 6, 16]), 2)

# # 返回一个新张量，包含输入 input 张量按元素取负。 即，out=−1∗input
obj23 = torch.neg(torch.tensor([1, 6, 16]))

# # 对输入 input 的按元素求 exponent 次幂值，并返回结果张量。
# # 幂值 exponent 可以为单一 float 数或者与 input 相同元素数的张量。
# exponent: 指数
obj24 = torch.pow(torch.tensor([1, 6, 16]), exponent=2)  # 单一 float
obj25 = torch.pow(torch.tensor([1, 6, 16]), torch.tensor([3, 2, 1]))  # 与 input 相同元素数的张量

# # torch.pow(base, input, out=None)
# # base 为标量浮点值,input 为张量，返回的输出张量 out 与输入张量相同形状。
obj26 = torch.pow(2, torch.tensor([3, 2, 1]))  # 和 obj24 相似

# # 返回一个新张量，包含输入 input 张量每个元素的倒数，即 1.0/x。
obj27 = torch.reciprocal(torch.tensor([5, 10, 1]))

# # 返回一个新张量，包含输入 input 张量每个元素的除法余数。
# # 除数与被除数可能同时包含整数或浮点数。
# 余数与除数有相同的符号!!!
obj28 = torch.remainder(torch.tensor([-3, -2, -1, 1, 2, 3]), 2)

# # 返回一个新张量，将输入 input 张量每个元素舍入到最近的整数。
obj29 = torch.round(torch.randn(3, 4))

# # 返回一个新张量，包含输入 input 张量每个元素的平方根倒数。
obj30 = torch.rsqrt(torch.tensor([1, 4, 9]))

# # 返回一个新张量，包含输入 input 张量每个元素的 sigmoid 值。
# sigmoid 函数范围 （0, 1），但是此函数的返回值包含 0 和 1
obj31 = torch.sigmoid(torch.tensor([-0.1, 200, 3]))

# # 符号函数：返回一个新张量，包含输入 input 张量每个元素的正负。
obj32 = torch.sign(torch.tensor([-1, 3, 5, -6, 6]))

# # 返回一个新张量，包含输入 input 张量每个元素的正弦。
obj33 = torch.sin(torch.tensor([1, 3, 5]))

# # 返回一个新张量，包含输入 input 张量每个元素的双曲正弦。
obj34 = torch.sinh(torch.tensor([1, 3, 5]))

# # 返回一个新张量，包含输入 input 张量每个元素的平方根。
obj35 = torch.sqrt(torch.tensor([1, 4, 9]))

# # 返回一个新张量，包含输入 input 张量每个元素的正切。
obj36 = torch.tan(torch.tensor([1, 4, 9]))

# # 返回一个新张量，包含输入 input 张量每个元素的双曲正切。
obj37 = torch.tanh(torch.tensor([1, 4, 9]))

# # 返回一个新张量，包含输入 input 张量每个元素的截断值(标量 x 的截断值是最接近其的整数，其比 x 更接近零)。
# # 简而言之，有符号数的小数部分被舍弃。
obj38 = torch.trunc(torch.tensor([1.2, 4.0, 9.9]))

print("*"*20, "obj1", "*"*20, "\n", obj1, "\n")
print("*"*20, "obj2", "*"*20, "\n", t, "\n", obj2, "\n")
print("*"*20, "obj3", "*"*20, "\n", obj3, "\n")
# print("*"*20, "obj4", "*"*20, "\n", obj4, "\n")
print("*"*20, "obj5", "*"*20, "\n", t, "\n", t1, "\n", t2, "\n", obj5, "\n")
print("*"*20, "obj6", "*"*20, "\n", obj6, "\n")
print("*"*20, "obj7", "*"*20, "\n", obj7, "\n")
print("*"*20, "obj8", "*"*20, "\n", obj8, "\n")
print("*"*20, "obj9", "*"*20, "\n", obj9, "\n")
print("*"*20, "obj10", "*"*20, "\n", obj10, "\n")
print("*"*20, "obj11", "*"*20, "\n", obj11, "\n")
print("*"*20, "obj12", "*"*20, "\n", obj12, "\n")
print("*"*20, "obj13", "*"*20, "\n", obj13, "\n", obj14, "\n")
print("*"*20, "obj15", "*"*20, "\n", obj15, "\n")
print("*"*20, "obj16", "*"*20, "\n", obj16, "\n")
print("*"*20, "obj17", "*"*20, "\n", obj17, "\n")
print("*"*20, "obj18", "*"*20, "\n", obj18, "\n")
print("*"*20, "obj19", "*"*20, "\n", start, "\n", end, "\n", obj19, "\n")
print("*"*20, "obj20", "*"*20, "\n", obj20, "\n")
print("*"*20, "obj21", "*"*20, "\n", obj21, "\n")
print("*"*20, "obj22", "*"*20, "\n", obj22, "\n")
print("*"*20, "obj23", "*"*20, "\n", obj23, "\n")
print("*"*20, "obj24", "*"*20, "\n", obj24, "\n", obj25, "\n")
print("*"*20, "obj26", "*"*20, "\n", obj26, "\n")
print("*"*20, "obj27", "*"*20, "\n", obj27, "\n")
print("*"*20, "obj28", "*"*20, "\n", obj28, "\n")
print("*"*20, "obj29", "*"*20, "\n", obj29, "\n")
print("*"*20, "obj30", "*"*20, "\n", obj30, "\n")
print("*"*20, "obj31", "*"*20, "\n", obj31, "\n")
print("*"*20, "obj32", "*"*20, "\n", obj32, "\n")
print("*"*20, "obj33", "*"*20, "\n", obj33, "\n")
print("*"*20, "obj34", "*"*20, "\n", obj34, "\n")
print("*"*20, "obj35", "*"*20, "\n", obj35, "\n")
print("*"*20, "obj36", "*"*20, "\n", obj36, "\n")
print("*"*20, "obj37", "*"*20, "\n", obj37, "\n")
print("*"*20, "obj38", "*"*20, "\n", obj38, "\n")

 >>>output

******************** obj1 ******************** 
 tensor([1, 2, 4, 8]) 

******************** obj2 ******************** 
 tensor([1.0776, 0.7139, 1.7933, 1.3843]) 
 tensor([   nan, 1.0375,    nan,    nan]) 

******************** obj3 ******************** 
 tensor([4, 6, 7]) 

******************** obj5 ******************** 
 tensor([1.0776, 0.7139, 1.7933, 1.3843]) 
 tensor([[ 1.9588, -0.0034, -0.6113],
              [ 1.3774, -1.2835,  0.2754]]) 
 tensor([[-0.5537,  1.6611, -0.9096],
              [-0.0702, -1.0303, -1.1696]]) 
 tensor([[ -3.5055,  -0.4913,   1.7136],
              [-20.5570,   0.7846,  -2.5386]]) 

******************** obj6 ******************** 
 tensor([ 0.1210, -0.4902,     nan,  0.0716]) 

******************** obj7 ******************** 
 tensor([0.8227, 0.6200, 1.0621, 0.9452]) 

******************** obj8 ******************** 
 tensor([1.1686, 0.8615, 1.2858, 1.4895]) 

******************** obj9 ******************** 
 tensor([2., 4., 1.]) 

******************** obj10 ******************** 
 tensor([1.2000, 3.0000, 0.4000]) 

******************** obj11 ******************** 
 tensor([0.9254, 0.9652, 0.8891]) 

******************** obj12 ******************** 
 tensor([1.1275, 1.0389, 1.2345]) 

******************** obj13 ******************** 
 tensor([0.5000, 1.0000, 1.5000]) 
 tensor([1., 2., 3.]) 

******************** obj15 ******************** 
 tensor([403.4288,   7.3891,   2.7183]) 

******************** obj16 ******************** 
 tensor([20.,  1.,  2.]) 

******************** obj17 ******************** 
 tensor([-1., -0., -1.,  1.,  0.,  1.]) 

******************** obj18 ******************** 
 tensor([0.0000, 0.5000, 0.5000]) 

******************** obj19 ******************** 
 tensor([1., 2., 3., 4.]) 
 tensor([10., 10., 10., 10.]) 
 tensor([5.5000, 6.0000, 6.5000, 7.0000]) 

******************** obj20 ******************** 
 tensor([0.0000, 2.3026, 1.7918]) 

******************** obj21 ******************** 
 tensor([0.0000, 2.3026, 1.7918]) 

******************** obj22 ******************** 
 tensor([ 2, 12, 32]) 

******************** obj23 ******************** 
 tensor([ -1,  -6, -16]) 

******************** obj24 ******************** 
 tensor([  1,  36, 256]) 
 tensor([ 1, 36, 16]) 

******************** obj26 ******************** 
 tensor([8, 4, 2]) 

******************** obj27 ******************** 
 tensor([0.2000, 0.1000, 1.0000]) 

******************** obj28 ******************** 
 tensor([1, 0, 1, 1, 0, 1]) 

******************** obj29 ******************** 
 tensor([[ 0., -1.,  1., -1.],
              [-0.,  0.,  0., -2.],
              [ 0.,  0., -1., -1.]]) 

******************** obj30 ******************** 
 tensor([1.0000, 0.5000, 0.3333]) 

******************** obj31 ******************** 
 tensor([0.4750, 1.0000, 0.9526]) 

******************** obj32 ******************** 
 tensor([-1,  1,  1, -1,  1]) 

******************** obj33 ******************** 
 tensor([ 0.8415,  0.1411, -0.9589]) 

******************** obj34 ******************** 
 tensor([ 1.1752, 10.0179, 74.2032]) 

******************** obj35 ******************** 
 tensor([1., 2., 3.]) 

******************** obj36 ******************** 
 tensor([ 1.5574,  1.1578, -0.4523]) 

******************** obj37 ******************** 
 tensor([0.7616, 0.9993, 1.0000]) 

******************** obj38 ******************** 
 tensor([1., 4., 9.]) 

**************************************************专栏直达**************************************************

https://blog.csdn.net/qq_54185421/category_11794260.htmlhttps://blog.csdn.net/qq_54185421/category_11794260.html

 **************************************************************************************************************

>>>如有疑问，欢迎评论区一起探讨

Flying Bulldog
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第三章：数学运算 Math Operations
GreenPeel的专栏
01-30 461
因为solidity还不支持浮点运算。这里的除法可能会比想象中的复杂。后面的章节再详细说明。这一章占位。
学习笔记 Day54（梯度，激活函数）
a_Loki的博客
03-16 2466
1，梯度： 2，激活函数 1，sigmoid 1，torch.sigmoid import torch a = torch.linspace(-100,100,10) print(a) print(torch.sigmoid(a)) 2, tanh 1,torch.tanh b = torch.linspace(-1,1,10) print(b) print(torch.tanh(b)) 3,Relu 目录 1，梯度： 2，激活函数...
PyTorch学习笔记之激活函数篇（二）
记录学习过程
03-17 1021
双曲正切函数 tanh(x) 的定义是 (e^x - e^-x) / (e^x + e^-x)，其中 e 是自然对数的底数。tanh 函数的值域是 [-1, 1]，并且它是奇函数，即 tanh(-x) = -tanh(x)。3、当神经网络的层数增多的时候，由于在进行反向传播的时候，链式求导，多项相乘，函数进入饱和区（导数接近于零的地方）就会逐层传递，这种现象被称为梯度消失。3、在一般的二元分类问题中，tanh 函数用于隐藏层，而 sigmoid 函数用于输出层，但这并不是固定的，需要根据特定问题进行调整。
深入理解 PyTorch 激活函数：从基础到高效实用技巧（4）
CDBmax的博客
01-16 1180
这个公式表示输入值的指数减去其负指数，然后除以这两个指数的和。结果是一个在 -1 和 1 之间的输出，提供了一个平滑的非线性变换。这个公式表示计算输入值的负指数，加 1 后取其倒数。结果是一个在 0 和 1 之间的输出，提供了平滑的非线性变换。如果x ≤ -3，则。如果x ≥ +3，则。否则，。这个公式将输入值分为三个区域：小于等于 -3 的区域输出为 0，大于等于 +3 的区域输出为 1，介于这两者之间的区域输出为。其中σ(x)是逻辑 Sigmoid 函数。这意味着每个输入值x。
PyTorch学习笔记：nn.Tanh——Tanh激活函数
qq_50001789的博客
02-10 1万+
PyTorch学习笔记：nn.Tanh——Tanh激活函数
PyTorch基础之激活函数模块中Sigmoid、Tanh、ReLU、LeakyReLU函数讲解（附源码）
showswoller的博客
04-29 7117
PyTorch基础之激活函数模块中Sigmoid、Tanh、ReLU、LeakyReLU函数讲解（附源码）
动手学深度学习2.1数据操作-笔记&练习（PyTorch）-jupyter源代码
03-25
李沐老师动手学深度学习PyTorch版2.1数据操作-笔记&练习详解-jupyter源代码
PyTorch 1.0 中文文档 & 教程.pdf
04-30
pytorch1.0官方中文文档&教程，包含起步使用简单教程，算法例子，中文文档包含机器学习深度学习常用算法demo例子
PyTorch 0.3&0.4 中文文档
02-22
PyTorch 0.3&0.4 中文文档
动手学深度学习PyTorch版2.2数据预处理-笔记&练习详解-jupyter源代码
最新发布
03-25
李沐老师动手学深度学习PyTorch版2.2数据预处理-笔记&练习详解-jupyter源代码
pytorch介绍&心得&项目&相关练习
03-13
这篇文章是关于深度学习框架PyTorch的详细介绍、使用心得、项目经验以及相关练习的分享。 文章开篇便对PyTorch进行了全面而深入的介绍，阐述了其作为Facebook人工智能研究院开发的深度学习框架，如何凭借其强大的...
Pytorch：激活函数及其梯度
weixin_62637793的博客
11-03 660
（1）sigmoid函数 sigmoid函数曲线平滑，可以很好的使用，但是如果数据长时间不更新，会出现失去梯度的状况，也叫梯度弥散。 求sigmoid函数的梯度 当然，我们可以使用pytorch实现sigmoid函数。代码如下。 import torch a=torch.linspace(-100,100,10) torch.sigmoid(a) '''得到结果为 tensor([0.0000e+00, 1.6655e-34, 7.4564e-25, 3.3382e-15, 1.4945.
torch.sqrt()的使用
敲代码的小风
12-17 2万+
参考链接: torch.sqrt(input, out=None) 功能: 逐元素计算张量的平方根 代码实验: (base) PS C:\Users\chenxuqi> python Python 3.7.4 (default, Aug 9 2019, 18:34:13) [MSC v.1915 64 bit (AMD64)] :: Anaconda, Inc. on win32 Type "help", "copyright", "credits" or "license" for mor
pytorch中的 relu、sigmoid、tanh、softplus 函数
weixin_42528089的博客
12-06 5万+
 四种基本激励函数是需要掌握的： 1.relu  线性整流函数（Rectified Linear Unit, ReLU）,又称修正线性单元, 是一种人工神经网络中常用的激活函数（activation function），通常指代以斜坡函数及其变种为代表的非线性函数。通常意义下，线性整流函数代指代数学中的斜坡函数，即 而在神经网络中，线性整流函数作为神经元的激活函数，定义了该神经元在线性变换 ...
pytorch中的relu,sigmiod,tanh等激励函数(激活函数）
Troublemaker丶的博客
03-20 5121
什么是激励函数（激活函数）： 在神经网络中原本输入输出都是线性关系，但现实中，许多的问题是非线性的（比如，房价问题中，房价不可能随着房子面积的增加一直线性增加），这个时候就神经网络的线性输出，再经过激励函数，便使得原本线性的关系变成非线性了，增强了神经网络的性能。 常用的激励函数（激活函数）： relu，sigmoid，tanh，softmax，softplus torch 实现激励函数（...
激活函数Tanh
热门推荐
August-us的博客
03-18 9万+
激活函数Tanh系列文章：   Tanh的诞生比Sigmoid晚一些，sigmoid函数我们提到过有一个缺点就是输出不以0为中心，使得收敛变慢的问题。而Tanh则就是解决了这个问题。Tanh就是双曲正切函数。等于双曲余弦除双曲正弦。函数表达式和图像见下图。这个函数是一个奇函数。   对tanh函数求导需要一定的数学基础，这里直接给出结果。tanh′(x)=1−tanh2(x)tanh'(x)=...
Pytorch 如何计算三角函数
weixin_36670529的博客
02-28 2944
1、加载库 首先加载torch库，进入python后加载库使用import导入 【import 库名】 2、sin值计算方法 pytorch中的sin计算都是基于tensor的，所以无论单个值还是多个值同时计算sin值，都需要首先将输入量转换为tensor 使用指令： 【torch.sin(tensor)】 实例中，使用了计算单个和多个sin值时的情况 3、cos值计算方法 pytorch中的cos计算都是基于tensor的，所以无论单个值还是多个值同时计算cos值，都需要首先将输
激活函数之tanh介绍及C++/PyTorch实现
网络资源是无限的
07-29 5055
深度神经网络中使用的激活函数有很多种，这里介绍下tanh。它的公式如下，截图来自于维基百科(https://en.wikipedia.org/wiki/Activation_function)： tanh又称双曲正切，它解决了sigmoid非零中心问题。tanh取值范围在(-1, 1)内，它也是非线性的。它也不能完全解决梯度消失问题。 C++实现如下： template<typename _Tp> int activation_function_t...
Pytorch学习之torch----数学操作(三)
励志的小胡子
07-17 9774
1. torch.reciprocal(input, out=None) 说明：返回一个新张量，包含输入input张量每个元素的倒数。 参数： input(Tensor) -- 输入张量 out(Tensor, 可选) -- 输出张量 >>> a = torch.randn(5) >>> a tensor([ 0.6535, 1.3616, -1....
pytorch官方文档
09-14
PyTorch官方文档是一个非常有价值的资源，提供了关于PyTorch库的详细说明和指南。您可以在PyTorch官方网站上...总之，PyTorch官方文档是学习和使用PyTorch的重要参考资料，可以帮助您更好地掌握和应用该深度学习框架。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Flying Bulldog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值