『PyTorch』Tensor

最新推荐文章于 2021-05-14 14:05:18 发布
最新推荐文章于 2021-05-14 14:05:18 发布
阅读量907 收藏 1
点赞数 2
分类专栏： PyTorch 文章标签： pytorch 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreaming_coder/article/details/104349710
版权

文章目录

1. 张量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Joq48dEn-1581861175874)(E:\我的学习\pytorch\Tensor\fig1.png)]

2. Variable类型(PyTorch 0.4之前)

Variable是torch.autograd中的数据类型，主要用于封装Tensor，进行自动求导

  • data
    被包装的张量
  • grad
    data的梯度
  • grad_fn
    创建Tensor的function，是自动求导的关键
  • requires_grad
    指示是否需要梯度，True表示需要计算梯度，False表示不需要计算梯度
  • is_leaf
    指示是否是叶子结点(张量)

3. Tensor类型(PyTorch 0.4之后)

​ Variable从PyTorch 0.4之后开始并入Tensor，多了3个主要属性

  • dtype·
    张量的数据类型，如torch.FloatTensor，torch.cuda.FloatTensor
  • shape
    张量的形状，类似NumPy数组的shape
  • device
    张量所在设备，GPU/CPU，是加速的关键

4. 创建Tensor

4.1 直接创建

4.1.1 torch.tensor()

  • 函数
torch.tensor(data, dtype=None, device=None,requires_grad=False, pin_memory=False)

  • 功能
    从data创建Tensor

  • 参数

    • data：数据，可以是list，numpy的ndarray
    • dtype：数据类型，默认与data一致
    • device：所在设备，GPU/CPU
    • requires_grad：是否需要计算梯度
    • pin_memory：是否存于锁业内存，通常就是False，与转换效率有关
import torch
import numpy as np

# 通过torch.tensor()创建张量

ary = np.ones((3,3))
print(f"ndarray的数据类型：{ary.dtype}")

t = torch.tensor(ary)
print(t)

s = torch.tensor(ary,device="cuda")
print(s)

输出结果：

ndarray的数据类型：float64
tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]], dtype=torch.float64)
tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]], device=‘cuda:0’, dtype=torch.float64)

4.1.2 torch.from_numpy()

  • 函数
torch.from_numpy(ndarray)
  • 功能
    从NumPy创建Tensor

从torch.from_numpy创建的Tensor与原ndarray共享内存，当修改其中一个数据，另一个也将会被改动

import torch
import numpy as np

# 通过torch.from_numpy()创建张量
ary = np.random.randint(0, 20, size=9).reshape(3, 3)

t = torch.from_numpy(ary)

print(f"ndarray的数据类型为：{ary.dtype}")
print(t)

输出结果：

ndarray的数据类型为：int32
tensor([[13, 17, 3],
            [18, 11, 1],
            [17,  8,  4]], dtype=torch.int32)

4.2 依据数值创建

4.2.1 torch.zeros()

  • 函数
torch.zeros(*size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)
  • 功能
    根据size创建全0张量
  • 参数
    • size：张量的形状
    • out：输出的张量
    • layout：内存中布局形式，有strided，sparse_coo等，一般默认值
import torch
import numpy as np

# 通过torch.zeros()创建全0张量

out_t = torch.tensor([1])

t = torch.zeros((3,3),out=out_t)

print(t)
print(out_t)
print(id(t)==id(out_t))

输出结果：

tensor([[0, 0, 0],
            [0, 0, 0],
            [0, 0, 0]])

tensor([[0, 0, 0],
            [0, 0, 0],
            [0, 0, 0]])
True

4.2.2 torch.zeros_like()

  • 函数
torch.zeros_like(input,dtype=None,layout=None,device=None,requires_grad=False)
  • 功能
    根据input的形状创建全0张量
  • 参数
    • input：张量，创建的全0张量形状与此一致

4.2.3 torch.ones()

参考torch.zeros()

