_TensorBase(45个张量基础后置函数总结) && Pytorch官方文件 && NOTEBOOK(NINE)

最新推荐文章于 2023-02-18 17:41:14 发布

Flying Bulldog

最新推荐文章于 2023-02-18 17:41:14 发布

阅读量1.3k

点赞数

分类专栏： Pytorch_python 文章标签： pytorch 深度学习人工智能 python

本文链接：https://blog.csdn.net/qq_54185421/article/details/124787719

版权

Pytorch_python 专栏收录该内容

18 篇文章 5 订阅

订阅专栏

（1）本文涉及函数的列表（具体用法和注释在代码之中）

torch.FloatTensor # 构建浮点张量
torch.IntTensor.zero_ # 空张量
torch.abs # 没有改变张量的内置数据
torch.abs_ # 改变张量的内置数据
torch.copysign # 引用符号（正负号）
obj1[0][1] = 6 # 更改指定元素的值
torch.Tensor().element_size # 返回单个元素的字节大小
torch.Tensor().expand # 单个维度扩大尺寸
torch.Tensor().expand_as # 扩展维度的大小
torch.Tensor().exponential_ # 同指数分布得到的元素填充
torch.Tensor().fill_ # 用指定的数填充
torch.Tensor().geometric_ # 用几何分布得到的元素填充
torch.Tensor().histc # 生成bins个元素
torch.Tensor()[2][1] # 利用索引调用元素
torch.Tensor().index_add_ # 按照索引数确定的顺序，进行元素相加
torch.Tensor().index_copy_ # 按照索引确定的顺序，进行元素复制
torch.Tensor().index_fill_ # 按照索引确定的顺序，用参数val值填充
torch.Tensor().int # 将该张量投射为int类型
torch.Tensor().is_contiguous # 判断张量在内存中是都是连续的
torch.Tensor().is_pinned # 判断张量是否在固定内存中
torch.Tensor().is_set_to # 判断两个张量是否都指向相同的内存
torch.Tensor().log_normal_ # 对数正态分布的元素填充
torch.Tensor().long # 将张量投射为long类型
torch.Tensor().masked_scatter_ # 把前面的张量复制到后面的张量中
torch.Tensor().masked_fill_ # 把后面的张量通过掩膜复制到前面的张量中
torch.Tensor().narrow # 缩放张量
torch.Tensor().normal_ # 用均值为mean和标准差为std的正态分布填充
torch.Tensor().numpy() # 把张量转换成ndarray数组
torch.Tensor().permute().size() # 维度换位
torch.Tensor().random_ # 正态分布或离散正态分布取样值进行填充
torch.Tensor().repeat # 沿着指定维度重复tensor
torch.Tensor().resize_as_().fill_ # 调整张量大小
torch.Tensor().scatter_ # 将 src 中的所有值按照 index 确定的索引写入本 tensor 中
torch.Tensor().select # 按照 index 中选定的维度将 tensor 切片
torch.Tensor().size # 返回张量的大小
torch.Tensor().split # 分割张量
torch.Tensor().storage_offset # 返回偏移量
torch.Tensor()[3:].storage_offset # 返回指定元素在内存中的偏移量
torch.Tensor()torch.sub # 缩放（相减）
torch.Tensor().type # 将对象投射为指定的类型
torch.Tensor().type_as # 将 tensor 投射为参数给定 tensor 类型并返回
torch.Tensor().unfold # 调整原张量的视图
torch.Tensor().uniform_ # 用从均匀分布中抽样得到的值填充
torch.Tensor().view # 返回有相同数据但大小不同的张量（输入整数）
torch.Tensor().view_as # 返回有相同数据但大小不同的张量（输入张量）

注意：

关于eval内置函数的使用方法，可以访问我的另外一篇博客：

python的内置函数 exec 和 eval 的具体用法及比较，并解析语法格式_Flying Bulldog的博客-CSDN博客exec 和 eval 都是用来 “处理字符串” 的函数；exec 把字符串转化成 “待执行的语句”，返回值永远为 None；eval 把字符串转换成 “python表达式”，返回表达式计算结果。https://blog.csdn.net/qq_54185421/article/details/124459806

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

