Pytorch的Tensor基本操作(重要的容易忘的）

最新推荐文章于 2023-12-12 15:20:27 发布

深度菜鸡-达闻西

最新推荐文章于 2023-12-12 15:20:27 发布

阅读量452

点赞数

分类专栏： PyTorch

本文为博主所有，如有问题，联系本人，欢迎指正

本文链接：https://blog.csdn.net/qq_37405118/article/details/105265553

版权

PyTorch 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

参考 pytorch 中文文档

创建操作

torch.eye

torch.eye(n, m=None, out=None)
返回一个2维张量，对角线位置全1，其它位置全0

参数:

n (int ) – 行数
m (int, optional) – 列数.如果为None,则默认为n
out (Tensor, optinal) - Output tensor
返回值: 对角线位置全1，其它位置全0的2维张量

返回值类型: Tensor

例子:

>>> torch.eye(3)
 1  0  0
 0  1  0
 0  0  1
[torch.FloatTensor of size 3x3]

from_numpy

torch.from_numpy(ndarray) → Tensor
Numpy桥，将numpy.ndarray 转换为pytorch的 Tensor。返回的张量tensor和numpy的ndarray共享同一内存空间。修改一个会导致另外一个也被修改。返回的张量不能改变大小。

例子:

>>> a = numpy.array([1, 2, 3])
>>> t = torch.from_numpy(a)
>>> t
torch.LongTensor([1, 2, 3])
>>> t[0] = -1
>>> a
array([-1,  2,  3])

torch.linspace

torch.linspace(start, end, steps=100, out=None) → Tensor
返回一个1维张量，包含在区间start 和 end 上均匀间隔的steps个点。输出1维张量的长度为steps。

参数:

start (float) – 序列的起始点
end (float) – 序列的最终值
steps (int) – 在start 和 end间生成的样本数
out (Tensor, optional) – 结果张量
例子:

>>> torch.linspace(3, 10, steps=5)

  3.0000
  4.7500
  6.5000
  8.2500
 10.0000
[torch.FloatTensor of size 5]

>>> torch.linspace(-10, 10, steps=5)

-10
 -5
  0
  5
 10
[torch.FloatTensor of size 5]

>>> torch.linspace(start=-10, end=10, steps=5)

-10
 -5
  0
  5
 10
[torch.FloatTensor of size 5]

torch.ones

torch.ones(*sizes, out=None) → Tensor
返回一个全为1 的张量，形状由可变参数sizes定义。

参数:

sizes (int…) – 整数序列，定义了输出形状
out (Tensor, optional) – 结果张量例子:

>>> torch.ones(2, 3)

 1  1  1
 1  1  1
[torch.FloatTensor of size 2x3]

>>> torch.ones(5)

 1
 1
 1
 1
 1
[torch.FloatTensor of size 5]

torch.zeros

torch.zeros(*sizes, out=None) → Tensor
返回一个全为标量 0 的张量，形状由可变参数sizes 定义。

参数:

sizes (int…) – 整数序列，定义了输出形状
out (Tensor, optional) – 结果张量
例子：

>>> torch.zeros(2, 3)

 0  0  0
 0  0  0
[torch.FloatTensor of size 2x3]

>>> torch.zeros(5)

 0
 0
 0
 0
 0
[torch.FloatTensor of size 5]

torch.rand

torch.rand(*sizes, out=None) → Tensor
返回一个张量，包含了从区间[0,1)的均匀分布中抽取的一组随机数，形状由可变参数sizes 定义。

参数:

sizes (int…) – 整数序列，定义了输出形状
out (Tensor, optinal) - 结果张量例子：

>>> torch.rand(4)

 0.9193
 0.3347
 0.3232
 0.7715
[torch.FloatTensor of size 4]

>>> torch.rand(2, 3)

 0.5010  0.5140  0.0719
 0.1435  0.5636  0.0538
[torch.FloatTensor of size 2x3]

torch.randn

torch.randn(*sizes, out=None) → Tensor
返回一个张量，包含了从标准正态分布(均值为0，方差为 1，即高斯白噪声)中抽取一组随机数，形状由可变参数sizes定义。参数:

sizes (int…) – 整数序列，定义了输出形状
out (Tensor, optinal) - 结果张量
例子：

>>> torch.randn(4)

-0.1145
 0.0094
-1.1717
 0.9846
[torch.FloatTensor of size 4]

>>> torch.randn(2, 3)

 1.4339  0.3351 -1.0999
 1.5458 -0.9643 -0.3558
[torch.FloatTensor of size 2x3]

torch.arange

torch.arange(start, end, step=1, out=None) → Tensor
返回一个1维张量，长度为 floor((end−start)/step)。包含从start到end，以step为步长的一组序列值(默认步长为1)。（不包括end）

参数:
start (float) – 序列的起始点
end (float) – 序列的终止点
step (float) – 相邻点的间隔大小
out (Tensor, optional) – 结果张量
例子：

>>> torch.arange(1, 4)

 1
 2
 3
[torch.FloatTensor of size 3]

>>> torch.arange(1, 2.5, 0.5)

 1.0000
 1.5000
 2.0000
[torch.FloatTensor of size 3]

torch.range

torch.range(start, end, step=1, out=None) → Tensor
返回一个1维张量，有 floor((end−start)/step)+1 个元素。包含在半开区间[start, end）从start开始，以step为步长的一组值。 step 是两个值之间的间隔，即 xi+1=xi+step
(包含end值，和arange功能类似）
警告：建议使用函数 torch.arange()

参数:

start (float) – 序列的起始点
end (float) – 序列的最终值
step (int) – 相邻点的间隔大小
out (Tensor, optional) – 结果张量
例子：

>>> torch.range(1, 4)

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> torch.range(1, 4, 0.5)

 1.0000
 1.5000
 2.0000
 2.5000
 3.0000
 3.5000
 4.0000
[torch.FloatTensor of size 7]

拼接，连接（这点总是忘）

（dim=0 对应于行操作，也就是对列怎么样，同理，dim=1 对应于列操作，也就是对行怎么样）

torch.cat(inputs, dimension=0) → Tensor

在给定维度上对输入的张量序列seq 进行连接操作。

torch.cat()可以看做 torch.split() 和 torch.chunk()的反操作。 cat() 函数可以通过下面例子更好的理解。

参数:

inputs (sequence of Tensors) – 可以是任意相同Tensor 类型的python 序列
dimension (int, optional) – 沿着此维连接张量序列。
例子：

>>> x = torch.randn(2, 3)
>>> x

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]

>>> torch.cat((x, x, x), 0)

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 6x3]

>>> torch.cat((x, x, x), 1)

 0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x9]