4.2.4 torch.ones_like()

参考torch.zeros_like()

4.2.5 torch.full()

  • 函数
torch.full(size,fill_value,out=None,dtype=None,
           layout=torch.strided,device=None,requires_grad=False)
  • 功能
    根据fill_value的值创建shape为size的张量

4.2.6 torch.full_like()

方法类似

4.2.7 torch.arrange()

  • 函数
torch.arange(end, *, out=None, dtype=None, device:=None, requires_grad=False)

torch.arange(start, end, *, out=None, dtype=None, device=None, requires_grad=False)

torch.arange(start, end, step, *, out=None, dtype=None, device=None, requires_grad=False)
  • 功能
    创建等差的一维张量

注意区间为 [ s t a r t , e n d ) [start, end) [start,end)

4.2.8 torch.linspace()

  • 函数
torch.linspace(start, end, steps=100, *, out=None, dtype=None, 
               layout=strided, device: =None, requires_grad=False)
  • 功能
    创建均分的一维张量，数值区间为 [ s t a r t , e n d ] [start, end] [start,end]，steps是该张量元素个数，步长要自己算

4.2.9 torch.logspace()

  • 函数
torch.logspace(start, end, steps=100, base=10.0, *, out=None, 
               dtype=None, layout=strided, device=None, requires_grad=False)
  • 功能
    创建对数均分的一维张量，数值区间为 [ b a s e s t a r t , b a s e e n d ] \displaystyle\Big[{base}^{start}, {base}^{end}\Big] [basestart,baseend]，steps是该张量元素个数，步长要自己算
import torch

t = torch.logspace(2, 6, 5, base=2)
print(t)

输出结果：

tensor([ 4., 8., 16., 32., 64.])

从这可以看出，是把 [ s t a r t , e n d ] [start, end] [start,end] 进行等分，得到指数序列 L，然后，输出的Tensor每个元素是 b a s e L [ i ] {base}^{L[i]} baseL[i]

4.2.10 torch.eye()

  • 函数
torch.eye(n, m, *, out=None, dtype=None, layout=strided, device=None, requires_grad=False) 

torch.eye(n, *, out=None, dtype=None, layout=strided, device=None, requires_grad=False)
  • 功能
    创建单位矩阵(二维张量)，默认方阵
import torch

t = torch.eye(4)
print(t)

s = torch.eye(3, 4)
print(s)

输出结果：

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

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

4.3 依据概率分布创建

4.3.1 torch.normal()

  • 均值和标准差都是标量

    • 函数

      torch.normal(mean, std, size, *, generator=None, out=None, 
             dtype=None, layout=strided, device=None, requires_grad=False)

    • 功能
      根据均值mean，标准差std采样，返回的张量shape为size

      t_normal = torch.normal(0, 1., size=(2,3))

print(t_normal)

      输出结果：

      tensor([[ 0.4256, -0.6451, -0.2785],
                  [-0.7766, -1.0419, -0.0259]])

  • 均值和标准差都是张量

    • 函数

      torch.normal(mean, std, *, generator=None, out=None)

    • 功能
      返回张量，mean和std的shape必须一致，且返回结果的shape和mean以及std的shape一致，返回结果对应位置的元素值，是根据mean和std的对应位置的值作为均值和标准差采样的

      mean = torch.arange(1, 5, dtype=torch.float)
std = torch.arange(1, 5, dtype=torch.float)
t_normal = torch.normal(mean, std)
print(f"mean：{mean}")
print(f"std：{std}")
print(t_normal)

      输出结果：

      mean：tensor([1., 2., 3., 4.])
      std：tensor([1., 2., 3., 4.])
      tensor([1.6039, 3.3902, 5.8297, 1.5644])

  • 均值和标准差有一个是张量
    标量会做broadcast处理，参考都是张量的情况