TensorBase_1.py

"""
torch.Tensor 是一种包含单一数据类型元素的多维矩阵。
Torch 定义了七种 CPU tensor 类型和八种 GPU tensor 类型：

"""
import torch

# # torch.Tensor 是默认的 tensor 类型（torch.FloatTensor）的简称。

# 一个张量 tensor 可以从 Python 的 list 或序列构建：
obj1 = torch.FloatTensor([[1, -2, 3], [-4, 5, 6]])

# 一个空张量 tensor 可以通过规定其大小来构建：
obj2 = torch.IntTensor(2, 4).zero_()

# 可以用 python 的索引和切片来获取和修改一个张量 tensor 中的内容：
obj1[0][1] = 6  # 把 obj1 的第一行的第二列的元素 8 转化成 6
obj3 = obj1

# 每一个张量 tensor 都有一个相应的 torch.Storage 用来保存其数据。
# 类 tensor 提供了一个存储的多维的、横向视图，并且定义了在数值运算。
obj4 = torch.abs(obj3)
print("无下划线", obj3, "\n")  # 没有改变张量的torch.Storage
# 会改变 tensor 的函数操作会用一个下划线后缀来标示。
# 会在原地计算绝对值，并返回改变后的 tensor，
obj5 = torch.abs_(obj3)
print("有下划线", obj3, "\n")  # 改变了张量的torch.Storage
# 还有很多有下划线的函数，大部分函数都有，不一一列举了

# input 复制 other 的符号（正负号）
obj6 = torch.copysign(torch.tensor([1, 2, 3]), -1)
obj7 = torch.copysign(torch.tensor([1, 2, 3]), torch.tensor([1, -5, 8]))

# 返回单个元素的字节大小
obj8 = torch.FloatTensor().element_size()
obj9 = torch.ByteTensor().element_size()

# 返回 tensor 的一个新视图，单个维度扩大为更大的尺寸。
x = torch.Tensor([[1], [2], [3]])
obj10 = x.size()
obj11 = x.expand(3, 4)

# 将 tensor 扩展为参数 other 的大小。
obj12 = x.expand_as(torch.randn(3, 4))  # 注意维度的大小

# 将该 tensor 用指数分布得到的元素填充：
# f(x) = \lambda e^{-\lambda x}
# exponential: 指数的；幂数的
obj13 = torch.Tensor(3, 4).exponential_(lambd=2)  # 注意：参数不是lambda，而是lambd

# 将该 tensor 用指定的数值填充
obj14 = torch.Tensor(3, 4).fill_(3)

# 将该 tensor 用几何分布得到的元素填充：
# f(X=k) = p^{k - 1} (1 - p)
obj15 = torch.Tensor(3, 4).geometric_(p=0.5)  # geometric_ expects p to be in (0, 1)

# 将 tensor 投射为半精度浮点类型
# 生成100个元素
obj16 = torch.histc(input=torch.FloatTensor(4, 4), bins=100, min=0, max=1)
# print(obj16.element_size())  # 4

# tensor的索引的调用方法和列表的调用方法相同
t = torch.FloatTensor(3, 4).fill_(6)
obj17 = t[2][1]

# index_add_(dim, index, tensor) → Tensor
# 按参数 index 中的索引数确定的顺序，将参数 tensor 中的元素加到原来的 tensor 中。
# 参数 tensor 的尺寸必须严格地与原 tensor 匹配，否则会发生错误。
x = torch.ones(5, 3)
t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
index = torch.tensor([0, 4, 2])  # x的第0、4、2行分别相加t的0、1、2行，不互换行与行的元素
obj18 = x.index_add_(0, index, t)

# # 按参数 index 中的索引数确定的顺序，将参数 tensor 中的元素复制到原来的 tensor 中。
# # 参数 tensor 的尺寸必须严格地与原 tensor 匹配，否则会发生错误。
x = torch.Tensor(3, 3)
t = torch.Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
index = torch.LongTensor([0, 2, 1])
obj19 = x.index_copy_(0, index, t)

