pytorch loss function.

Cross Entropy

简单来说，交叉熵是用来衡量在给定的真实分布 $p_k$ 下，使用非真实分布 $q_k$ 所指定的策略 f(x) 消除系统的不确定性所需要付出的努力的大小。交叉熵的越低说明这个策略越好，我们总是 minimize 交叉熵，因为交叉熵越小，就证明算法所产生的策略越接近最优策略，也就间接证明我们的算法所计算出的非真实分布越接近真实分布。交叉熵损失函数从信息论的角度来说，其实来自于 KL 散度，只不过最后推导的新式等价于交叉熵的计算公式：

从信息论的视角来理解： 信息量/信息熵（熵）/交叉熵/条件熵

信息量： 一个事件的信息量就是这个时间发生的概率的负对数，概率越大，所带来的信息就越少嘛。至于为什么是负对数，就要问香农了。。起码要满足$P(X)=1$时信息量为0，且始终大于0

$$-\log P(X)$$

信息熵， 也就是熵，是随机变量不确定性的度量，依赖于事件X的概率分布。即信息熵是信息量的期望。即求离散分布列的期望～～

$$H(p) = -\sum_{i=1}^np_i\log p_i$$

交叉熵： 回归到分类问题来，我们通过score function得到一个结果（10，1），通过softmax函数压缩成0到1的概率分布，我们称为 $q_i=\dfrac{e^{f_{y_i}}}{\sum_je^{f_j}}$ 吧，

$$H(p,q) = -\sum_{i=1}^np_i\log q_i$$

这就是我们所说的交叉熵，通过 Gibbs’ inequality 知道：$H(p,q)>=H(p)$ 恒成立，当且仅当 $q_i$ 分布和 $p_i$ 相同时，两者相等。

相对熵： 跟交叉熵是同样的概念，$D(p||q)=H(p,q)-H(p)=-\sum_{i=1}^np(i)\log {\dfrac{q(i)}{p(i)}}$，又称为KL散度，表征两个函数或概率分布的差异性，差异越大则相对熵越大.

最大似然估计、Negative Log Liklihood(NLL)、KL散度与Cross Entropy其实是等价的，都可以进行互相推导，当然MSE也可以用Cross Entropy进行推导出（详见Deep Learning Book P132）。

BCELoss

Creates a criterion that measures the Binary Cross Entropy between the target and the output

用于二分类的损失函数，也就是 logistic 回归的损失函数。

对于二分类，我们只需要预测出正分类的概率 p，对应的 (1-p) 则是负分类的概率。其中 p 可使用 sigmoid 函数得到。

$$sigmoid(x) = \dfrac{1}{1+e^{(-x)}}$$

对应的损失函数可通过极大似然估计推导得到：

假设有 n 个独立的训练样本 ${(x_1,y_1), …,(x_n, y_n)}$

y 是真实标签，$y\in {0,1}$, 那么对于每一个样本的概率为：

$$P(x_i, y_i)=P(y_i=1|x_i)^{y_i}P(y_i=0|x_i)^{1-y_i}$$

$$=P(y_i=1|x_i)^{y_i}(1-P(y_i=1|x_i))^{1-y_i}$$

取负对数即可得：

$$-y_iP(y_i=1|x_i)-(1-y_i)(1-P(y_i=1|x_i))$$

不难看出，这与常见的 softmax 多分类的 loss 计算是一致的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

class BCELoss(_WeightedLoss):

  def __init__(self, weight=None, size_average=None, reduce=None, reduction='elementwise_mean'):

    """

    - weight: 手动调整权重，不太明白有啥用，用到在看吧

    - size_average, reduce 弃用，直接看 reduction 即可

    - reduction： "elementwise_mean"|"sum"|"none"，看名字就知道啥意思了

    """

    super(BCELoss, self).__init__(weight, size_average, reduce, reduction)



def forward(self, input, target):

    return F.binary_cross_entropy(input, target, weight=self.weight, reduction=self.reduction)

    """

    - input: 预测概率，任意 shape, 但是值必须在 0-1 之间

    - target: 真实概率， shape 与 input 相同

    """  

$$loss(p,t)=−\dfrac{1}{N}\sum_{i=1}^{N}=\dfrac{1}{N}[t_i∗log(p_i)+(1−t_i)∗log(1−p_i)]$$

example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import torch

import torch.nn as nn



loss = nn.BCELoss(reduction="elementwise_mean")

input = torch.randn(5)

target = torch.ones(5)





loss = loss(torch.sigmoid(input), target)



my_loss = torch.mean(-target * torch.log(torch.sigmoid(input)) - (1-target) * torch.log((1-torch.sigmoid(input))))



# test weight parameter

loss1 = F.binary_cross_entropy(torch.sigmoid(input), target, reduction="none", weight=torch.Tensor([0,0,0,0,1]))

loss2 = F.binary_cross_entropy(torch.sigmoid(input), target, weight=torch.Tensor([0,0,0,0,1]))

print(my_loss, loss)



print(loss1, loss2*5)



# tensor(0.7590) tensor(0.7590)

# tensor([0.0000, 0.0000, 0.0000, 0.0000, 0.3104]) tensor(0.3104)

通常使用 sigmoid 函数时，我们预测得到正分类的概率，然后需要人为设置 threshold 来判断概率达到 threshold 才是正分类，有点类似于 hingle loss 哦。

torch.nn.CrossEntropyLoss

This criterion combines nn.LogSoftmax() and nn.NLLLoss() in one single class.