4.3.2 torch.randn()

  • 函数

    torch.rand(size, *, generator=None, out=None, 
             dtype=None, layout=strided, device=None, requires_grad=False)

  • 功能
    从 [ 0 , 1 ) [0, 1) [0,1)均匀分布中采样，返回shape为size的张量

    torch.rand_like()参考前面类似的like函数

4.3.3 torch.randint()

  • 函数

    torch.randint(low, high, size, *, generator=None, out=None, 
             dtype=None, layout=strided, device=None, requires_grad=False)

torch.randint(high, size, *, generator=None, out=None, 
             dtype=None, layout=strided, device=None, requires_grad=False)

  • 功能
    从 [ l o w , h i g h ) [low, high) [low,high)均匀分布中采样，返回shape为size的张量，第二种定义从 [ 0 , h i g h ) [0,high) [0,high)均匀分布采样

    torch.randint_like()参考前面类似的like函数

4.3.4 torch.randperm()

  • 函数

    torch.randperm(n, *, generator, out=None, dtype=None, 
               layout=strided, device=None, requires_grad=False)

  • 功能
    生成从 0 0 0 到 n − 1 n-1 n−1 的随机排列

4.3.5 torch.bernoulli()

  • 函数

    torch.bernoulli(p, *, generator=None, out=None)

  • 功能
    以 p p p 为概率，生成伯努利分布( 0 − 1 0-1 0−1分布，两点分布)

5. 张量的常用操作

有些方法是可以直接用Tensor对象.方法的

5.1 张量的拼接与切分

5.1.1 torch.cat()

  • 函数

    torch.cat(tensors, dim=0, *, out)

  • 功能
    将张量按照指定维度拼接

    import torch

t = torch.ones(2, 3)

t_0 = torch.cat([t, t], dim=0)
t_1 = torch.cat([t, t], dim=1)
t_2 = torch.cat([t, t, t], dim=1)

print(t)
print(t_0)
print(t_1)
print(t_2)

    输出结果：

    tensor([[1., 1., 1.],
                [1., 1., 1.]])

    tensor([[1., 1., 1.],
                [1., 1., 1.],
                [1., 1., 1.],
                [1., 1., 1.]])

    tensor([[1., 1., 1., 1., 1., 1.],
                [1., 1., 1., 1., 1., 1.]])

    tensor([[1., 1., 1., 1., 1., 1., 1., 1., 1.],
                [1., 1., 1., 1., 1., 1., 1., 1., 1.]])

5.1.2 torch.stack()

  • 函数

    torch.stack(tensors, dim=0, *, out=None)

  • 功能
    在新创建的维度dim上进行拼接，用到时先实验一下，别想当然，记不住的

    import torch

t = torch.ones(2, 3)

t_stack_0 = torch.stack([t, t, t, t], dim=0)
t_stack_1 = torch.stack([t, t, t, t], dim=1)
t_stack_2 = torch.stack([t, t, t, t], dim=2)

print(f"t 的shape：{t.shape}")
print(f"t_stack_0的shape：{t_stack_0.shape}")
print(f"t_stack_1的shape：{t_stack_1.shape}")
print(f"t_stack_2的shape：{t_stack_2.shape}")

    输出结果：

    t 的shape：torch.Size([2, 3])
    t_stack_0的shape：torch.Size([4, 2, 3])
    t_stack_1的shape：torch.Size([2, 4, 3])
    t_stack_2的shape：torch.Size([2, 3, 4])

5.1.3 torch.chunk()

  • 函数

    torch.chunk(chunks, dim=0)

  • 功能
    将张量按维度dim进行平均切分，返回张量列表
    【注意】若不能整除，最后一个张量小于其他张量

    import torch

t = torch.ones(2, 7)

tensors = torch.chunk(t, dim=1, chunks=3)

for index, tensor in enumerate(tensors):
    print(f"第{index + 1}个张量：{tensor}，shape is {tensor.shape}")

    输出结果：

    第1个张量: tensor([[1., 1., 1.],
                                  [1., 1., 1.]])，shape is torch.Size([2, 3])

    第2个张量: tensor([[1., 1., 1.],
                                   [1., 1., 1.]])，shape is torch.Size([2, 3])

    第3个张量: tensor([[1.],
                                  [1.]])，shape is torch.Size([2, 1])

