目录

注释

一.创建tensor

创建tensor的方法有:

方法 含义 code
torch.empyt(*shape,dtype) 创建空的tensor code1.1
torch.rand(*shape,dtype) 创建随机元素的tensor code1.2
torch.zeros(*shape,dtype) 创建元素全为0的tensor code1.3
torch.tensor(data) 由list创建tensor code1.4
tensor.new_ones(*shape,dtype) 创建于tensor类似的元素全为0的tensor code1.5
torch.randn_like(tensor,dtype) 创建与tensor形状,元素随机的tensor,dtype可自行指定 code1.6
torch.ones(*shape) 创建元素全为1的tensor code1.7
torch.eye(*shape) 创建对角线全部为1其他元素为0的tensor code1.8
torch.linspace(start,end,step) 创建一个一维的tensor,在[strat,end]上均匀的分为step份 code1.9
torch.rand/randn(*shape,dtype) 在[0,1) 上的均匀分布的随机数/标准正态分布(均值为0,方差为1,即高斯白噪声)中抽取一组随机数 code1.10
torch.arange(start,end,step=1) 创建一个常用于遍历的一维张量[start,end) code1.11
注:这些创建方法都可以在创建的时候指定数据类型dtype和存放device(cpu/gpu)。

引入第三方库:

import torch
1.1.1 torch.empty 创建空的Tensor
#创建一个空的形状自定义的Tensor
empty_tensor=torch.empty(7,1)
print(empty_tensor)
tensor([[4.7984e+30],
    [6.2121e+22],
    [1.8370e+25],
    [1.4603e-19],
    [6.4069e+02],
    [2.7489e+20],
    [1.5444e+25]])
1.1.2 torch.rand 创建随机Tensor
#创建一个自定义形状的随机的Tensor
rand_tensor=torch.rand(3,3)
print(rand_tensor)
tensor([[0.7131, 0.5533, 0.7585],
    [0.1066, 0.8007, 0.7148],
    [0.7409, 0.7177, 0.4105]])
1.1.3 torch.zeros 创建全零的Tensor
#创建一个自定义形状且规定数据类型全为0的Tensor
zeros_long_tensor=torch.zeros(3,3,dtype=torch.long)
print(zeros_long_tensor)
tensor([[0, 0, 0],
    [0, 0, 0],
    [0, 0, 0]])
1.1.4 torch.tensor 创建自带数据的Tensoor
#按照list直接创建tensor
self_list_data=[[1,2,3,4],[1,2,3,4]]
self_list_data_tensor=torch.tensor(self_list_data)
print(self_list_data_tensor)
tensor([[1, 2, 3, 4],
    [1, 2, 3, 4]])

注意:
torch.tensor()仅是复制数据。 如果您有一个张量数据,并且只想更改它的requires_grad标志,请使用requires_grad_()或detach()来避免复制。 如果你有一个numpy数组并且想要避免复制,可以使用torch.as_tensor()。

1.1.5 tensor.new_ones 创建元素全零的类似Tensor
#按照已有的tensor来创建一个与其类似的tensor
origin_tensor=torch.zeros(2,2,dtype=torch.long)#原生的tensor,shape为(2,2)
print(origin_tensor)
origin_tensor_new_ones=origin_tensor.new_ones(5,3,dtype=torch.float)#shape为(5,3)类型float,具有相同的torch.device
print(origin_tensor_new_ones)
tensor([[0, 0],
    [0, 0]])
tensor([[1., 1., 1.],
    [1., 1., 1.],
    [1., 1., 1.],
    [1., 1., 1.],
    [1., 1., 1.]])
1.1.6 torch.randn_like 创建元素随机的类似Tensor
new_like_tensor=torch.randn_like(origin_tensor,dtype=torch.float)#shape为(2,2)类型为float
print(new_like_tensor)
tensor([[ 1.6904,  0.8834],
    [ 0.9088, -0.3631]])
1.1.7 torch.ones 创建元素全一的Tensor
#创建元素全部为1的tensor
one_float_tensor=torch.ones(3,3,dtype=torch.float)
print(one_float_tensor)
tensor([[1., 1., 1.],
    [1., 1., 1.],
    [1., 1., 1.]])