多分类交叉熵损失函数，可以看作是 binary_cross_entropy 的拓展。计算过程可以分为两步，log_softmax() 和 nn.NLLloss()

It is useful when training a classification problem with C classes. If provided, the optional argument weight should be a 1D Tensor assigning weight to each of the classes. This is particularly useful when you have an unbalanced training set.

在不均衡数据集中，参数 weight 会很有用。

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

class CrossEntropyLoss(_WeightedLoss):

  def __init__():

    """

    - weights: 给每一个类别一个权重。  

    - reduction: "elementwise_mean"|"sum"|"none".

    """

  def forward():

    """

    - input: [batch, C] or [batch, C, d_1, d_2, ..., d_k]

    - target: [batch], 0 <= targte[i] <= C-1, or [batch, d_1, d_2, ..., d_k], K >= 2.  

    """

example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

input = torch.randn(2, 3)

target = torch.Tensor([0, 2]).long()



# use loss function

loss_fn = nn.CrossEntropyLoss()

loss = loss_fn(input, target)



# compute loss step by step

score = torch.log_softmax(input, dim=1)

score1 = torch.log(F.softmax(input, dim=1))

print(score)

print(score1)



# use nll loss

nll_loss_fn = nn.NLLLoss()

nll_loss = nll_loss_fn(score, target)



# computer nll loss step by step

my_nll = torch.mean(-score[0][0] - score[1][2])

print(nll_loss, loss, my_nll)

1
2
3
4
5
6
7
8
9
10
11

tensor([[-0.8413, -0.7365, -2.4073],

        [-0.4626, -2.0660, -1.4120]])

tensor([[-0.8413, -0.7365, -2.4073],

        [-0.4626, -2.0660, -1.4120]])

tensor(1.1266) tensor(1.1266) tensor(1.1266)

torch.nn.NLLloss

The negative log likelihood loss. It is useful to train a classification problem with C class.

input 是已经通过 log_softmax 层的输入。loss 是对应样本中真实标签对应的值的负数。

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

class NLLLoss(_WeightedLoss):

  def __init__():

    """

    参数设置跟 CrossEntropyLoss 基本一致。

    """

NLLloss

$$\ell(x, y) = L = {l_1,\dots,l_N}^\top, \quad

l_n = - w_{y_n} x_{n,y_n}, \quad

w_{c} = \text{weight}[c] \cdot \mathbb{1}{c \not= \text{ignore_index}}$$

example：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

loss = nn.NLLLoss()

# input is of size N x C = 3 x 5

input = torch.randn(3, 5, requires_grad=True)

# each element in target has to have 0 <= value < C

target = torch.tensor([1, 0, 4])

output = loss(torch.log_softmax(input, dim=1), target)



score = torch.log_softmax(input, dim=1)

output2 = (-score[0, 1]-score[1, 0]-score[2, 4])/3

output.backward()

# output2.backward()



print(output, output2)



# tensor(1.5658, grad_fn=<NllLossBackward>)  tensor(1.5658, grad_fn=<DivBackward0>)

MultiMarginLoss

$loss = \dfrac{1}{N}\sum_{j\ne y_i}^{N}max(0,s_j - s_{y_i}+\Delta)$

$s_{yi}$ 表示其真实标签对应的值，那么其他非真实分类的结果凡是大于 $s_{yi}−\Delta$ 这个值的，都对最后的结果 $loss$ 产生影响，比这个值小的就没事～

显然想对于 softmax 损失函数来说，softmax 考虑到了所有的错分类，而 marginloss 只考虑概率较大的错分类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class MultiMarginLoss(_WeightedLoss):

  def __init__(self, p=1, margin=1, weight=None, size_average=None, reduce=None, reduction='elementwise_mean'):

    """

    - p (int, optional): Has a default value of `1`. `1` and `2` are the only supported values

    - margin (float, optional): Has a default value of `1`.

    """

    super(MultiMarginLoss, self).__init__(weight, size_average, reduce, reduction)

    if p != 1 and p != 2:

        raise ValueError("only p == 1 and p == 2 supported")

    assert weight is None or weight.dim() == 1

    self.p = p

    self.margin = margin



  def forward(self, input, target):

      return F.multi_margin_loss(input, target, p=self.p, margin=self.margin,

                                 weight=self.weight, reduction=self.reduction)

example:

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

loss = nn.MultiMarginLoss()

input = torch.FloatTensor([[0, 3, 1], [0, 4, 2], [1, 5, 2], [3, 5, 1]])

target = torch.ones(4).long()



out = loss(input, target)



print(out)  # 显然应该是 0,因为负分类与真实标签的 socre 差值都大于等于 1.

# tensor(0.)

nn.L1loss

$$L1(\hat{y}, y)=\dfrac{1}{m}\sum|\hat{y}_i−y_i|$$

nn.MSEloss

$$L2(\hat{y}, y)=\dfrac{1}{m}\sum|\hat{y}_i−y_i|^2$$

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

loss = nn.L1Loss()

loss2 = nn.MSELoss()



input = torch.FloatTensor([1,2,3])

target = torch.FloatTensor([1,2,9])



output = loss(input, target)

output2 = loss2(input, target)



print(output, output2)

# tensor(2.) tensor(12.)

Tensor

从接口的角度来讲，对tensor的操作可分为两类：

1. torch.function，如torch.save等。

2. 另一类是tensor.function，如tensor.view等。

而从存储的角度来讲，对tensor的操作又可分为两类：