5.1.4 torch.split()

  • 函数

    torch.split(tensor, split_size_or_sections, dim=0)

  • 功能
    将张量按维度dim进行切分，返回张量列表

  • 参数

    • split_size_or_sections
      • int时，表示每一份的长度
      • list时，按list元素大小切分（元素和要和切割的维度上元素数一致）
    import torch

t = torch.ones(2, 5)

tensors = torch.split(t, 3, dim=1)
tensors1 = torch.split(t, [2, 1, 2], dim=1)

for index, tensor in enumerate(tensors):
    print(f"第{index + 1}个张量：{tensor}，shape is {tensor.shape}")

for index, tensor in enumerate(tensors1):
    print(f"第{index + 1}个张量：{tensor}，shape is {tensor.shape}")

    输出结果：

    第1个张量: tensor([[1., 1., 1.],
                                   [1., 1., 1.]])，shape is torch.Size([2, 3])

    第2个张量: tensor([[1., 1.],
                                   [1., 1.]])，shape is torch.Size([2, 2])

    第1个张量: tensor([[1., 1.],
                                   [1., 1.]])，shape is torch.Size([2, 2])

    第2个张量: tensor([[1.],
                                   [1.]])，shape is torch.Size([2, 1])

    第3个张量: tensor([[1., 1.],
                                   [1., 1.]])，shape is torch.Size([2, 2])

5.2 张量的索引

5.2.1 torch.index_select()

  • 函数

    torch.index_select(tensor, dim, index, *, out=None)

  • 功能
    在维度dim上，按照index索引数据，返回搜索结果拼接而成的张量
    【注意】index必须是long类型的一维Tensor

    import torch

t = torch.randint(0, 9, size=(3, 3))
idx = torch.tensor([0, 2], dtype=torch.long)  # 作为索引，这里必须是long
t_select = torch.index_select(t, dim=1, index=idx)

print(t)
print(t_select)

    输出结果：

    tensor([[4, 7, 2],
                [7, 3, 7],
                [7, 5, 7]])
    tensor([[4, 2],
                [7, 7],
                [7, 7]])

5.2.2 torch.mask_select()

  • 函数

    torch.masked_select(tensor, mask, *, out=None)

  • 功能
    按mask中的True进行索引，返回一维张量

    import torch

t = torch.randint(0, 9, size=(3, 3))
mask = t.ge(5)  # ge:>= , gt:> ,  le  ,  lt
t_select = torch.masked_select(t, mask)


print(t)
print(mask)
print(t_select)

    输出结果：

    tensor([[0, 4, 8],
                [2, 7, 5],
                [6, 7, 6]])

    tensor([[False, False, True],
                 [False, True, True],
                 [ True, True, True]])

    tensor([8, 7, 5, 6, 7, 6])

5.3 张量变换

5.3.1 torch.reshape()

  • 函数

    torch.masked_select(tensor, mask, *, out=None)

  • 功能
    重塑形状，但是元素个数要对的上

    import torch

t = torch.randint(0, 9, size=(3, 3))

print(t)

t = t.reshape(1, -1)
s = torch.reshape(t, (1, -1))

print(t)
print(s)

    输出结果：

    tensor([[3, 4, 8],
                [7, 8, 1],
                [1, 3, 0]])
    tensor([[3, 4, 8, 7, 8, 1, 1, 3, 0]])
    tensor([[3, 4, 8, 7, 8, 1, 1, 3, 0]])

  • 注意——内存共享

    import torch

t = torch.randint(0, 9, size=(3, 3))

print(t)

s = t.reshape(1, -1)
s[0][2] = 100  # 内存共享，更改它也会影响原Tensor