1.1.8 torch.eye 创建对角矩阵
#创建对角线矩阵
eye_tensor=torch.eye(4,4,dtype=torch.long)
print(eye_tensor)
tensor([[1, 0, 0, 0],
    [0, 1, 0, 0],
    [0, 0, 1, 0],
    [0, 0, 0, 1]])
1.1.9 torch.linspace创建tensor
#创建一个从0到10的分割为5份的张量
one_ten_step_5=torch.linspace(0,10,5)
print(one_ten_step_5)
tensor([ 0.0000,  2.5000,  5.0000,  7.5000, 10.0000])
1.1.10 torch.rand创建0到1上的均匀分布的Tensor
#创建一个0到1上的均匀分布张量,rand函数规定的是0到1上的均匀分布
rand_one_ten=torch.rand(2,4)
print(rand_one_ten)
#创建一个标准正态分布(均值为0方差为1)的张量
randn_mean_0_std_1_tensor=torch.randn(4,4)
print(randn_mean_0_std_1_tensor)
tensor([[0.8897, 0.2605, 0.0535, 0.8882],
    [0.7278, 0.6101, 0.6233, 0.1711]])
tensor([[ 0.3915,  1.4575, -0.7884,  1.4703],
    [ 1.1029,  1.2063,  0.3582,  1.3420],
    [-1.0480, -0.4601,  1.1066, -1.4942],
    [-1.0196, -0.7050, -0.2726,  0.2510]])
1.1.11 torch.arange创建Tensor
#创建一个常用于遍历的一维张量
arange_tensor=torch.arange(1,10,1)
print(arange_tensor)
tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])

二.操作tensor

2.1 算术操作

2.1.1 直接采用运算符相加
a_tensor=torch.zeros(3,2,dtype=torch.long)
b_tensor=torch.ones(3,2,dtype=torch.float)
add_a_b_tensor=a_tensor+b_tensor
print(add_a_b_tensor)
tensor([[1., 1.],
    [1., 1.],
    [1., 1.]])
2.1.2 采用troch.add方法相加

troch.add方法的api:
torch.add(input,other,,alpha=1,out=None)Tensortorch.add(input, other, *, alpha=1, out=None) → Tensor
采用该方法,可实现:
out=input+otherout=input+other
out=input+alpha×otherout=input+alpha×other
如果input项与other项均为张量但是形状不同,则必须保证上述两项能够完成广播操作。

#将两个形状相同的张量相加
add_a_b_tensor=torch.add(a_tensor,b_tensor)
print(add_a_b_tensor)
#将一个张量与一个实数相加
add_b_1_tensor=torch.add(b_tensor,1)
print(add_b_1_tensor)
c_tensor=torch.ones(3,2,dtype=torch.float)
#将c张量乘以10加到b张量上
add_b_10_c_tensor=torch.add(b_tensor,c_tensor,alpha=10)
print(add_b_10_c_tensor)
tensor([[1., 1.],
    [1., 1.],
    [1., 1.]])
tensor([[2., 2.],
    [2., 2.],
    [2., 2.]])
tensor([[11., 11.],
    [11., 11.],
    [11., 11.]])
2.1.3 inplace操作add_()

inplace add的api
Tensor.add(other,,alpha=1)TensorTensor.add_(other, *, alpha=1) → Tensor

#对b张量进行原地add操作
b_tensor.add_(c_tensor,alpha=3)
print(b_tensor)
tensor([[4., 4.],
    [4., 4.],
    [4., 4.]])

2.2 pytorch对各个维度张量形状的表示

2.2.1 0维———标量
#0维张量的shape表示
dim_0_tensor=torch.tensor(4)
print(dim_0_tensor)
print(dim_0_tensor.shape)
tensor(4)#直接显示标量元素
torch.Size([])
2.2.2 1维———向量
#一维张量的shape表示
dim_1_tensor=torch.tensor([1,2,3])
print(dim_1_tensor)
print(dim_1_tensor.shape)
tensor([1, 2, 3])
torch.Size([3])
2.2.3 2维———矩阵
#二维张量的shape表示
dim_2_tensor=torch.tensor([[1,2,3],[1,2,3]])
print(dim_2_tensor)
print(dim_2_tensor.shape)
tensor([[1, 2, 3],
    [1, 2, 3]])