# # 按参数 index 中的索引数确定的顺序，将原 tensor 用参数 val 值填充。
# # 参数 tensor 的尺寸必须严格地与原 tensor 匹配，否则会发生错误。
t = torch.Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
index = torch.LongTensor([0, 2])
obj20 = t.index_fill_(0, index, -2)

for i in range(1, 21):
    try:
        print("*" * 20, "obj{}".format(i), "*" * 20)
        # eval 把字符串转换成 “python表达式”
        print(eval(str("obj") + str(i)), "\n")
    except:
        pass

TensorBase_2.py

"""
torch.Tensor 是一种包含单一数据类型元素的多维矩阵。
Torch 定义了七种 CPU tensor 类型和八种 GPU tensor 类型：
"""
import torch

# 将该 tensor 投射为 int 类型
obj1 = torch.tensor([1.0, 2.0, 2.0]).int()

# 如果该 tensor 在内存中是连续的则返回 True。
obj2 = torch.tensor([1, 5, 3]).is_contiguous()

# 如果该 tensor 在固定内内存中则返回 True
obj3 = torch.tensor([1, 2, 3]).is_pinned()

# 如果两个张量都指向完全相同的内存（相同的存储空间、偏移量、大小和步幅），则返回 True。
obj4 = torch.tensor([1, 4, 5]).is_set_to(torch.tensor([1, 4, 5]))

# 将该 tensor 用均值为$\mu$,标准差为$\sigma$的对数正态分布得到的元素填充。
# 要注意 mean 和 stdv 是基本正态分布的均值和标准差，
# f(x) = \dfrac{1}{x \sigma \sqrt{2\pi}}\ e^{-\frac{(\ln x - \mu)^2}{2\sigma^2}}
obj5 = torch.Tensor(3, 4).log_normal_(mean=1, std=2)

# 将 tensor 投射为 long 类型
obj6 = torch.Tensor(3, 4).fill_(1.0).long()

# 将 mask 中值为 1 元素对应的 source 中位置的元素复制到本 tensor 中。
# mask 应该有和本 tensor 相同数目的元素。
# source 中元素的个数最少为 mask 中值为 1 的元素的个数。
obj7 = torch.Tensor(2, 3).fill_(2).masked_scatter_(torch.Tensor(2, 3).fill_(1), torch.Tensor(3, 4))  # 把前面的张量复制到后面的张量中
# Copies elements from :attr:`source` into :attr:`self` tensor at positions where the :attr:`mask` is True.
# mask (BoolTensor): the boolean mask
# source (Tensor): the tensor to copy from

# 在 mask 值为 1 的位置处用 value 填充。mask 的元素个数需和本 tensor 相同，但尺寸可以不同。
obj8 = torch.Tensor(2, 2).fill_(10).masked_fill_(torch.tensor([[1, 0], [1, 1]]), 6)  # 把后面的张量通过掩膜复制到前面的张量中

# 返回一个本 tensor 经过缩小后的 tensor。
# 维度 dim 缩小范围是 start 到 start+length。
# 原 tensor与返回的 tensor 共享相同的底层内存。
obj9 = torch.Tensor(2, 2).fill_(10).narrow(dim=1, start=0, length=1)

# 将 tensor 用均值为 mean 和标准差为 std 的正态分布填充。
obj10 = torch.Tensor(2, 2).fill_(10).normal_(mean=0, std=1)

# 将该 tensor 以 NumPy 的形式返回 ndarray，两者共享相同的底层内存。
# 原 tensor 改变后会相应的在 ndarray 有反映，反之也一样。
t11 = torch.Tensor(2, 2).fill_(10)
obj11 = t11.numpy()
t11[1][0] = 6

# 将 tensor 的维度换位。
x = torch.randn(2, 3, 5)
obj12 = x.permute(2, 0, 1).size()

