【深度学习】PyTorch张量Tensor的一些必备操作

张量是什么？

• 标量：0维张量；比如一个单独的数字1

• 向量：1维张量；比如一组排列好的数：1,2,3,4,5,6

• 矩阵：2为张量；比如一个灰度图矩阵

• 3维张量；比如一个彩色图RGB

• n维张量

张量是一个多维数组，它是标量、向量、矩阵的高维扩展

Variable是PyTorch0.4.0之前的内容，现在并入Tensor了！

Variable是torch.autograd中的数据类型，后来并入了Tensor，主要目的是为了封装求导

五个属性：

• data：被包装的Tensor

• grad：data的梯度

• grad_fn：创建Tensor的Func，记录比如操作加法还是乘法

• requires_grad：是否需要求梯度

• is_leaf：是否是叶子结点（张量）

后来Variable就并入了Tensor中

现在是8个属性：

• dtype：张量的数据类型，如torch.FloatTensor，torch.cuda.FloatTensor

• shape：张量的形状

• device：张量所在的设备，GPU还是CPU

那么张量有哪些必备的创建方法值得学习？

这些代码王博Kings都一个一个敲打注释的，可以直接运行

import numpy as np
import torch

通过torch.tensor创建张量

arr = np.ones((3,3))
    print("由np.ones生成的数据：\n",arr)
    print("ndarray的数据类型：",arr.dtype,"\n")


    #t = torch.tensor(arr, device='cuda')
    t = torch.tensor(arr)


    print("torch.tensor创建好的Tensor：\n",t)

输出结果：

由np.ones生成的数据：
 [[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
ndarray的数据类型：float64 


torch.tensor创建好的Tensor：
 tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)


Process finished with exit code 0

通过torch.from_numpy创建张量   

arr = np.array([[1,2,3],[4,5,6]])
    print("由np.array生成的数据：\n",arr)
    t = torch.from_numpy(arr)
    print("torch.from_numpy创建好的Tensor：\n",t)


    # 由from_numpy创建的Tensor是共享内存空间
    # 修改numpy中的一个数字，看看tensor有没有变化
    print("\n=======================\n修改arr")
    arr[0,0]=9
    print("由np.array生成的数据：\n",arr)
    t = torch.from_numpy(arr)
    print("torch.from_numpy创建好的Tensor：\n",t)


    # 由from_numpy创建的Tensor是共享内存空间
    # 修改tensor中的一个数字，看看numpy有没有变化
    print("\n=======================\n修改t")
    t[0,0]=-9
    print("由np.array生成的数据：\n",arr)
    t = torch.from_numpy(arr)
    print("torch.from_numpy创建好的Tensor：\n",t)

运行结果

由np.array生成的数据：
 [[1 2 3]
 [4 5 6]]
torch.from_numpy创建好的Tensor：
 tensor([[1, 2, 3],
        [4, 5, 6]], dtype=torch.int32)


=======================
修改arr
由np.array生成的数据：
 [[9 2 3]
 [4 5 6]]
torch.from_numpy创建好的Tensor：
 tensor([[9, 2, 3],
        [4, 5, 6]], dtype=torch.int32)


=======================
修改t
由np.array生成的数据：
 [[-9  2  3]
 [ 4  5  6]]
torch.from_numpy创建好的Tensor：
 tensor([[-9,  2,  3],
        [ 4,  5,  6]], dtype=torch.int32)


Process finished with exit code 0

通过torch.zeros创建张量

out_t = torch.tensor(([1]))


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


    print("t的值：\n",t,"\n out_t的值\n",out_t)
    print("看一下t和out_t的id位置号\n",id(t),"\n",id(out_t))

输出结果

t的值：
 tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]]) 
 out_t的值
 tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]])
看一下t和out_t的id位置号
 1819528746952 
 1819528746952


Process finished with exit code 0

通过torch.full创建全相同的张量  

t = torch.full((3,3),10)
    print("torch.full((3,3),10)的输出结果\n",t)

输出结果

torch.full((3,3),10)的输出结果
 tensor([[10., 10., 10.],
        [10., 10., 10.],
        [10., 10., 10.]])

通过torch.arange创建等差数列张量  

t = torch.arange(2,10,2)
    print("torch.arange(2,10,2)的输出结果\n",t)

输出结果

torch.arange(2,10,2)的输出结果
 tensor([2, 4, 6, 8])

通过torch.linspace创建均分数列 张量

步长=（Start - end）/（Steps - 1）

t = torch.linspace(2,10,5)
    print("torch.linspace(2,10,5)的输出结果\n",t)
    t = torch.linspace(2,10,6)
    print("torch.linspace(2,10,6)的输出结果\n",t)

输出结果

torch.linspace(2,10,5)的输出结果
 tensor([ 2.,  4.,  6.,  8., 10.])
torch.linspace(2,10,6)的输出结果
 tensor([ 2.0000,  3.6000,  5.2000,  6.8000,  8.4000, 10.0000])

通过torch.eye创建单位对角矩阵  

t = torch.eye(3)
    print("torch.eye(3)的输出结果\n",t)

输出结果

torch.eye(3)的输出结果
 tensor([[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]])

通过torch.normal()创建概率分布的张量   

# mean：张量 std: 张量
    print("-----------mean：张量 std: 张量---------")
    mean = torch.arange(1, 5, dtype=torch.float)
    std = torch.arange(1, 5, dtype=torch.float)
    print("mean是：",mean,"\n std是：",std)
    t_normal = torch.normal(mean, std)
    print("t_normal是\n",t_normal)


    # mean：标量 std: 标量
    print("-----------mean：标量 std: 标量---------")
    t_normal = torch.normal(0., 1., size=(5,))
    print("torch.normal(0., 1., size=5,))输出\n",t_normal)


    # mean：张量 std: 标量
    print("-----------mean：张量 std: 标量---------")
    mean = torch.arange(1, 5, dtype=torch.float)
    std = 1
    print("mean是：",mean,"\n std是：",std)
    t_normal = torch.normal(mean, std)
    print("t_normal是\n",t_normal)

输出结果：

-----------mean：张量 std: 张量---------
mean是：tensor([1., 2., 3., 4.]) 
 std是：tensor([1., 2., 3., 4.])
t_normal是
 tensor([ 1.0527,  2.8746,  5.1393, -2.5108])
-----------mean：标量 std: 标量---------
torch.normal(0., 1., size=5,))输出
 tensor([-0.7771, -0.7684,  0.8846,  0.5542,  1.3451])
-----------mean：张量 std: 标量---------
mean是：tensor([1., 2., 3., 4.]) 
 std是：1
t_normal是
 tensor([0.5560, 1.9777, 2.9634, 2.7911])


Process finished with exit code 0

建议大家还是手动敲一遍代码加深理解

往期精彩回顾




适合初学者入门人工智能的路线及资料下载(图文+视频)机器学习入门系列下载机器学习及深度学习笔记等资料打印《统计学习方法》的代码复现专辑机器学习交流qq群955171419，加入微信群请扫码