1. 不会修改自身的数据，如 a.add(b)， 加法的结果会返回一个新的tensor。

2. 会修改自身的数据，如 a.add_(b)， 加法的结果仍存储在a中，a被修改了。

表3-1: 常见新建tensor的方法

|函数|功能|

|:—:|:—:|

|Tensor(*sizes)|基础构造函数|

|ones(*sizes)|全1Tensor|

|zeros(*sizes)|全0Tensor|

|eye(*sizes)|对角线为1，其他为0|

|arange(s,e,step|从s到e，步长为step|

|linspace(s,e,steps)|从s到e，均匀切分成steps份|

|rand/randn(*sizes)|均匀/标准分布|

|normal(mean,std)/uniform(from,to)|正态分布/均匀分布|

|randperm(m)|随机排列|

其中使用Tensor函数新建tensor是最复杂多变的方式，它既可以接收一个list，并根据list的数据新建tensor，也能根据指定的形状新建tensor，还能传入其他的tensor.

• b.tolist() 把 tensor 转为 list

• b.numel() b 中元素总数，等价于 b.nelement()

• torch.Tensor(b.size()) 创建和 b 一样的 tensor

• 除了tensor.size()，还可以利用tensor.shape直接查看tensor的形状，tensor.shape等价于tensor.size()

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

# 用list的数据创建tensor

b = torch.Tensor([[1,2,3],[4,5,6]])

print(b)

print(b.tolist())

print(b.numel())

# 创建一个和b形状一样的tensor

c = torch.Tensor(b.size())

print(c)

# 创建一个元素为2和3的tensor

d = torch.Tensor((2, 3))

print(d)

tensor([[ 1.,  2.,  3.],

        [ 4.,  5.,  6.]])

[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]

6

tensor(1.00000e-15 *

       [[-3.4942,  0.0000,  0.0000],

        [ 0.0000,  0.0000,  0.0000]])

tensor([ 2.,  3.])

常用Tensor操作

view, squeeze, unsqueeze, resize

• 通过tensor.view方法可以调整tensor的形状，但必须保证调整前后元素总数一致。view不会修改自身的数据，返回的新tensor与源tensor共享内存，也即更改其中的一个，另外一个也会跟着改变。在实际应用中可能经常需要添加或减少某一维度，这时候squeeze和unsqueeze两个函数就派上用场了。

tensorflow 里面是 tf.expand_dim 和 tf.squeeze.

• resize是另一种可用来调整size的方法，但与view不同，它可以修改tensor的大小。如果新大小超过了原大小，会自动分配新的内存空间，而如果新大小小于原大小，则之前的数据依旧会被保存，看一个例子。

1
2
3
4
5

a = torch.arange(0, 6)

a.view(2, 3)

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

        [ 3.,  4.,  5.]])

1
2
3
4
5

b = a.view(-1, 3) # 当某一维为-1的时候，会自动计算它的大小

b

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

        [ 3.,  4.,  5.]])

1
2
3

b.unsqueeze(1) # 注意形状，在第1维（下标从0开始）上增加“１”

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



        [[ 3.,  4.,  5.]]])

1
2
3

b.unsqueeze(-2) # -2表示倒数第二个维度

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



        [[ 3.,  4.,  5.]]])

1
2
3
4
5

c = b.view(1, 1, 1, 2, 3)

c.squeeze(0) # 压缩第0维的“１”

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

          [ 3.,  4.,  5.]]]])

1
2
3

c.squeeze() # 把所有维度为“1”的压缩

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

        [ 3.,  4.,  5.]])

1
2
3
4
5

a[1] = 100

b # a修改，b作为view之后的，也会跟着修改

tensor([[   0.,  100.,    2.],

        [   3.,    4.,    5.]])

1
2
3
4
5

b.resize_(1, 3)

b

tensor([[   0.,  100.,    2.]])

1
2
3
4
5

b.resize_(3, 3) # 旧的数据依旧保存着，多出的大小会分配新空间

b

tensor([[   0.0000,  100.0000,    2.0000],

        [   3.0000,    4.0000,    5.0000],

        [  -0.0000,    0.0000,    0.0000]])

索引操作

Tensor支持与numpy.ndarray类似的索引操作，语法上也类似，下面通过一些例子，讲解常用的索引操作。如无特殊说明，索引出来的结果与原tensor共享内存，也即修改一个，另一个会跟着修改。

其它常用的选择函数如表3-2所示。

表3-2常用的选择函数

函数|功能|

:—:|:—:|

index_select(input, dim, index)|在指定维度dim上选取，比如选取某些行、某些列

masked_select(input, mask)|例子如上，a[a>0]，使用ByteTensor进行选取

non_zero(input)|非0元素的下标

gather(input, dim, index)|根据index，在dim维度上选取数据，输出的size与index一样

gather是一个比较复杂的操作，对一个2维tensor，输出的每个元素如下：

1
2
3
4
5

out[i][j] = input[index[i][j]][j]  # dim=0

out[i][j] = input[i][index[i][j]]  # dim=1

三维tensor的gather操作同理，下面举几个例子。

index_select(input, dim, index) 指定维度上选取某些行和列, 返回的是某行和某列

1
2
3
4
5
6
7

a = torch.randn(3, 4)

print(a)

print(a[0,1]) # 第 0 行， 第 1 列

tensor([[ 0.5948, -0.5760,  1.3726, -0.9664],

        [ 0.5705,  1.0374, -1.1780,  0.0635],

        [-0.1195,  0.6657,  0.9583, -1.8952]])