# 将 tensor 用从在[from, to-1]上的正态分布或离散正态分布取样值进行填充。
# 如果没有明确说明，则填充值仅由本 tensor 的数据类型限定。
obj13 = torch.Tensor(2, 3).random_(0, to=5)
obj14 = torch.FloatTensor(2, 3).random_(0, to=None)

# 沿着指定的维度重复 tensor。 不同于 expand()，本函数复制的是 tensor 中的数据。
obj15 = torch.Tensor([[2, 3], [4, 5]]).repeat(3, 4)

# 将本 tensor 的大小调整为与参数中的 tensor 相同的大小。
# 等效于：self.resize_(tensor.size())
obj16 = torch.Tensor(2, 3).fill_(1).resize_as_(torch.Tensor(3, 4).fill_(2))

# 将 src 中的所有值按照 index 确定的索引写入本 tensor 中。
# 其中索引是根据给定的 dimension，dim 按照 gather()描述的规则来确定。
# 注意，index 的值必须是在_0_到_(self.size(dim)-1)_之间，
x = torch.randn(2, 3)
obj17 = x
obj18 = torch.Tensor(2, 3).fill_(1).scatter_(1, torch.LongTensor([[0, 2, 1], [2, 0, 1]]), x)

# 按照 index 中选定的维度将 tensor 切片。
# 如果 tensor 是一维的，则返回一个数字。否则，返回给定维度已经被移除的 tensor。
obj19 = torch.Tensor(2, 3).select(0, 1)
# Args:
# dim (int): the dimension to slice
# index (int): the index to select with

# 返回 tensor 的大小。返回的值是 tuple 的子类。
obj20 = torch.Tensor(3, 5, 6).size()

# 将 tensor 分割成 tensor 数组。请查看 torch.split()
obj21 = torch.Tensor(2, 3, 5).split(7, 1)

# 以储存元素的个数的形式返回 tensor 在内存中的偏移量。
obj22 = torch.Tensor([1, 2, 3, 4, 5]).storage_offset()
obj23 = torch.Tensor([1, 2, 3, 4, 5])[3:].storage_offset()

# 从 tensor 中抽取一个标量或 tensor。
# 如果 value 和 other 都是给定的，则在使用之前 other 的每一个元素都会被 value 缩放(相减)。
obj24 = torch.sub(torch.Tensor([1, 2, 4]), 0.5)
obj25 = torch.sub(torch.Tensor([1, 2, 4]), torch.Tensor([1, 1, 1]))

# 将对象投为指定的类型。torch.Tensor默认类型为Float
obj26 = torch.Tensor(1, 3, 4).type(dtype=torch.int32)

# 将 tensor 投射为参数给定 tensor 类型并返回。
obj27 = torch.Tensor(1, 3, 4).fill_(5).type_as(torch.IntTensor([1, 2, 4]))

# 返回原始张量的视图，指定切片的大小和每个切片之间的步长
# unfold(dimension, size, step) -> Tensor
# 维度（int）：展开发生的维度
# size (int): 展开的每个切片的大小
# step (int)：每个切片之间的步长
x = torch.arange(1, 8)
obj28 = x.unfold(0, 2, 1)
obj29 = x.unfold(0, 3, 2)

# 将 tensor 用从均匀分布中抽样得到的值填充。
obj30 = torch.Tensor(2, 3, 4).uniform_(0, 1)

# ================================================================== #
# # 输入整数
# 返回一个有相同数据但大小不同的 tensor。
# 返回的 tensor 必须有与原 tensor 相同的数据和相同数目的元素，但可以有不同的大小。
# 一个 tensor 必须是连续的 contiguous()才能被查看。
obj31 = torch.Tensor(2, 3, 5)
obj32 = obj31.view(30)  # 2*3*5=30  # 返回大小为(1, 30)的一维张量

# 输入张量
# 返回被视作与给定的 tensor 相同大小的原 tensor。
obj33 = obj31.view_as(torch.Tensor(2, 15))  # 返回大小为(2, 15)的二维张量
# ================================================================== #