torch.index_select

torch.index_select(input, dim, index, out=None) → Tensor
沿着指定维度对输入进行切片，取index中指定的相应项(index为一个LongTensor)，然后返回到一个新的张量，返回的张量与原始张量_Tensor_有相同的维度(在指定轴上)。

注意：返回的张量不与原始张量共享内存空间。

参数:

input (Tensor) – 输入张量
dim (int) – 索引的轴
index (LongTensor) – 包含索引下标的一维张量
out (Tensor, optional) – 目标张量
例子：

>>> x = torch.randn(3, 4)
>>> x

 1.2045  2.4084  0.4001  1.1372
 0.5596  1.5677  0.6219 -0.7954
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 3x4]

>>> indices = torch.LongTensor([0, 2])
>>> torch.index_select(x, 0, indices)

 1.2045  2.4084  0.4001  1.1372
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 2x4]

>>> torch.index_select(x, 1, indices)

 1.2045  0.4001
 0.5596  0.6219
 1.3635 -0.5414
[torch.FloatTensor of size 3x2]

torch.nonzero

torch.nonzero(input, out=None) → LongTensor
返回一个包含输入input中非零元素索引的张量。输出张量中的每行包含输入中非零元素的索引。

如果输入input有n维，则输出的索引张量output的形状为 z x n, 这里 z 是输入张量input中所有非零元素的个数。

参数:

input (Tensor) – 源张量
out (LongTensor, optional) – 包含索引值的结果张量
例子：

>>> torch.nonzero(torch.Tensor([1, 1, 1, 0, 1]))

 0
 1
 2
 4
[torch.LongTensor of size 4x1]

>>> torch.nonzero(torch.Tensor([[0.6, 0.0, 0.0, 0.0],
...                             [0.0, 0.4, 0.0, 0.0],
...                             [0.0, 0.0, 1.2, 0.0],
...                             [0.0, 0.0, 0.0,-0.4]]))
# 输入是两维，所以输出是两列，非零元素个数为四个，所以输出四行
 0  0
 1  1
 2  2
 3  3
[torch.LongTensor of size 4x2]

torch.squeeze

torch.squeeze(input, dim=None, out=None)
将输入张量形状中的1 去除并返回。如果输入是形如(A×1×B×1×C×1×D)，那么输出形状就为： (A×B×C×D)
当给定dim时，那么挤压操作只在给定维度上。例如，输入形状为: (A×1×B), squeeze(input, 0) 将会保持张量不变，只有用 squeeze(input, 1)，形状会变成 (A×B)。

注意：返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。

参数:

input (Tensor) – 输入张量
dim (int, optional) – 如果给定，则input只会在给定维度挤压
out (Tensor, optional) – 输出张量
例子：

>>> x = torch.zeros(2,1,2,1,2)
>>> x.size()
(2L, 1L, 2L, 1L, 2L)
>>> y = torch.squeeze(x)
>>> y.size()
(2L, 2L, 2L)
>>> y = torch.squeeze(x, 0)
>>> y.size()
(2L, 1L, 2L, 1L, 2L)
>>> y = torch.squeeze(x, 1)
>>> y.size()
(2L, 2L, 1L, 2L)