print(s)
print(t)

    输出结果：

    tensor([[5, 3, 7],
                [0, 4, 5],
                [3, 0, 7]])

    tensor([[ 5, 3, 100, 0, 4, 5, 3, 0, 7]])

    tensor([[ 5, 3, 100],
                [ 0, 4,     5],
                [ 3, 0,     7]])

5.3.2 torch.transpose()

  • 函数

    torch.transpose(dim0, dim1)

  • 功能
    交换两个维度，比如一般卷积神经网络输入channel×height×width，交换0和1维，然后交换1和2维，得到height×width×channel

    import torch

t = torch.randint(0, 24, size=(2, 3, 4))

print(t.shape)

s = t.transpose(0, 2)

print(s.shape)

    输出结果：

    torch.Size([2, 3, 4])
    torch.Size([4, 3, 2])

5.3.3 torch.t()

  • 功能：转置二维张量

5.3.4 torch.squeeze()

  • 功能

    压缩长度为1的轴

    • 不输入参数，则移除所有长度为1的维度
    • 若指定维度，则当且仅当该维度长度为1时，可以删除该维度

5.3.5 torch.unsqueeze()

  • 功能
    扩充张量维度

    import torch

t = torch.ones(2, 3, 4)

print(t.shape)

s = t.unsqueeze(2)
p = t.unsqueeze(0)
print(s.shape)
print(p.shape)

    输出结果：

    torch.Size([2, 3, 4])
    torch.Size([2, 3, 1, 4])
    torch.Size([1, 2, 3, 4])

6. 张量的数学运算

需要用到时查询使用