tensor(-0.5760)

返回行的四种方式

1
2
3

print(a[torch.LongTensor([1,2])]) # 第 0 行 和 第 1 行

tensor([[ 0.5705,  1.0374, -1.1780,  0.0635],

        [-0.1195,  0.6657,  0.9583, -1.8952]])

1
2
3
4
5

index = torch.LongTensor([1,2])

a.index_select(dim=0, index=index)

tensor([[ 0.5705,  1.0374, -1.1780,  0.0635],

        [-0.1195,  0.6657,  0.9583, -1.8952]])

1
2
3

a[1:3] # 只能是连续的行

tensor([[ 0.5705, 1.0374, -1.1780, 0.0635],

        [-0.1195,  0.6657,  0.9583, -1.8952]])

1
2
3

print(a[torch.LongTensor([[1],[2]])]) # 还是第 0 行 和 第 1 行

tensor([[[ 0.5705,  1.0374, -1.1780,  0.0635]],



        [[-0.1195,  0.6657,  0.9583, -1.8952]]])

返回列的两种方式

1
2
3

a.index_select(dim=1, index=index)

tensor([[-0.5760,  1.3726],

        [ 1.0374, -1.1780],

        [ 0.6657,  0.9583]])

1
2
3

a[:, 1:3] # 连续的列

tensor([[-0.5760,  1.3726],

        [ 1.0374, -1.1780],

        [ 0.6657,  0.9583]])

masked_selected(input, mask) 使用 ByteTensor 进行选取

mask is ByteTensor, 类似于 a[a>1]

1
2
3
4
5
6
7
8
9

a = torch.randn(3, 4)

print(a)

print(a[a>0])

a.masked_select(a>0)

tensor([[ 0.3464,  1.4499,  0.7417, -1.9551],

        [-0.0042, -0.0141,  1.2861,  0.0691],

        [ 0.5843,  1.6635, -1.2771, -1.4623]])

tensor([ 0.3464,  1.4499,  0.7417,  1.2861,  0.0691,  0.5843,  1.6635])



tensor([ 0.3464,  1.4499,  0.7417,  1.2861,  0.0691,  0.5843,  1.6635])

1
2
3

a>0  # 返回一个 ByteTensor

tensor([[ 1,  1,  1,  0],

        [ 0,  0,  1,  1],

        [ 1,  1,  0,  0]], dtype=torch.uint8)

1
2
3
4
5

b = torch.ByteTensor(3,4)

b

tensor([[  80,  235,  127,  167],

        [ 199,   85,    0,    0],

        [   0,    0,    0,    0]], dtype=torch.uint8)

1
2
3

a[b]

tensor([ 0.3464,  1.4499,  0.7417, -1.9551, -0.0042, -0.0141])

gather(input, dim, index) 根据 index 在 dim 维度上选取数据，输出 size 与 index 一样.

1
2
3
4
5
6
7
8
9

a = torch.arange(0, 20).view(4,5)

print(a)

index = torch.LongTensor([[0,1,2,1,3]])

print(index, index.shape)

tensor([[  0.,   1.,   2.,   3.,   4.],

        [  5.,   6.,   7.,   8.,   9.],

        [ 10.,  11.,  12.,  13.,  14.],

        [ 15.,  16.,  17.,  18.,  19.]])

tensor([[ 0,  1,  2,  1,  3]]) torch.Size([1, 5])

1
2
3

a.gather(dim=0, index=index)

tensor([[  0.,   6.,  12.,   8.,  19.]])

所以 gather 就是 index 与 input 中某一个维度一致，比如这里 input.size()=[4,5].

那么 dim=0, index.size()=[1,5]. 然后在每列对应的 index 选取对应的数据。最后输出 size 与 index 一致。

1
2
3
4
5

index2 = torch.LongTensor([[1],[2],[3],[4]])

print(index2.shape)

torch.Size([4, 1])

1
2
3

a.gather(dim=1, index=index2)

tensor([[  1.],

        [  7.],

        [ 13.],

        [ 19.]])

list 转换成 one-hot 向量

1
2
3
4
5
6
7
8
9
10
11

### list 转换成 one-hot 向量

label = [1, 2, 3, 4, 5]

label = torch.LongTensor(label).view(-1, 1)

one_hot = torch.zeros(5, 10).scatter_(dim=1, index=label, value=1)

one_hot

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

        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],

        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],

        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],

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

Tensor 类型

Tensor有不同的数据类型，如表3-3所示，每种类型分别对应有CPU和GPU版本(HalfTensor除外)。默认的tensor是FloatTensor，可通过t.set_default_tensor_type 来修改默认tensor类型(如果默认类型为GPU tensor，则所有操作都将在GPU上进行)。Tensor的类型对分析内存占用很有帮助。例如对于一个size为(1000, 1000, 1000)的FloatTensor，它有1000*1000*1000=10^9个元素，每个元素占32bit/8 = 4Byte内存，所以共占大约4GB内存/显存。HalfTensor是专门为GPU版本设计的，同样的元素个数，显存占用只有FloatTensor的一半，所以可以极大缓解GPU显存不足的问题，但由于HalfTensor所能表示的数值大小和精度有限[^2]，所以可能出现溢出等问题。

^2: https://stackoverflow.com/questions/872544/what-range-of-numbers-can-be-represented-in-a-16-32-and-64-bit-ieee-754-syste

