pytorch学习笔记一：张量的操作与线性回归

一、张量的简介

1、张量的基本概念

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

2、张量的属性

在 PyTorch 0.4.0 之前，torch.autograd 包中存在 Variable 这种数据类型，主要是用于封装 Tensor，进行自动求导。Variable 主要包含下面几种属性。

● data: 被包装的 Tensor。
● grad: data 的梯度。
● grad_fn: 创建 Tensor 所使用的 Function，是自动求导的关键，因为根据所记录的函数才能计算出导数。
● requires_grad: 指示是否需要梯度，并不是所有的张量都需要计算梯度。
● is_leaf: 指示是否叶子节点(张量)。

在 PyTorch 0.4.0 之后，Variable 并入了 Tensor。在之后版本的 Tensor 中，除了具有上面 Variable 的 5 个属性，还有另外 3 个属性。

• dtype：张量的数据类型
  
  每种类型都有CPU和GPU两个版本，张量运算必须发生在相同类型的数据之间。
• shape：张量的形状，如（1， 3， 64， 64）
• device：张量所在的设备，CPU/GPU，决定张量的计算在哪里进行，张量放在GPU上才能使用加速。

二、张量的创建

1、直接创建

torch.tensor():从data创建Tensor

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

• data：数据，可以是list，也可以是numpy
• dtype：数据类型，默认和data一致
• device：tensor所在的设备
• requires_grad：是否需要梯度，默认False，在搭建神经网络时需要将求导的参数设为True
• pin_memory：是否存于锁页内存，默认False

示例：

arr = np.ones((3, 3))
print('ndarray的数据类型：',arr.dtype)

tensor_arr = torch.tensor(arr)
print(tensor_arr)

#result
ndarray的数据类型： float64
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)

.from_numpy() 将ndarray转换成tensor，两者共享内存，当修改一个数据时另一个也会被修改

array_b = np.array([1, 2, 3, 4])
tensor_b = torch.from_numpy(array_b)
print(array_b)
print(tensor_b)
#result
[1 2 3 4]
tensor([1, 2, 3, 4], dtype=torch.int32)

array_b[0] = 5
print(array_b)
print(tensor_b)
#result
[5 2 3 4]
tensor([5, 2, 3, 4], dtype=torch.int32)

tensor_b[0] = 10
print(array_b)
print(tensor_b)
#result
[10  2  3  4]
tensor([10,  2,  3,  4], dtype=torch.int32)

2、依数值创建

torch.zeros()依size创建全0的张量，torch.ones()依据size创建值全为1的张量

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

• size：张量的形状，如（3，3）
• layout ：这个是内存中的布局形式,有strided和sparse_coo等
• out：表示输出张量，就是再把这个张量赋值给别的一个张量，但是这两个张量时一样的，指的同一个内存地址
• device：所在的设备，gpu/cpu
• requires_grad：是否需要梯度
  示例：

out_t = torch.tensor([2])
t = torch.zeros((3, 3), out=out_t)
print(out_t)
print(t)
print(id(t), id(out_t), id(out_t)==id(t))
# result
tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]])
tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]])
140531404201664 140531404201664 True

torch.eye()创建对角线为1的张量

torch.eye(n, m=None, 
    out=None, 
    dtype=None, 
    layout=torch.strided, 
    device=None, 
    requires_grad=False) -> Tensor

torch.zeros_like()创建与input同shape的值全为0张量，torch.ones_like()创建与input同shape的值全为1的张量

#创建与input同shape的全1张量
torch.ones_like(input, 
          dtype=None, 
          layout=None, 
          device=None, 
          requires_grad=False, 
          memory_format=torch.preserve_format) -> Tensor

out_t = torch.tensor([1, 2, 3])
print('out_t:', out_t)

t = torch.ones((3,1), out=out_t)
print('\n')
print('t:',t)
print('out_t:', out_t)
print('id(t:):', id(t), 'id(out_t):', id(out_t), id(t)==id(out_t))

inputs = torch.tensor([[1, 2], [3, 4]])
out_ = torch.ones_like(inputs)
print('\n')
print('out_:', out_)

###result
out_t: tensor([1, 2, 3])


t: tensor([[1],
        [1],
        [1]])
out_t: tensor([[1],
        [1],
        [1]])
id(t:): 2564793927864 id(out_t): 2564793927864 True


out_: tensor([[1, 1],
        [1, 1]])

torch.full()自定义数值张量

torch.full(size, 
           fill_value,
           out=None, 
           dtype=None, 
           layout=torch.strided, 
           device=None, 
           requires_grad=False) -> Tensor
# fill_value:自定义的数值

torch.full_like(input, 
                fill_value, 
                dtype=None, 
                layout=torch.strided, 
                device=None, 
                requires_grad=False, 
                memory_format=torch