张量简介与创建

1. 张量的概念

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

在这里插入图片描述

1.1 Tensor 与 Variable

• Variable是torch.autograd中的数据类型，主要用于封装Tensor，进行自动求导，包含五个属性：

  
  在这里插入图片描述
  • data：被包装的Tensor
  • grad：data的梯度
  • grad_fn：创建Tensor的function，是自动求导的关键
  • requires_grad：指示是否需要梯度
  • is_leaf：指示是否是叶子结点（张量）

• Tensor
  Pytorch0.4.0版本开始，Variable并入Tensor，并增加了dtype, shape和device属性

  
  在这里插入图片描述

  • dtype：张量的数据类型，pytorch提供了9种数据类型，如下图所示，其中32位浮点和64位整型是比较常用的两种数据类型。

    
    在这里插入图片描述
  • shape：张量的形状。
  • device：张量所在的设备，GPU/CPU。

2. 张量的创建

2.1 直接创建

• torch.tensor()
• 功能：从data创建tensor
  • data：数据，可以是list，numpy
  • dtype：数据类型，默认与data的一致
  • device：所在设备，cuda/cpu
  • requires_grad：是否需要梯度
  • pin_memory：是否存于锁页内容，通常设置位False

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

• torch.from_numpy(ndarray)
  功能：从numpy创建tensor
  注意事项：从torch.from_numpy创建的tensor与ndarray共享内存，当修改其中一个数据，另外一个也将会被改动。
  在这里插入图片描述
  我们通过下面的代码分别展示tensor的创建过程，以及tensor和ndarray共享内存的情况：

        arr = np.array([[1, 2, 3],[4, 5, 6]])
        t = torch.from_numpy(arr)
        print('numpy array:', arr)
        print('tensor:', t)

        print('修改array！')
        arr[0, 0] = 0
        print('numpy array:', arr)
        print('tensor:', t)

        print('修改tensor！')
        t[0, 0] = -1
        print('numpy array:', arr)
        print('tensor:', t)

运行结果如下：

在这里插入图片描述

2.2 依据数值创建

• torch.zeros()
• 功能： 依size创建全0张量
  • size：张量的形状，如（3，3）
  • out：输出的张量，用于接收创建的张量，一般可不写
  • layout：内存中布局形式，有strided，sparse_coo等
  • device：所在设备，gpu/cpu
  • requires_grad：是否需要梯度

torch.zeros(
            size,
            out=None,
            dtype=None,
            layout=torch.strided,
            device=None,
            requires_grad=False)

• torch.zeros_like()

• 功能：依input形状创建全0张量

  • input：创建与input同形状的全0张量
  • dtype：数据类型
  • layout：内存中布局形式

• torch.ones()

• torch.ones_like()

• torch.full()

  • size：张量的形状，如（3，3）
  • fill_value：需要填充的张量的值

torch.full(
            size,
            fill_value,
            out=None,
            dtype=None,
            layout=torch.strided,
            device=None,
            requires_grad=False)

• torch.full_like()

• 功能：与full()函数功能类似，依input形状创建张量

• torch.arange()

• 功能：创建等差的1维张量

• 数值区间为[start， end）

  • start：数列起始值
  • end：数列结束值，不包含在内
  • step：数列公差，默认为1

torch.arange(
            start=0,
            end,
            step=1,
            out=None,
            dtype=None,
            layout=torch.strided,
            device=None,
            requires_grad=False)

• torch.linspace()
• 功能：创建均分的1维张量
• 注意事项：数值区间为[start， end]
  • start：数列起始值
  • end：数列结束值
  • steps：数列长度

torch.linsapce(
            start=0,
            end,
            steps=100,
            out=None,
            dtype=None,
            layout=torch.strided,
            device=None,
            requires_grad=False)

• torch.longspace()

• 功能：创建对数均分的1维张量

• 注意：长度为steps，底为base

  • start：数列起始值
  • end：数列结束值
  • steps：数列长度
  • base：对数函数的底，默认为10

• torch.eye()

• 功能：创建单位对角矩阵（2维张量）

• 注意：默认为方阵

  • n：矩阵行数
  • m：矩阵列数（默认不写数值，这样会创建出n*n的方阵）

torch.linsapce(
            n,
            m=None,
            out=None,
            dtype=None,
            layout=torch.strided,
            device=None,
            requires_grad=False)

2.3 依据概率分布创建张量

• torch.normal()
• 功能：生成正太分布（高斯分布）
  • mean：均值
  • std：标准值
• 三种模式：
  1. mean为标量，std为标量
  2. mean为张量，std为标量
  3. mean为张量，std为张量

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

        print('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('mean:{} \n std:{}'.format(mean, std))
        print(t_normal)


        print('mean张量，std标量')
        mean = torch.arange(1, 5, dtype=torch.float)
        std = 1
        t_normal = torch.normal(mean, std)
        print('mean:{} \n std:{}'.format(mean, std))
        print(t_normal)


        print('mean标量，std张量')
        mean = 0
        std = torch.arange(1, 5, dtype=torch.float)
        t_normal = torch.normal(mean, std)
        print('mean:{} \n std:{}'.format(mean, std))
        print(t_normal)

结果为：

在这里插入图片描述

• torch.rand()
• torch.rand_like()
• 功能：在区间[0, 1)上，生成均匀分布

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

• torch.randint()
• torch.randint_like()
• 功能：在区间[low, high)生成整数均匀分布

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

• torch.randperm()
• 功能：生成从0到n-1的随机排列，通常用于生成乱序索引
  • n：张量的长度

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

• torch.bernoulli()
• 功能:以input为概率，生成伯努利分布（0，1分布，两点分布）
  • input：概率值

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