表3-3: tensor数据类型

数据类型| CPU tensor |GPU tensor|

:—:|:—:|:–:|

32-bit 浮点| torch.FloatTensor |torch.cuda.FloatTensor

64-bit 浮点| torch.DoubleTensor| torch.cuda.DoubleTensor

16-bit 半精度浮点| N/A |torch.cuda.HalfTensor

8-bit 无符号整形(0~255)| torch.ByteTensor| torch.cuda.ByteTensor

8-bit 有符号整形(-128~127)| torch.CharTensor |torch.cuda.CharTensor

16-bit 有符号整形 | torch.ShortTensor| torch.cuda.ShortTensor

32-bit 有符号整形 |torch.IntTensor |torch.cuda.IntTensor

64-bit 有符号整形 |torch.LongTensor |torch.cuda.LongTensor

各数据类型之间可以互相转换，type(new_type)是通用的做法，同时还有float、long、half等快捷方法。CPU tensor与GPU tensor之间的互相转换通过tensor.cuda和tensor.cpu方法实现。Tensor还有一个new方法，用法与t.Tensor一样，会调用该tensor对应类型的构造函数，生成与当前tensor类型一致的tensor。

• torch.set_sefault_tensor_type(‘torch.IntTensor)

逐元素操作

这部分操作会对tensor的每一个元素(point-wise，又名element-wise)进行操作，此类操作的输入与输出形状一致。常用的操作如表3-4所示。

表3-4: 常见的逐元素操作

|函数|功能|

|:–:|:–:|

|abs/sqrt/div/exp/fmod/log/pow..|绝对值/平方根/除法/指数/求余/求幂..|

|cos/sin/asin/atan2/cosh..|相关三角函数|

|ceil/round/floor/trunc| 上取整/四舍五入/下取整/只保留整数部分|

|clamp(input, min, max)|超过min和max部分截断|

|sigmod/tanh..|激活函数

对于很多操作，例如div、mul、pow、fmod等，PyTorch都实现了运算符重载，所以可以直接使用运算符。如a ** 2 等价于torch.pow(a,2), a * 2等价于torch.mul(a,2)。

其中clamp(x, min, max)的输出满足以下公式：

$$

y_i =

\begin{cases}

min, & \text{if } x_i \lt min \

x_i, & \text{if } min \le x_i \le max \

max, & \text{if } x_i \gt max\

\end{cases}

$$

clamp常用在某些需要比较大小的地方，如取一个tensor的每个元素与另一个数的较大值。

1
2
3
4
5
6
7
8
9

import torch

a = torch.arange(0,6).view(2,3)

print(a)

torch.clamp(a, min=3, max=5)

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

        [ 3.,  4.,  5.]])



tensor([[ 3.,  3.,  3.],

        [ 3.,  4.,  5.]])

归并操作

此类操作会使输出形状小于输入形状，并可以沿着某一维度进行指定操作。如加法sum，既可以计算整个tensor的和，也可以计算tensor中每一行或每一列的和。常用的归并操作如表3-5所示。

表3-5: 常用归并操作

|函数|功能|

|:—:|:—:|

|mean/sum/median/mode|均值/和/中位数/众数|

|norm/dist|范数/距离|

|std/var|标准差/方差|

|cumsum/cumprod|累加/累乘|

以上大多数函数都有一个参数 **dim**，用来指定这些操作是在哪个维度上执行的。关于dim(对应于Numpy中的axis)的解释众说纷纭，这里提供一个简单的记忆方式：

假设输入的形状是(m, n, k)

• 如果指定dim=0，输出的形状就是(1, n, k)或者(n, k)

• 如果指定dim=1，输出的形状就是(m, 1, k)或者(m, k)

• 如果指定dim=2，输出的形状就是(m, n, 1)或者(m, n)

size中是否有”1”，取决于参数keepdim，keepdim=True会保留维度1。注意，以上只是经验总结，并非所有函数都符合这种形状变化方式，如cumsum。

1
2
3
4
5

a = torch.arange(0, 6).view(2,3)

a

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

        [ 3.,  4.,  5.]])

1
2
3

a.norm(dim=0, p=1), a.norm(dim=0, p=2), a.norm(dim=0, p=3)

(tensor([ 3.,  5.,  7.]),

 tensor([ 3.0000,  4.1231,  5.3852]),

 tensor([ 3.0000,  4.0207,  5.1045]))

1
2
3

torch.norm??

$||x||{p} = \sqrt[p]{x{1}^{p} + x_{2}^{p} + \ldots + x_{N}^{p}}$

torch.dist??

dist(input, other, p=2) -> Tensor

Returns the p-norm of (:attr:input - :attr:other)

1
2
3

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

tensor(2.)

1
2
3

torch.var(torch.randn(10,3), dim=0)

tensor([ 0.7617,  1.0060,  1.6778])

比较

比较函数中有一些是逐元素比较，操作类似于逐元素操作，还有一些则类似于归并操作。常用比较函数如表3-6所示。

表3-6: 常用比较函数

|函数|功能|

|:–:|:–:|

|gt/lt/ge/le/eq/ne|大于/小于/大于等于/小于等于/等于/不等|

|topk|最大的k个数|

|sort|排序|

|max/min|比较两个tensor最大最小值|

表中第一行的比较操作已经实现了运算符重载，因此可以使用a>=b、a>b、a!=b、a==b，其返回结果是一个ByteTensor，可用来选取元素。max/min这两个操作比较特殊，以max来说，它有以下三种使用情况：