torch.unsqueeze

torch.unsqueeze(input, dim, out=None)
返回一个新的张量，对输入的制定位置插入维度 1

注意：返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。

如果dim为负，则将会被转化dim+input.dim()+1
参数:

tensor (Tensor) – 输入张量
dim (int) – 插入维度的索引
out (Tensor, optional) – 结果张量

>>> x = torch.Tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
 1  2  3  4
[torch.FloatTensor of size 1x4]
>>> torch.unsqueeze(x, 1)
 1
 2
 3
 4
[torch.FloatTensor of size 4x1]

torch.t

torch.t(input, out=None) → Tensor
输入一个矩阵（2维张量），并转置0, 1维。可以被视为函数transpose(input, 0, 1)的简写函数。

参数:

input (Tensor) – 输入张量
out (Tensor, optional) – 结果张量

>>> x = torch.randn(2, 3)
>>> x

 0.4834  0.6907  1.3417
-0.1300  0.5295  0.2321
[torch.FloatTensor of size 2x3]

>>> torch.t(x)

 0.4834 -0.1300
 0.6907  0.5295
 1.3417  0.2321
[torch.FloatTensor of size 3x2]

torch.transpose

torch.transpose(input, dim0, dim1, out=None) → Tensor
返回输入矩阵input的转置。交换维度dim0和dim1。输出张量与输入张量共享内存，所以改变其中一个会导致另外一个也被修改。

参数:

input (Tensor) – 输入张量
dim0 (int) – 转置的第一维
dim1 (int) – 转置的第二维

>>> x = torch.randn(2, 3)
>>> x

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]

>>> torch.transpose(x, 0, 1)

 0.5983  1.5981
-0.0341 -0.5265
 2.4918 -0.8735
[torch.FloatTensor of size 3x2]

torch.clamp

torch.clamp(input, min, max, out=None) → Tensor
将输入input张量每个元素的夹紧到区间 [min,max]，并返回结果到一个新张量。

操作定义如下：

  | min, if x_i < min

y_i = | x_i, if min <= x_i <= max
| max, if x_i > max
如果输入是FloatTensor or DoubleTensor类型，则参数min max 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，min， max取整数、实数皆可。】

参数：

input (Tensor) – 输入张量
min (Number) – 限制范围下限
max (Number) – 限制范围上限
out (Tensor, optional) – 输出张量
例子：

a = torch.randn(4)
a

1.3869
0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

torch.clamp(a, min=-0.5, max=0.5)

0.5000
0.3912
-0.5000
-0.5000
[torch.FloatTensor of size 4]

torch.clamp(input, *, min, out=None) → Tensor

将输入input张量每个元素的限制到不小于min ，并返回结果到一个新张量。

如果输入是FloatTensor or DoubleTensor类型，则参数 min 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，min取整数、实数皆可。】

参数：

input (Tensor) – 输入张量
value (Number) – 限制范围下限
out (Tensor, optional) – 输出张量
例子：

a = torch.randn(4)
a

1.3869
0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

torch.clamp(a, min=0.5)

1.3869
0.5000
0.5000
0.5000
[torch.FloatTensor of size 4]

torch.clamp(input, *, max, out=None) → Tensor

将输入input张量每个元素的限制到不大于max ，并返回结果到一个新张量。

如果输入是FloatTensor or DoubleTensor类型，则参数 max 必须为实数，否则须为整数。【译注：似乎并非如此，无关输入类型，max取整数、实数皆可。】

参数：

input (Tensor) – 输入张量
value (Number) – 限制范围上限
out (Tensor, optional) – 输出张量
例子：

a = torch.randn(4)
a

1.3869
0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

torch.clamp(a, max=0.5)

0.5000
0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

torch 乘法

torch.mul(x,y)

对应位置相乘，要求两个因子维度相同，结果还是因子的维度

torch.mm(x,y) or x.mm(y)

矩阵乘法，前一个因子的列等于后一个因子的行【2,4】【4，2】 == 【2,2】

import  torch

a = torch.arange(1,9).reshape(2,4)
b = torch.arange(2,10).reshape(4,2)

c = torch.mul(a,a)# 对应位置相乘，要求两个因子维度相同，结果还是因子的维度

d = torch.mm(a,b)# 矩阵乘法，前一个因子的列等于后一个因子的行  【2,4】 【4，2】 == 【2,2】
print(a.mm(b))
print(c,'\n',d)
print(c.size(),"\n",d.size())

深度菜鸡-达闻西

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Pytorch的Tensor基本操作(重要的容易忘的）

参考 pytorch 中文文档目录创建操作torch.eyefrom_numpytorch.linspacetorch.onestorch.zerostorch.randtorch.randntorch.arangetorch.range创建操作torch.eyetorch.eye(n, m=None, out=None)返回一个2维张量，对角线位置全1，其它位置全0参数:n (i...
复制链接

扫一扫