ツぃ☆ve芜情
关注
专栏目录
Pytorch Tensor的索引与切片例子
09-18
PyTorch中的Tensor是深度学习中非常重要的数据结构，它提供了高效的数据操作和计算功能。在本篇中，我们将深入探讨PyTorch Tensor的索引与切片操作，这对于理解和处理Tensor数据至关重要。 1. PyTorch风格的索引： ...
Python基础及函数解读(深度学习)
m0_67357141的博客
02-09 551
该语句是python2的概念，那么python3对于python2就是future了，也就是说，在python2的环境下，超前使用python3的。利用命令“import numpy as np”将numpy库取别名为“np”将上一层的输出作为下一层的输入，并计算下一层的输出，一直到运算到输出层为止。softplus的数学表达式以及与Relu的函数对比，相当于Relu的平滑。（2）在代码后面加注释：和代码相距两个空格， # 后面再跟一个空格。（1）在代码上面加注释： # 后面跟一个空格。
python中enumerate函数
weixin_47156261的博客
05-14 1131
enumerate函数将一个可以遍历对象（如数组、列表、元组、张量）组合为一个索引序列，同时列出数据索引和数据，在for循环中经常使用。 enumerate(iterator,n),n代表起始索引号为多少，从0开始或者从1开始等等，即索引起始位置。 代码示例： import torch #list names=['a','b','c','d'] print("列表：",list(enumerate(names))) print("列表索引从1开始：",list(enumerate(names,1))) #t
python中的enumerate函数
浮生若梦
06-17 483
array=[1,2,3,4,5] fori, einenumerate(array,0): printi, e #0 1 #1 2 #2 3 #3 4 #4 5 　　 1 2 3 4 5 6 7 f...
python中的enumerate()函数
菜鸟更要努力呀
07-11 8086
1 enumerate()简介及语法： enumerate()是Python中的内置函数，用于可迭代/可遍历的的数据对象组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中。 enumerate()语法： enumerate(sequence,[start=0]) 参数： sequence：一个序列、迭代器或其他支持迭代对象。 start：下标起始位置。 enumera...
Python的enumerate()的坑
luoying_1993的专栏
08-30 4226
其实enumerate()函数本身没啥问题，通常使用方法如下： 然而我踩的坑是这样的，最近项目中使用TensorFlow，生成TFRecord数据集，训练完成后在测试集上测试，发现预期能分的好的类别分的不好，而预期分的糟糕的类别竟然precision很高。可是对于label对应我还是非常坚定的认为不会出错。 最终，还是好好检查了一下生成数据集的代码，没想到测试下面的代码时，竟然结果出乎意料...
Pytorch Tensor 输出为txt和mat格式方式
09-18
其中的Tensor是Pytorch中的核心数据结构，它用于存储多维数组，类似于numpy中的ndarray。Tensor不仅可以用于进行高效的数值计算，还可以轻松地将数据导出为其他格式，以便与其他系统或应用程序进行交互。在一些场景...
Pytorch Tensor基本数学运算详解
09-18
在PyTorch中，Tensor是核心数据结构，用于存储和计算。本文将深入探讨PyTorch Tensor的基本数学运算，这些运算对于构建深度学习模型至关重要。 首先，我们来看加法运算。在PyTorch中，我们可以直接使用`+`运算符...
详解pytorch tensor和ndarray转换相关总结
12-17
在使用pytorch的时候，经常会涉及到两种数据格式tensor和ndarray之间的转换，这里总结一下两种格式的转换： 1. tensor cpu 和tensor gpu之间的转化： tensor cpu 转为tensor gpu： tensor_gpu = tensor_cpu.cuda() ...
python enumerate用法总结
热门推荐
竹聿Simon的专栏
06-12 44万+
enumerate()说明 enumerate()是python的内置函数 enumerate在字典上是枚举、列举的意思 对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值 enumerate多用于在for循环中得到计数 例如对于一个seq，得到：(0, seq[0]), (1, seq[1]), (2, seq[
如何将tensor的内容输出到文本文件
weixin_34290631的博客
01-17 7505
    local part2 = self.convModel:forward({linputs, rinputs}) local length = part2:size(1) local file = io.open('/home/xbwang/Desktop/part2original','a') for j = 1,length do number = part2...
pytorch之dataloader，enumerate
剪烛西窗的博客
04-11 1万+
pytorch之dataloader，enumerate from torch.utils.data import TensorDataset import torch from torch.utils.data import DataLoader a = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 2, 3], [4, 5, 6], [7, 8,
pytorch中tensor数据和numpy数据转换中注意的一个问题
nihate的专栏
09-20 1万+
在pytorch中，把numpy.array数据转换到张量tensor数据的常用函数是torch.from_numpy(array)或者torch.Tensor(array)，第一种函数更常用，然而在pytorch0.4中已经舍弃了这种函数，下面一个简单的编程实验说明这两种方法的区别，实验在pytorch0.4框架下进行 运行程序之后，结果是 可以看出修改数组a的元素值，张量b的元素值...
pytorch之tensor矩阵输出省略问题
tyler的博客
03-29 8785
import torch from transformers import BertConfig, BertModel, BertTokenizer if __name__ == '__main__': tokenizer = BertTokenizer.from_pretrained('./bert-base-uncased') model_config = BertConf...
pytorch基础知识-tensor的操作
qq_27860199的博客
01-16 345
张量的操作 拼接 #将张量按维度dim进行拼接 #torch.cat(tensors, dim=0, out=None) t = torch.ones((2,3)) t_0 = torch.cat([t,t],dim=0) t_1 = torch.cat([t,t],dim=1) print("t_0:{}shape:{}\nt_1:{}shape:{}\n".format(t_0,t_0.s...
『PyTorch』安装教程
七秒钟的记忆
02-14 4305
PyTorch第一步——安装
当Pytorch遇上tqdm
七秒钟的记忆
01-31 2741
Pytorch训练时，进度条的显示
pytorch tensor切片
最新发布
07-15
PyTorch中的tensor切片是指从一个tensor中选择特定的元素或子集。切片操作可以通过索引或范围来指定。下面是关于PyTorch tensor切片的一些重要信息： 1.基本切片操作：您可以使用索引操作符[]来对tensor进行切片。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值