【动手学深度学习笔记】一.数据操作

1.张量的概念

概念： Pytorch 或者 Tensorflow 中的 $Tensor$ 类型（张量），可以理解成是数学中的 $n$ 维数组，与 NumPy 中的 $ndarray$ 类型类似。

区别是：

• Pytorch 或者 Tensorflow 中的 $Tensor$，GPU可以很好的支持它的加速计算，而 NumPy 中的 $ndarray$ 只能支持CPU计算。
• $Tensor$ 类型支持自动微分。

张量表示由一个数值组成的数组，这个数组可能有多个维度。具有一个轴的张量对应数学上的向量（$vector$）； 具有两个轴的张量对应数学上的矩阵（$matrix$）； 具有两个轴以上的张量没有特殊的数学名称。

1.1.torch.arange(12)

torch.arange可以用来创建行向量，默认创建的是整数（也可以指定创建类型为浮点型）。
张量中的每个值都成为张量的元素（$element$）。除非额外指定，新的张量将存储在内存中，并采用基于CPU的计算。

代码：

# 导入pytorch
import torch

# 创建一个行向量x，向量中有12个元素（整数），元素是从0-11
x = torch.arange(12)  
print(x)

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

# 查看张量中元素的个数
y = x.numel()
print(y)

# 输出：
12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.2.reshape(3,4)

要想改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数。

# 将向量x变成3行4列的张量z
z = x.reshape(3, 4)
print(z)

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

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

我们可以创建一个形状为（2,3,4）的张量，其中所有元素都设置为0。

注意：具有两个轴以上的张量没有特殊的数学名称，就不用去解读2,3,4分别代表什么了，知道是这样的一个形状就可以。

# 使用zeros，表示该张量中的所有元素都为0(zero)
torch.zeros((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.]]])
1
2
3
4
5
6
7
8
9
10
11

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

我们可以创建一个形状为（2,3,4）的张量，其中所有元素都设置为1。

# 使用ones，表示该张量中的所有元素都为1(one)
torch.ones((2,3,4))

# 输出：
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.]]])
1
2
3
4
5
6
7
8
9
10
11

1.5.torch.randn(2,3,4)

创建一个形状为（2,3,4）的张量。 其中的每个元素都从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样。

torch.randn(2,3,4)

# 输出：
tensor([[[ 0.2409, -0.1582,  0.4382, -1.0087],
         [-0.3676,  0.3038, -0.9411,  0.0746],
         [ 1.7080, -0.7177, -0.4913,  0.7167]],

        [[-0.2134, -0.3533,  0.0383, -1.6476],
         [ 0.6329, -0.4788, -0.8633, -0.8998],
         [ 1.6637, -1.3705,  0.6495,  0.0498]]])
1
2
3
4
5
6
7
8
9
10

1.6.torch.tensor([[2,3,4],[3,4,5]])

使用torch.tensor()手动创建张量，如：

torch.tensor([[2,3,4],[4,5,6],[7,8,9]])

# 输出：
tensor([[2, 3, 4],
        [4, 5, 6],
        [7, 8, 9]])
1
2
3
4
5
6

技巧： 可以根据[的数量来判断是几维的张量，如：

# 1个[，1维张量
tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])


# 2个[，2维张量
tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])


# 3个[，3维张量
tensor([[[ 0.2409, -0.1582,  0.4382, -1.0087],
         [-0.3676,  0.3038, -0.9411,  0.0746],
         [ 1.7080, -0.7177, -0.4913,  0.7167]],

        [[-0.2134, -0.3533,  0.0383, -1.6476],
         [ 0.6329, -0.4788, -0.8633, -0.8998],
         [ 1.6637, -1.3705,  0.6495,  0.0498]]])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.运算符

在数学表示法中，用$f:\mathbb{R}\to \mathbb{R}$ 来表示一元标量运算符，意味着该函数从任何一个实数 $\mathbb{R}$ 映射到了另一个实数 $\mathbb{R}$。

其中，

• $f$：表明这是一个函数，函数自变量和因变量之间存在映射关系，类似于数学的$f(x)$。
• $\mathbb{R}$：表示实数 $\mathbb{R}$。
• $\to$：箭头左侧是函数 $f$ 的自变量，右侧是函数 $f$ 的因变量。

所以上式表示一个一元函数，而 $f:\mathbb{R},\mathbb{R}\to \mathbb{R}$ 则表示一个二元函数（即：有两个自变量，有一个因变量）。

注意： 张量的运算符，是指张量中，元素与元素之间的运算。

x = torch.tensor([1, 2, 4, 8])

y = torch.tensor([2, 3, 4, 5])

print(x+y)
# 输出：
tensor([ 3,  4,  8, 13])
#即:	3 = 1+2	第一个tensor中的
		4 = 2+3
		8 = 4+4
		13= 8+5
1
2
3
4
5
6
7
8
9
10
11

3.广播机制

广播机制：通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状（两个张量就可以进行运算了）。

a = torch.arange(3).reshape((3, 1))  # 创建一个3行1列的张量
b = torch.arange(2).reshape((1, 2))  # 创建一个1行2列的张量
print(a)  
print(b)
print(a+b)

# 输出：
tensor([[0],
        [1],
        [2]])
tensor([[0, 1]])

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

理解： 一个是3行1列，一个是1行2列，二者没法直接进行运算。所以需要将3行1列的广播成3行2列，1行2列的广播成3行2列，即：2个张量维度相同时再进行运算。广播机制整个过程如下所示。

# 第一步：两个张量触发广播机制，进行转换
  [0]		[0, 0]
  [1]  	=>	[1, 1]		# 3行1列，变成3行2列
  [2] 	 	[2, 2]

			[0, 1]
[0, 1]	=>  [0, 1] 		# 1行2列，变成3行2列
			[0, 1]


# 第二步：两个张量进行运算
[0, 1]		[0, 0]		[0, 1]
[0, 1]  + 	[1, 1]	=	[1, 2]
[0, 1]		[2, 2]		[2, 3]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15