• t.max(tensor)：返回tensor中最大的一个数

• t.max(tensor,dim)：指定维上最大的数，返回tensor和下标

• t.max(tensor1, tensor2): 比较两个tensor相比较大的元素

至于比较一个tensor和一个数，可以使用clamp函数。下面举例说明。

• max/min

• sort

• topk

1
2
3
4
5

a = torch.rand(3,4)

a

tensor([[ 0.1845,  0.4101,  0.1470,  0.0083],

        [ 0.7520,  0.8871,  0.9494,  0.2504],

        [ 0.3879,  0.4554,  0.4080,  0.1703]])

1
2
3

torch.max(a, dim=0)

(tensor([ 0.7326,  0.6784,  0.9791,  0.9011]), tensor([ 1,  2,  1,  1]))

1
2
3

a.sort(dim=0)

(tensor([[ 0.1424,  0.5681,  0.1833,  0.1654],

         [ 0.4556,  0.6418,  0.3242,  0.5120],

         [ 0.7326,  0.6784,  0.9791,  0.9011]]), tensor([[ 2,  0,  0,  2],

         [ 0,  1,  2,  0],

         [ 1,  2,  1,  1]]))

1
2
3

a.topk(k=2, dim=0)

(tensor([[ 0.7326,  0.6784,  0.9791,  0.9011],

         [ 0.4556,  0.6418,  0.3242,  0.5120]]), tensor([[ 1,  2,  1,  1],

         [ 0,  1,  2,  0]]))

线性代数

PyTorch的线性函数主要封装了Blas和Lapack，其用法和接口都与之类似。常用的线性代数函数如表3-7所示。

表3-7: 常用的线性代数函数

|函数|功能|

|:—:|:—:|

|trace|对角线元素之和(矩阵的迹)|

|diag|对角线元素|

|triu/tril|矩阵的上三角/下三角，可指定偏移量|

|mm/bmm|矩阵乘法，batch的矩阵乘法|

|addmm/addbmm/addmv/addr/badbmm..|矩阵运算

|t|转置|

|dot/cross|内积/外积

|inverse|求逆矩阵

|svd|奇异值分解

具体使用说明请参见官方文档^3，需要注意的是，矩阵的转置会导致存储空间不连续，需调用它的.contiguous方法将其转为连续。

1
2
3
4
5
6
7

b.contiguous(), b.size()

b.contiguous().is_contiguous()

print(a.matmul(b.contiguous()))

tensor([[ 0.8260,  1.3392,  0.5944],

        [ 1.3392,  2.7192,  1.0062],

        [ 0.5944,  1.0062,  0.6130]])

1
2
3
4
5
6
7
8
9

b = a.t()

print(a.size(), b.shape)

print(a.mm(b))

b.is_contiguous()

torch.Size([3, 4]) torch.Size([4, 3])

tensor([[ 0.8260,  1.3392,  0.5944],

        [ 1.3392,  2.7192,  1.0062],

        [ 0.5944,  1.0062,  0.6130]])

False

1
2
3

b, b.diag()

(tensor([[ 0.4556,  0.7326,  0.1424],

         [ 0.5681,  0.6418,  0.6784],

         [ 0.1833,  0.9791,  0.3242],

         [ 0.5120,  0.9011,  0.1654]]), tensor([ 0.4556,  0.6418,  0.3242]))

1
2
3
4
5

a = torch.randn(5,5)

a.triu(1)

tensor([[ 0.0000,  1.5959, -0.2253,  0.2349, -0.5151],

        [ 0.0000,  0.0000, -0.0366, -0.0867,  0.2737],

        [ 0.0000,  0.0000,  0.0000,  0.9904, -1.4889],

        [ 0.0000,  0.0000,  0.0000,  0.0000, -1.1053],

        [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000]])

Tensor和Numpy

Tensor和Numpy数组之间具有很高的相似性，彼此之间的互操作也非常简单高效。需要注意的是，Numpy和Tensor共享内存。由于Numpy历史悠久，支持丰富的操作，所以当遇到Tensor不支持的操作时，可先转成Numpy数组，处理后再转回tensor，其转换开销很小。

注意： 当numpy的数据类型和Tensor的类型不一样的时候，数据会被复制，不会共享内存。

1
2
3
4
5
6
7
8
9

import numpy as np

a = np.ones([2,3])

print(a.dtype)

a

float64