for i in range(1, 34):
    try:
        print("*" * 20, "obj{}".format(i), "*" * 20)
        # eval 把字符串转换成 “python表达式”
        print(eval(str("obj") + str(i)), "\n")
    except:
        pass

  >>>output_1

无下划线 tensor([[ 1., 6., 3.],
[-4., 5., 6.]])

有下划线 tensor([[1., 6., 3.],
[4., 5., 6.]])

******************** obj1 ********************
tensor([[1., 6., 3.],
[4., 5., 6.]])

******************** obj2 ********************
tensor([[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=torch.int32)

******************** obj3 ********************
tensor([[1., 6., 3.],
[4., 5., 6.]])

******************** obj4 ********************
tensor([[1., 6., 3.],
[4., 5., 6.]])

******************** obj5 ********************
tensor([[1., 6., 3.],
[4., 5., 6.]])

******************** obj6 ********************
tensor([-1., -2., -3.])

******************** obj7 ********************
tensor([ 1., -2., 3.])

******************** obj8 ********************
4

******************** obj9 ********************
1

******************** obj10 ********************
torch.Size([3, 1])

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

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

******************** obj13 ********************
tensor([[0.4669, 2.1746, 0.1574, 1.3098],
[0.3156, 1.3735, 0.2133, 1.0070],
[0.7781, 1.1207, 0.0182, 0.9676]])

******************** obj14 ********************
tensor([[3., 3., 3., 3.],
[3., 3., 3., 3.],
[3., 3., 3., 3.]])

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

******************** obj16 ********************
tensor([12., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
   0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
     0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
     0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
     0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
   0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
     0., 0.])

******************** obj17 ********************
tensor(6.)

******************** obj18 ********************
tensor([[ 2., 3., 4.],
[ 1., 1., 1.],
[ 8., 9., 10.],
[ 1., 1., 1.],
[ 5., 6., 7.]])

******************** obj19 ********************
tensor([[1., 2., 3.],
   [7., 8., 9.],
[4., 5., 6.]])

******************** obj20 ********************
tensor([[-2., -2., -2.],
[ 4., 5., 6.],
[-2., -2., -2.]])

   >>>output_2

******************** obj1 ********************
tensor([1, 2, 2], dtype=torch.int32)

******************** obj2 ********************
True

******************** obj3 ********************
False

******************** obj4 ********************
False

******************** obj5 ********************
tensor([[2.1913e-01, 2.2163e-02, 8.9421e-01, 1.1587e+01],
[5.9468e+00, 6.8859e-01, 2.5673e+00, 1.8512e+01],
[6.1639e-01, 3.6431e+01, 6.5872e+00, 3.4976e+00]])

******************** obj6 ********************
tensor([[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]])

******************** obj7 ********************
tensor([[2., 2., 2.],
[2., 2., 2.]])

******************** obj8 ********************
tensor([[ 6., 10.],
[ 6., 6.]])

******************** obj9 ********************
tensor([[10.],
   [10.]])

******************** obj10 ********************
tensor([[ 0.1659, -1.5151],
[-0.8123, 0.2678]])

******************** obj11 ********************
[[10. 10.]
[ 6. 10.]]

******************** obj12 ********************
torch.Size([5, 2, 3])

******************** obj13 ********************
tensor([[1., 4., 4.],
[2., 3., 2.]])

******************** obj14 ********************
tensor([[11935666., 8485914., 10576380.],
[ 1753921., 6170202., 2809117.]])

******************** obj15 ********************
tensor([[2., 3., 2., 3., 2., 3., 2., 3.],
[4., 5., 4., 5., 4., 5., 4., 5.],
[2., 3., 2., 3., 2., 3., 2., 3.],
[4., 5., 4., 5., 4., 5., 4., 5.],
[2., 3., 2., 3., 2., 3., 2., 3.],
[4., 5., 4., 5., 4., 5., 4., 5.]])

******************** obj16 ********************
tensor([[1., 1., 1., 1.],
[1., 1., 0., 0.],
[0., 0., 0., 0.]])

******************** obj17 ********************
tensor([[-0.9783, 1.2584, -0.3980],
[-0.9402, -0.7283, 1.4979]])

******************** obj18 ********************
tensor([[-0.9783, -0.3980, 1.2584],
[-0.7283, 1.4979, -0.9402]])

******************** obj19 ********************
tensor([0., 0., 0.])

******************** obj20 ********************
torch.Size([3, 5, 6])

******************** obj21 ********************
(tensor([[[1.1463e+30, 8.1836e-43, 3.3559e-20, 3.2510e-43, 0.0000e+00],
[0.0000e+00, 2.1019e-44, 0.0000e+00, 3.5859e+31, 8.1836e-43],
[3.3559e-20, 3.2510e-43, 0.0000e+00, 0.0000e+00, 2.1019e-44]],

[[0.0000e+00, 1.1311e+32, 8.1836e-43, 3.3559e-20, 3.2510e-43],
[0.0000e+00, 0.0000e+00, 2.1019e-44, 0.0000e+00, 3.8005e+31],
[8.1836e-43, 3.3559e-20, 3.2510e-43, 0.0000e+00, 0.0000e+00]]]),)

******************** obj22 ********************
0

******************** obj23 ********************
3

******************** obj24 ********************
tensor([0.5000, 1.5000, 3.5000])

******************** obj25 ********************
tensor([0., 1., 3.])

******************** obj26 ********************
tensor([[[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]]], dtype=torch.int32)

******************** obj27 ********************
tensor([[[5, 5, 5, 5],
[5, 5, 5, 5],
[5, 5, 5, 5]]], dtype=torch.int32)

******************** obj28 ********************
tensor([[1, 2],
[2, 3],
[3, 4],
   [4, 5],
[5, 6],
[6, 7]])

******************** obj29 ********************
tensor([[1, 2, 3],
[3, 4, 5],
[5, 6, 7]])

******************** obj30 ********************
tensor([[[0.6728, 0.0580, 0.0029, 0.3877],
   [0.2545, 0.9419, 0.3931, 0.7527],
   [0.9927, 0.5357, 0.3064, 0.9194]],

[[0.7586, 0.8892, 0.0431, 0.1697],
   [0.2318, 0.1436, 0.2494, 0.2116],
   [0.6804, 0.9092, 0.8976, 0.3319]]])

******************** obj31 ********************
tensor([[[1.4013e-45, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00],
[0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00],
   [2.8961e+31, 8.1836e-43, 3.3042e+33, 8.1836e-43, 1.4013e-45]],

[[0.0000e+00, 4.2039e-45, 0.0000e+00, 0.0000e+00, 0.0000e+00],
   [0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00],
   [0.0000e+00, 1.4013e-45, 0.0000e+00, 0.0000e+00, 0.0000e+00]]])

******************** obj32 ********************
tensor([1.4013e-45, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,
0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 2.8961e+31, 8.1836e-43,
3.3042e+33, 8.1836e-43, 1.4013e-45, 0.0000e+00, 4.2039e-45, 0.0000e+00,
0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,
0.0000e+00, 0.0000e+00, 1.4013e-45, 0.0000e+00, 0.0000e+00, 0.0000e+00])

******************** obj33 ********************
tensor([[1.4013e-45, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,
   0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 2.8961e+31, 8.1836e-43,
   3.3042e+33, 8.1836e-43, 1.4013e-45],
[0.0000e+00, 4.2039e-45, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,
   0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 1.4013e-45,
   0.0000e+00, 0.0000e+00, 0.0000e+00]])

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

Flying Bulldog

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
_TensorBase(45个张量基础后置函数总结) && Pytorch官方文件 && NOTEBOOK(NINE)

pytorch基础函数对神经网络的搭建和数据处理很重要，在处理数据的时候，结合torch官方定义的函数，往往能做到事半功倍。好的地基才会用摩天大厦更加稳固，知识需要沉淀。for i in range(1, 34): print("*" * 20, "obj{}".format(i), "*" * 20) # eval 把字符串转换成 “python表达式”print(eval(str("obj") + str(i)), "\n")
复制链接

扫一扫