torch.Size([2, 3])
2.2.4 3维———三维张量
#三维张量的shape表示
dim_3_tensor=torch.tensor([[[1,1,1],[1,1,1]],
                            [[2,2,2],[2,2,2]]])
print(dim_3_tensor)
print(dim_3_tensor.shape)
tensor([[[1, 1, 1],
     [1, 1, 1]],

    [[2, 2, 2],
     [2, 2, 2]]])
torch.Size([2, 2, 3])
2.2.5 4维———四维张量
#四维张量的shape表示
dim_4_tensor=torch.tensor([[[[1,1,1],[1,1,1],[1,1,1]]],
                            [[[2,2,2],[2,2,2],[2,2,2]]]])
print(dim_4_tensor)
print(dim_4_tensor.shape)
tensor([[[[1, 1, 1],
      [1, 1, 1],
      [1, 1, 1]]],


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

2.3 维度

tensorMap
图1.PyTorch中的张量示意图

对于0维与1维的张量讨论维度的意义不大,或者可以将维度简单的理解为一个固定方向上为0的索引,对于二维张量也就是矩阵,维度有两个一个是0维度一个是1维度,0维度是行方向,1维度是列方向;对于三维张量以及三维以上张量维度的操作需要结合张量的shape进行理解。

2.3.1 二维张量的维度操作以求和(sum)为例

torch求和函数api
torch.sum(input,dim,keepdim=False,,dtype=None)Tensortorch.sum(input, dim, keepdim=False, *, dtype=None) → Tensor

创建一个二维张量

#张量维度测试
import torch

#创建一个二维张量
two_dim_tensor=torch.tensor([[1,1],[2,2],[3,3]])
print(two_dim_tensor.shape)
print(two_dim_tensor)
torch.Size([3, 2])
tensor([[1, 1],
    [2, 2],
    [3, 3]])

在0维度(行方向)上进行求和:

two_dim_tensor_sum_dim_0=torch.sum(two_dim_tensor,0)
print(two_dim_tensor_sum_dim_0)
print(two_dim_tensor_sum_dim_0.shape)
tensor([6, 6])
torch.Size([2])

在1维度(列方向)上进行求和:

#二维度张量在1维度上的求和
two_dim_tensor_sum_dim_1=torch.sum(two_dim_tensor,1)
print(two_dim_tensor_sum_dim_1)
print(two_dim_tensor_sum_dim_1.shape)
tensor([2, 4, 6])
torch.Size([3])
2.3.2 三维张量的维度操作以求和(sum)为例

首先来看这张图,读懂这张图三维张量的维度操作就一目了然了

tensor_dim_3_show
图2.一个三维张量分析图

创建图2中的三维张量

#创建一个三维张量
three_dim_tensor=torch.tensor(
    [
        [
            [1,1,1],
            [2,2,2]
        ],
        [
            [3,3,3],
            [4,4,4]
        ]
    ]
)
print(three_dim_tensor)
print(three_dim_tensor.shape)
tensor([[[1, 1, 1],
     [2, 2, 2]],

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

在0维度进行求和

#对三维张量进行0维度求和
three_dim_tensor_sum_dim_0=torch.sum(three_dim_tensor,0)
print(three_dim_tensor_sum_dim_0)
print(three_dim_tensor_sum_dim_0.shape)
tensor([[4, 4, 4],
    [6, 6, 6]])
torch.Size([2, 3])

在图2中,dim=0表示的是shape(2,2,3)中的第一个2,那么在0维度上的求和就是将[[1,1,1],[2,2,2]]与[[3,3,3],[4,4,4]]进行对位相加求和,得到的就是[[4,4,4],[6,6,6]]。

在1维度上进行求和

three_dim_tensor_sum_dim_1=torch.sum(three_dim_tensor,1)
print(three_dim_tensor_sum_dim_1)
print(three_dim_tensor_sum_dim_1.shape)
tensor([[3, 3, 3],
    [7, 7, 7]])
torch.Size([2, 3])

在图2中,dim=1表示的是shape(2,2,3)中的第二个2,那么在1维度上的求和就是将[[1,1,1],[2,2,2]]中的两个张量进行对位相加求和得到[3,3,3],同理[[3,3,3],[4,4,4]]也是一样的操作得到结果为[7,7,7],最终的结果为[[3,3,3],[7,7,7]]。

在2维度上进行求和

three_dim_tensor_sum_dim_2=torch.sum(three_dim_tensor,2)
print(three_dim_tensor_sum_dim_2)
print(three_dim_tensor_sum_dim_2.shape)
tensor([[ 3,  6],
    [ 9, 12]])
torch.Size([2, 2])

在图2中,dim=2是表示shape(2,2,3)中的3,那么在2维度上的求和就是单独地将[1,1,1]、[2,2,2]、[3,3,3]、[4,4,4]中的三个元素相加求和,最终结果就是[[3,6],[9,12]]。

2.3.3 四维张量的维度操作以求和(sum)为例

tensor_dim_4_show
图2.一个三维张量分析图

#创建一个形状为(2,1,2,3)的四维张量
four_dim_tensor=torch.tensor([[[[1,1],[2,2],[3,3]]],[[[4,4],[5,5],[6,6]]]])
print(four_dim_tensor)
print(four_dim_tensor.shape)
tensor([[[[[1, 1],
       [2, 2],
       [3, 3]]]],



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

在0维度进行求和

#四维张量在0维度上的求和
four_dim_tensor_sum_dim_0=torch.sum(four_dim_tensor,0)
print(four_dim_tensor_sum_dim_0)
print(four_dim_tensor_sum_dim_0.shape)
tensor([[[5, 5],
     [7, 7],
     [9, 9]]])
torch.Size([1, 3, 2])

在1维度进行求和

#四维张量在1维度上的求和
four_dim_tensor_sum_dim_1=torch.sum(four_dim_tensor,1)
print(four_dim_tensor_sum_dim_1)
print(four_dim_tensor_sum_dim_1.shape)
tensor([[[1, 1],
     [2, 2],
     [3, 3]],

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

在2维度进行求和

#四维张量在2维度上的求和
four_dim_tensor_sum_dim_2=torch.sum(four_dim_tensor,2)
print(four_dim_tensor_sum_dim_2)
print(four_dim_tensor_sum_dim_2.shape)
tensor([[[ 6,  6]],

    [[15, 15]]])
torch.Size([2, 1, 2])

在3维度进行求和

#四维张量在3维度上的求和
four_dim_tensor_sum_dim_3=torch.sum(four_dim_tensor,3)
print(four_dim_tensor_sum_dim_3)
print(four_dim_tensor_sum_dim_3.shape)
tensor([[[ 2,  4,  6]],

    [[ 8, 10, 12]]])
torch.Size([2, 1, 3])

如果我们在求和的时候不设定维度的话,会出现什么情况呢?

#四维张量不指定维度的求和
four_dim_tensor_sum_dim_none=torch.sum(four_dim_tensor)
print(four_dim_tensor_sum_dim_none)
print(four_dim_tensor_sum_dim_none.shape)
tensor(42)
torch.Size([])

我们发现在不指定张量的情况下他是直接对整个张量所有的元素进行求和的。

2.4 索引

在了解完了维度这个概念,索引就很简单了

我们可以通过索引的方式来获取一个张量的部分内容,但是获取到的部分内容与原始内容共享内存,而不是view模式,修改索引出来的结果也会修改原始张量的内容。

#索引
x_tensor=torch.ones(3,3,dtype=torch.long)
print(x_tensor)
x_index_tensor=x_tensor[1,:]
x_index_tensor.add_(1,alpha=2)
print(x_index_tensor)
print(x_tensor)
tensor([[1, 1, 1],
    [1, 1, 1],
    [1, 1, 1]])
tensor([3, 3, 3])
tensor([[1, 1, 1],
    [3, 3, 3],
    [1, 1, 1]])

其他几种索引方式:

torch.index_select方法

index_select方法在指定的维度上选取行与列

返回的张量不使用与原始张量相同的存储空间。 如果out的形状与预期的不同,则静默地将其更改为正确的形状,并在必要时重新分配底层存储。

2.5 形状操作

2.6 线性代数运算