array([[1., 1., 1.],

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

1
2
3
4
5
6
7

b = torch.Tensor(a)

print(b.type())

b

torch.FloatTensor

tensor([[   1.,  100.,    1.],

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

1
2
3

torch.from_numpy??

1
2
3
4
5
6
7

c = torch.from_numpy(a)

print(c.type())

c

torch.DoubleTensor

tensor([[ 1.,  1.,  1.],

        [ 1.,  1.,  1.]], dtype=torch.float64)

1
2
3
4
5

a[0,1] = 100

b  # b与a不通向内存，所以即使a改变了，b也不变

tensor([[ 1.,  1.,  1.],

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

1
2
3

c  # c 与 a 共享内存

tensor([[   1.,  100.,    1.],

        [   1.,    1.,    1.]], dtype=torch.float64)

BroadCast

广播法则(broadcast)是科学运算中经常使用的一个技巧，它在快速执行向量化的同时不会占用额外的内存/显存。

Numpy的广播法则定义如下：

• 让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分通过在前面加1补齐

• 两个数组要么在某一个维度的长度一致，要么其中一个为1，否则不能计算

• 当输入数组的某个维度的长度为1时，计算时沿此维度复制扩充成一样的形状

PyTorch当前已经支持了自动广播法则，但是笔者还是建议读者通过以下两个函数的组合手动实现广播法则，这样更直观，更不易出错：

• unsqueeze或者view：为数据某一维的形状补1，实现法则1

• expand或者expand_as，重复数组，实现法则3；该操作不会复制数组，所以不会占用额外的空间。

注意，repeat实现与expand相类似的功能，但是repeat会把相同数据复制多份，因此会占用额外的空间。

1
2
3
4
5

a = torch.ones(3, 2)

b = torch.zeros(2, 3, 1)

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

# 自动广播法则

# 第一步：a是2维,b是3维，所以先在较小的a前面补1 ，

#               即：a.unsqueeze(0)，a的形状变成（1，3，2），b的形状是（2，3，1）,

# 第二步:   a和b在第一维和第三维形状不一样，其中一个为1 ，

#               可以利用广播法则扩展，两个形状都变成了（2，3，2）

a+b

tensor([[[ 1.,  1.],

         [ 1.,  1.],

         [ 1.,  1.]],



        [[ 1.,  1.],

         [ 1.,  1.],

         [ 1.,  1.]]])

1
2
3

a.unsqueeze(0).expand(2,3,2) + b.expand(2,3,2)

tensor([[[ 1.,  1.],

         [ 1.,  1.],

         [ 1.,  1.]],



        [[ 1.,  1.],

         [ 1.,  1.],

         [ 1.,  1.]]])

1
2
3
4
5

# expand不会占用额外空间，只会在需要的时候才扩充，可极大节省内存

e = a.unsqueeze(0).expand(10000000000000, 3,2)

内部结构

tensor的数据结构如图3-1所示。tensor分为头信息区(Tensor)和存储区(Storage)，信息区主要保存着tensor的形状（size）、步长（stride）、数据类型（type）等信息，而真正的数据则保存成连续数组。由于数据动辄成千上万，因此信息区元素占用内存较少，主要内存占用则取决于tensor中元素的数目，也即存储区的大小。

一般来说一个tensor有着与之相对应的storage, storage是在data之上封装的接口，便于使用，而不同tensor的头信息一般不同，但却可能使用相同的数据。下面看两个例子。

1
2
3
4
5

a = torch.arange(0,6)

a

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

1
2
3

a.storage()

 0.0

 1.0

 2.0

 3.0

 4.0

 5.0

[torch.FloatStorage of size 6]

1
2
3
4
5

b = a.view(2, 3)

b.storage()

 0.0

 1.0

 2.0

 3.0

 4.0

 5.0

[torch.FloatStorage of size 6]

1
2
3
4
5
6
7

# 一个对象的id值可以看作它在内存中的地址

# storage的内存地址一样，即是同一个storage

id(b.storage()) == id(a.storage())

True

1
2
3
4
5

c = torch.arange(0, 6)

c.storage()

 0.0

 1.0

 2.0

 3.0

 4.0

 5.0

[torch.FloatStorage of size 6]

1
2
3
4
5
6
7

# 一个对象的id值可以看作它在内存中的地址

# storage的内存地址一样，即是同一个storage

id(c.storage()) == id(a.storage())

True

1
2
3
4
5
6
7

# a改变，b也随之改变，因为他们共享storage, 但是 c 没有改变啊，很神奇

a[1] = 100

b, c

(tensor([[   0.,  100.,    2.],

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

1
2
3
4
5
6
7

# 一个对象的id值可以看作它在内存中的地址

# storage的内存地址一样，即是同一个storage

id(c[1].storage()), id(c.storage())

(139719200619016, 139719200619016)

1
2
3
4
5
6
7

c = a[2:]

print(c)

c.storage()

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

 0.0

 100.0

 2.0

 3.0

 4.0

 5.0

[torch.FloatStorage of size 6]

1
2
3
4
5

c.data_ptr(), a.data_ptr() # data_ptr返回tensor首元素的内存地址

# 可以看出相差8，这是因为2*4=8--相差两个元素，每个元素占4个字节(float)

(94551854283064, 94551854283056)

1
2
3
4
5

c[0]=-100 # c[0]的内存地址对应 a[2] 的内存地址

a

tensor([   0.,  100., -100.,    3.,    4.,    5.])

1
2
3
4
5
6
7

d = torch.Tensor(c.storage())

d[0] = 6666

b

tensor([[ 6666.,   100.,  -100.],

        [    3.,     4.,     5.]])

1
2
3
4
5

# 下面４个tensor共享storage

id(a.storage()) == id(b.storage()) == id(c.storage()) == id(d.storage())

True

1
2
3

a.storage_offset(), c.storage_offset(), d.storage_offset()

(0, 2, 0)

1
2
3
4
5

e = b[::2, ::2] # 隔2行/列取一个元素

id(e.storage()) == id(a.storage())

True

1
2
3

e.is_contiguous()

False

可见绝大多数操作并不修改tensor的数据，而只是修改了tensor的头信息。这种做法更节省内存，同时提升了处理速度。在使用中需要注意。

此外有些操作会导致tensor不连续，这时需调用tensor.contiguous方法将它们变成连续的数据，该方法会使数据复制一份，不再与原来的数据共享storage。

另外读者可以思考一下，之前说过的高级索引一般不共享stroage，而普通索引共享storage，这是为什么？（提示：普通索引可以通过只修改tensor的offset，stride和size，而不修改storage来实现）。

持久化

Tensor的保存和加载十分的简单，使用t.save和t.load即可完成相应的功能。在save/load时可指定使用的pickle模块，在load时还可将GPU tensor映射到CPU或其它GPU上。

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

if torch.cuda.is_available():

    a = a.cuda() # 把a转为GPU1上的tensor,

    torch.save(a,'a.pth')



    # 加载为b, 存储于GPU1上(因为保存时tensor就在GPU1上)

    b = torch.load('a.pth')

    # 加载为c, 存储于CPU

    c = torch.load('a.pth', map_location=lambda storage, loc: storage)

    # 加载为d, 存储于GPU0上

    d = torch.load('a.pth', map_location={'cuda:1':'cuda:0'})

1
2
3
4
5

a = torch.load("a.pth")

print(a)

tensor([ 6666.,   100.,  -100.,     3.,     4.,     5.], device='cuda:0')

向量化

向量化计算是一种特殊的并行计算方式，相对于一般程序在同一时间只执行一个操作的方式，它可在同一时间执行多个操作，通常是对不同的数据执行同样的一个或一批指令，或者说把指令应用于一个数组/向量上。向量化可极大提高科学运算的效率，Python本身是一门高级语言，使用很方便，但这也意味着很多操作很低效，尤其是for循环。在科学计算程序中应当极力避免使用Python原生的for循环。

1
2
3
4
5
6
7
8
9
10
11

def for_loop_add(x, y):

    result = []

    for i,j in zip(x, y):

        result.append(i + j)

    return torch.Tensor(result)

1
2
3
4
5
6
7
8
9

x = torch.zeros(100)

y = torch.ones(100)

%timeit -n 10 for_loop_add(x, y)

%timeit -n 10 x + y

351 µs ± 9.1 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

The slowest run took 16.46 times longer than the fastest. This could mean that an intermediate result is being cached.

4.24 µs ± 7.12 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

可见二者有超过40倍的速度差距，因此在实际使用中应尽量调用内建函数(buildin-function)，这些函数底层由C/C++实现，能通过执行底层优化实现高效计算。因此在平时写代码时，就应养成向量化的思维习惯。

此外还有以下几点需要注意：

• 大多数torch.function都有一个参数out，这时候产生的结果将保存在out指定tensor之中。

• torch.set_num_threads可以设置PyTorch进行CPU多线程并行计算时候所占用的线程数，这个可以用来限制PyTorch所占用的CPU数目。

• torch.set_printoptions可以用来设置打印tensor时的数值精度和格式。

下面举例说明。

1
2
3
4
5
6
7

a = torch.randn(2,3)

torch.set_printoptions(precision=10)

a

tensor([[-0.3306640089, -0.0507176071, -0.4223535955],

        [-0.8678948879, -0.0437202156, 0.0183448847]])

线性回归

线性回归是机器学习入门知识，应用十分广泛。线性回归利用数理统计中回归分析，来确定两种或两种以上变量间相互依赖的定量关系的，其表达形式为$y = wx+b+e$，$e$为误差服从均值为0的正态分布。首先让我们来确认线性回归的损失函数：

$$

loss = \sum_i^N \frac 1 2 ({y_i-(wx_i+b)})^2

$$

然后利用随机梯度下降法更新参数$\textbf{w}$和$\textbf{b}$来最小化损失函数，最终学得$\textbf{w}$和$\textbf{b}$的数值。

1
2
3
4
5
6
7
8
9

import torch as t

%matplotlib inline

from matplotlib import pyplot as plt

from IPython import display

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 设置随机数种子，保证在不同电脑上运行时下面的输出一致

t.manual_seed(1000)



def get_fake_data(batch_size=8):

    ''' 产生随机数据：y=x*2+3，加上了一些噪声'''

    x = t.rand(batch_size, 1) * 20

    y = x * 2 + (1 + t.randn(batch_size, 1))*3

    return x, y



# 来看看产生的x-y分布

x, y = get_fake_data()

plt.scatter(x.squeeze().numpy(), y.squeeze().numpy())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

# 随机初始化参数

w = torch.randn(1,1)

b = torch.zeros(1,1)



lr = 0.001 # 学习率



for epoch in range(20000):

    x, y = get_fake_data(batch_size=8)



    # forward

    y_pred = x.mm(w) + b.expand_as(y)

    loss = 0.5 * (y_pred - y) ** 2

    loss = loss.sum()



    # backward: 手动计算梯度

    dloss = 1

    dy_pred = dloss * (y_pred - y)



    dw = x.t().contiguous().mm(dy_pred)

    db = dy_pred.sum()



    # 更新参数

    w.sub_(lr * dw)

    b.sub_(lr * db)



    if epoch % 1000 == 0:

        print("epoch:{}, loss:{}".format(epoch, loss))

        # 画图

        display.clear_output(wait=True)

        x = torch.arange(0, 20).view(-1, 1)    # [20, 1]

        y = x.mm(w) + b.expand_as(x)           # predicted data

        plt.plot(x.numpy(), y.numpy())



        x2, y2 = get_fake_data(batch_size=20)  # true data

        plt.scatter(x2.numpy(), y2.numpy())



        plt.xlim(0,20)

        plt.ylim(0,41)

        plt.show()

        plt.pause(0.5)



print(w.squeeze()[0], b.squeeze()[0])

tensor(2.0264241695) tensor(2.9323694706)