深度学习第一篇——预备知识

本章主要讲述一些入门操作。

来源：动手学习深度学习(pytorch版)

张量表示一个由数值组成的数组，这个数组可能有多个维度。具有一个轴的张量对应数学上的向量。
使用arange创建一个行向量x.从0开始。

import torch

x=torch.arange(12)
x

tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

输出张量的形状

x.shape

torch.Size([12])

检查张量的大小

x.numel()

12

改变一个张量的形状，而不改变元素的数量和元素值。其中可以通过-1来调用此自动计算出形状

X=x.reshape(3,4)
X

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])

x.reshape(-1,4)

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])

x.reshape(3,-1)

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])

使用全0、全1、其他常量或者从特定分布中随机采样的数字来初始化矩阵。

torch.zeros((2,3,4)),torch.ones((2,3,4))

(tensor([[[0., 0., 0., 0.],
          [0., 0., 0., 0.],
          [0., 0., 0., 0.]],

         [[0., 0., 0., 0.],
          [0., 0., 0., 0.],
          [0., 0., 0., 0.]]]),
 tensor([[[1., 1., 1., 1.],
          [1., 1., 1., 1.],
          [1., 1., 1., 1.]],

         [[1., 1., 1., 1.],
          [1., 1., 1., 1.],
          [1., 1., 1., 1.]]]))

特定的概率分布中随机采样，从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样

torch.randn(3,4)

tensor([[-0.0805,  0.5003, -0.3091,  1.2814],
        [-0.3342,  0.4061,  0.1151, -0.1609],
        [-1.2401, -0.6279,  1.2042,  0.3797]])

通过提供包含数值的python列表（或嵌套列表），来为所需张量中的每个元素赋予确定值。在这里，外层的列表对应于轴0，内层的列表对应于轴1

torch.tensor([[2,1,4,3],[1,2,3,4],[4,3,2,1]])

tensor([[2, 1, 4, 3],
        [1, 2, 3, 4],
        [4, 3, 2, 1]])

简单的张量运算

x=torch.tensor([1.0,2,4,8])
y=torch.tensor([2,2,2,2])
x+y,x-y,x*y,x/y,x**y  #运算符是求幂运算

(tensor([ 3.,  4.,  6., 10.]),
 tensor([-1.,  0.,  2.,  6.]),
 tensor([ 2.,  4.,  8., 16.]),
 tensor([0.5000, 1.0000, 2.0000, 4.0000]),
 tensor([ 1.,  4., 16., 64.]))

torch.exp(x)#按元素求幂

tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

多个张量连接，第一个 输出张量的轴0长度（6）是两个输入张量轴0 长度的总和
第二个输出张量的轴1长度（8）是两个输入张量轴1长度的总和

X=torch.arange(12,dtype=torch.float32).reshape((3,4))
Y=torch.tensor([[2.0,1,4,3],[1,2,3,4],[4,3,2,1]])
torch.cat((X,Y),dim=0),torch.cat((X,Y),dim=1)

(tensor([[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.],
         [ 2.,  1.,  4.,  3.],
         [ 1.,  2.,  3.,  4.],
         [ 4.,  3.,  2.,  1.]]),
 tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
         [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
         [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]]))

第一个通过逻辑运算符构建二元张量
第二个对张量的所有元素求和，会产生一个单元素张量

X==Y,X.sum(),X<Y,X>Y

(tensor([[False, False, False, False],
         [False, False, False, False],
         [False, False, False, False]]),
 tensor(298.),
 tensor([[False, False, False, False],
         [False, False, False, False],
         [False, False, False, False]]),
 tensor([[True, True, True, True],
         [True, True, True, True],
         [True, True, True, True]]))

广播机制，在大多数情况下，我们将沿着数组中长度为1的轴进行广播。

a=torch.arange(3).reshape((3,1))
b=torch.arange(2).reshape((1,2))
c=torch.arange(8).reshape((2,1,4))
a,b,c,a+b,a+c

(tensor([[0],
         [1],
         [2]]),
 tensor([[0, 1]]),
 tensor([[[0, 1, 2, 3]],

         [[4, 5, 6, 7]]]),
 tensor([[0, 1],
         [1, 2],
         [2, 3]]),
 tensor([[[0, 1, 2, 3],
          [1, 2, 3, 4],
          [2, 3, 4, 5]],

         [[4, 5, 6, 7],
          [5, 6, 7, 8],
          [6, 7, 8, 9]]]))

索引和切片，第一个元素的索引是0，最后一个元素的索引是-1；
可以指定范围以包含第一个元素和最后一个元素之前的元素

X[-1],X[1:3] #对于轴0而言的最后一个元素

(tensor([ 8.,  9., 10., 11.]),
 tensor([[ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.]]))

X[1,2]=9 #将指定元素写入矩阵
X

tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  9.,  7.],
        [ 8.,  9., 10., 11.]])

X[0:2,:]=12 #为多个元素赋予相同的值
X

tensor([[12., 12., 12., 12.],
        [12., 12., 12., 12.],
        [ 8.,  9., 10., 11.]])

节省内存

before =id(Y) #记录之前Y的地址
Y = Y+X #Y将分配到新的内存中
id(Y)==before #验证前后Y的地址是否相同，若不同则内存地址不同

False

#但在日常使用中，我们更希望其执行原地操作
Z=torch.zeros_like(Y)
print('id(Z):',id(Z))
Z[:]=X+Y
print('id(Z):',id(Z))

id(Z): 140064498968624
id(Z): 140064498968624

#也可以使用X+=Y来减少操作的内存开销
before =id(X)
X+=Y
id(X)==before

True

转换为其他python对象
将深度学习框架定义的张量转换为Numpy张量（ndarry）很容易，反之也同样容易。torch张量和numpy数组将共享它们的底层内存
就地操作更改一个张量也会同时更改另一个张量

A=X.numpy()
B = torch.tensor(A)
type(A),type(B)

(numpy.ndarray, torch.Tensor)

a = torch.tensor([3.5]) #要将大小为1的张量转换为Python标量，我们可以调用item函数或Python的内置函数
a,a.item(),float(a),int(a)

(tensor([3.5000]), 3.5, 3.5, 3)