激活函数以及损失函数

sigmoid

sigmoid函数和tanh函数是研究早期被广泛使用的2种激活函数。两者都为S型饱和函数。

  1. 当sigmoid 函数输入的值趋于正无穷或负无穷时，梯度会趋近零，从而发生梯度弥散现象。
  2. sigmoid函数的输出恒为正值，不是以零为中心的，这会导致权值更新时只能朝一个方向更新，从而影响收敛速度。

tanh激活函数是sigmoid 函数的改进版，是以零为中心的对称函数，收敛速度快，不容易出现 loss 值晃动，但是无法解决梯度弥散的问题。

2个函数的计算量都是指数级的，计算相对复杂。softsign 函数是 tanh 函数的改进版，为 S 型饱和函数，以零为中心，值域为（−1，1）。

公式

更多可以直接看

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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
# -*- coding: utf8 -*-
#
import math

import torch
from torch.functional import F

print('sigmoid'.center(60, '-'))


def sigmoid(x):
    return 1 / (1 + math.exp(-x))


print(torch.sigmoid(torch.tensor([1., 2.])))
print([sigmoid(1.), sigmoid(2.)])

print('softmax'.center(60, '-'))


def softmax(xs):
    z_exp = [math.exp(x) for x in xs]
    sum_z_exp = sum(z_exp)
    return [_z_exp / sum_z_exp for _z_exp in z_exp]


print(torch.softmax(torch.tensor([1., 2., 7.]), dim=-1))
print(softmax([1., 2., 7.]))

print('tanh'.center(60, '-'))


def tanh(x):
    return (math.exp(x) - math.exp(-x)) / (math.exp(x) + math.exp(-x))


print(torch.tanh(torch.tensor([1., 2.])))
print([tanh(1.), tanh(2.)])

print('cross_entropy'.center(60, '-'))
import torch


def my_cross_entropy(input, target, reduction="mean"):
    # input.shape: torch.size([-1, class])
    # target.shape: torch.size([-1])
    # reduction = "mean" or "sum"
    # input是模型输出的结果，与target求loss
    # target的长度和input第一维的长度一致
    # target的元素值为目标class
    # reduction默认为mean，即对loss求均值
    # 还有另一种为sum，对loss求和

    # 这里对input所有元素求exp
    exp = torch.exp(input)
    # 根据target的索引，在exp第一维取出元素值，这是softmax的分子
    tmp1 = exp.gather(1, target.unsqueeze(-1)).squeeze()
    # 在exp第一维求和，这是softmax的分母
    tmp2 = exp.sum(1)
    # softmax公式：ei / sum(ej)
    softmax = tmp1 / tmp2
    # cross-entropy公式： -yi * log(pi)
    # 因为target的yi为1，其余为0，所以在tmp1直接把目标拿出来，
    # 公式中的pi就是softmax的结果
    log = -torch.log(softmax)
    # 官方实现中，reduction有mean/sum及none
    # 只是对交叉熵后处理的差别
    if reduction == "mean":
        return log.mean()
    else:
        return log.sum()

# example1
# input = torch.randn(3, 5,)
# target = torch.randint(5, (3,), dtype=torch.int64)
# example2
input = torch.tensor([[0.1, 0.9], [0.9, 0.1]])
target = torch.tensor([1, 0])
# example3
# input = torch.tensor([[0., 1.], [1., 0.]])
# target = torch.tensor([1, 0])
loss1_mean = F.cross_entropy(input, target)
loss2_mean = my_cross_entropy(input, target)
print(loss1_mean)
print(loss2_mean)

loss1_sum = F.cross_entropy(input, target, reduction="sum")
loss2_sum = my_cross_entropy(input, target, reduction="sum")
print(loss1_sum)
print(loss2_sum)


def bce_loss_with_logit(y_pred, y_true, reduction='mean'):
    y_pred = sigmoid(y_pred)

    loss = -y_true * torch.log(y_pred) - (1 - y_true) * torch.log(1 - y_pred)
    if reduction == 'mean':
        return torch.mean(loss)
    raise NotImplementedError

交叉熵

有木有发现，伯努利分布加上log就是交叉熵。

另外其实可以理解交叉熵就是极大似然估计加上log。

如何解释梯度消失呢？

描述

梯度消失是指模型在反向传播的过程中，更上层模型获取到的梯度值越来越小，导致更上层的权重基本保持不变，导致整个模型无法正常收敛以及训练。

原因？
其出现原因在Xavier Glorot和Yoshua Bengio在2010年的一篇论文中阐述了一些观点，包含像当时流行的sigmoid激活函数以及均值为0标准差为1的权重初始化方案，每层输出的方差远大于输入的方差，随着网络的延伸，方差在每一层之后都会增加，直到激活函数在顶层达到饱和为止。而实际像simoid这种激活函数随x的增大其导数值趋向于0,导致在反向传播的过程中，基本没有什么可以传播回去。

解决方式？

他提出应该在每一层网络的输出的方差等于其输入的方差。但是除非该层具有相等数量的输入和神经元，否则这条条件无法满足，故提出一些这种方案，像Xavier初始化或者Glorot初始化。

展开全文 >>

一些mask的操作理解

mask和index在一起操作挺多的，故关于index操作也可以看: 活到老学到老之index操作。

1. 对矩阵获取句子长度

1
2
3
4
5
6
from torch.nn.utils.rnn import pad_sequence

a = [torch.tensor([1,2, 3]), torch.tensor([4,5])]
b = pad_sequence(a, batch_first=True)
mask = b.not_equal(0)
b[mask].split(mask.sum(1).tolist())

2. 计算loss的时候把mask加上

略.

3. 比如三维矩阵操作mask

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
a = torch.arange(24).reshape(2, 3, 4)

Out[28]: 
tensor([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11]],
         
        [[12, 13, 14, 15],
         [16, 17, 18, 19],
         [20, 21, 22, 23]]])



mask = torch.tril(torch.ones(2, 3)).bool()

Out[29]: 
tensor([[ True, False, False],
        [ True,  True, False]])


# 假设mask为下面的如何理解？
a[mask]

Out[30]: 
tensor([[ 0,  1,  2,  3],
        [12, 13, 14, 15],
        [16, 17, 18, 19]])

简单理解，就是将sequence_length中padding位忽略掉。

4. gather

也可以看这里：bert以首字表示词向量(2)。

1
2
# 例如这句，他在ltp中：https://github.com/HIT-SCIR/ltp/blob/f3d4a25ee2fbb71613f76c99a47e70a5445b8c03/ltp/transformer_rel_linear.py#L58 中出现 
input = torch.gather(input, dim=1, index=word_index.unsqueeze(-1).expand(-1, -1, input.size(-1)))

它的完整实验代码如下：

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

def tokenize(form: List[List[str]], tokenizer: PreTrainedTokenizerBase, max_length: int = 128, char_base: bool = False):
    """
    Args:
        form:
        tokenizer:
        max_length:
        char_base: 这里指的是form[即 word]是否是字级别的
    Returns:
    """
    res = tokenizer.batch_encode_plus(
        form,
        is_split_into_words=True,
        max_length=max_length,
        truncation=True,
    )
    result = res.data
    # 可用于长度大于指定长度过滤, overflow指字长度大于指定max_length，如果有cls,sep，那么就算上这个
    result['overflow'] = [len(encoding.overflowing) > 0 for encoding in res.encodings]
    if not char_base:
        word_index = []
        for encoding in res.encodings:
            word_index.append([])

            last_word_idx = -1
            current_length = 0
            for word_idx in encoding.word_ids[1:-1]:
                if word_idx != last_word_idx:
                    word_index[-1].append(current_length)

                current_length += 1
                last_word_idx = word_idx
        result['word_index'] = word_index
        result['word_attention_mask'] = [[True] * len(index) for index in word_index]
    return result


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
# -*- coding: utf8 -*-
#
import torch
from torch import nn
from torch.nn.utils.rnn import pad_sequence
from transformers import AutoModel, AutoTokenizer

from src.conf import PRETRAINED_NAME_OR_PATH
from src.transform import tokenize

tokenizer = AutoTokenizer.from_pretrained(PRETRAINED_NAME_OR_PATH)


class DemoModel(nn.Module):
    def __init__(self):
        super(DemoModel, self).__init__()
        self.transformer = AutoModel.from_pretrained(PRETRAINED_NAME_OR_PATH)

    def forward(self, input_ids, token_type_ids, attention_mask, word_index):
        seq_out = self.transformer(
            input_ids=input_ids,
            token_type_ids=token_type_ids,
            attention_mask=attention_mask
        )[0]
        word_out = torch.cat([seq_out[:, :1, :], torch.gather(
            seq_out[:, 1:, :], dim=1, index=word_index.unsqueeze(-1).expand(-1, -1, seq_out.size(-1))
        )], dim=1)

        return seq_out, word_out[:, 1:, :]


if __name__ == '__main__':
    inputs = [
        ['我', '爱', '北京'],
        ['我', '爱', '北京', '和', '你']
    ]

    rs = tokenize(inputs, tokenizer, 10)

    batch_input_ids = pad_sequence([torch.tensor(i) for i in rs['input_ids']], batch_first=True)
    batch_token_type_ids = pad_sequence([torch.tensor(i) for i in rs['token_type_ids']], batch_first=True)
    batch_attention_mask = pad_sequence([torch.tensor(i) for i in rs['attention_mask']], batch_first=True)
    batch_word_index = pad_sequence([torch.tensor(i) for i in rs['word_index']], batch_first=True)
    batch_word_attention_mask = pad_sequence([torch.tensor(i) for i in rs['word_attention_mask']],
                                             batch_first=True)

    model = DemoModel()
    seq_out, word_out = model(batch_input_ids, batch_token_type_ids, batch_attention_mask, batch_word_index)
    print(seq_out.shape, word_out.shape)
    # torch.Size([2, 6, 256]) torch.Size([2, 5, 256])
    # (1)
    assert (seq_out[0][1] == word_out[0][0]).all()  # 我
    assert (seq_out[0][2] == word_out[0][1]).all()  # 爱
    assert (seq_out[0][3] == word_out[0][2]).all()  # 北京

    assert (seq_out[1][1] == word_out[1][0]).all()  # 我
    assert (seq_out[1][2] == word_out[1][1]).all()  # 爱
    assert (seq_out[1][3] == word_out[1][2]).all()  # 北京
                                                    #
    assert (seq_out[1][5] == word_out[1][3]).all()  # 和
    assert (seq_out[1][6] == word_out[1][4]).all()  # 你

    # （2）对于填充位置的设置value
    new_mask = batch_word_attention_mask.unsqueeze(-1).expand(-1, -1, word_out.size(-1))
    # word_out._masked_fill_(~new_mask, float('-inf')) ，这样做可以加快模型收敛
    # 此处为了演示，所以改下写法
    new_word_out = word_out.masked_fill(~new_mask, float("-inf"))
    assert (seq_out[0][1] == word_out[0][0]).all()  # 我
    assert (seq_out[0][2] == word_out[0][1]).all()  # 爱
    assert (seq_out[0][3] == word_out[0][2]).all()  # 北京

    assert (new_word_out[0][3] == torch.full(new_word_out[0][3].shape, fill_value=float("-inf"))).all()
    assert (new_word_out[0][4] == torch.full(new_word_out[0][4].shape, fill_value=float("-inf"))).all()

    assert (seq_out[1][1] == word_out[1][0]).all()  # 我
    assert (seq_out[1][2] == word_out[1][1]).all()  # 爱
    assert (seq_out[1][3] == word_out[1][2]).all()  # 北京
                                                    #
    assert (seq_out[1][5] == word_out[1][3]).all()  # 和
    assert (seq_out[1][6] == word_out[1][4]).all()  # 你

解释:
word_out表示取首字的向量作为整个词的向量，但是对于长度为padding的，那么取的是首个词的索引，需要mask掉。

比如：
['我', '爱', '北京']，seq_out为(2,6,256)，其中6是['我', '爱', '北京', '和', '你']字的长度，那么 ['我', '爱', '北京']后两位就为padding，word_index为0，这个进行gather的时候就会取到我的向量了，所以这个在后续计算时需要把padding部分给mask掉。

5. masked_fill

1
2
3
4
5
6
a = torch.arange(4).float().reshape(2,2)
b = torch.tensor([[1, 0], [0, 1]]).bool()
a.masked_fill(b, float('-inf'))
Out[44]: 
tensor([[-inf, 1.],
        [2., -inf]])

6. 二维mask -> 三维mask

这个在变成4维（最后一维表示feature）时用到。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
mask = torch.tensor([
        [1, 1, 1, 0],
        [1, 1, 0, 0]
    ])
mask3d = mask.unsqueeze(-1) & mask.unsqueeze(-2)
print(mask3d)

Out:
tensor([[[1, 1, 1, 0],
         [1, 1, 1, 0],
         [1, 1, 1, 0],
         [0, 0, 0, 0]],

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

7. flatten操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
a = torch.arange(12).view(2, 2, 3)
a
Out[39]: 
tensor([[[ 0,  1,  2],
         [ 3,  4,  5]],
        [[ 6,  7,  8],
         [ 9, 10, 11]]])
a.flatten(end_dim=1)
Out[40]: 
tensor([[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8],
        [ 9, 10, 11]])

8. 对角线

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
# -*- coding: utf8 -*-
#
import torch

seq_len = 3


def a():
    """
    tensor([[-inf, 0., 0.],
        [-inf, -inf, 0.],
        [-inf, -inf, -inf]])
    Returns:

    """
    a = torch.arange(0, seq_len)
    mask = a.unsqueeze(0) - a.unsqueeze(1)
    mask = torch.log((mask > 0).to(torch.float))
    print(mask)


def b():
    """
    tensor([[0., 0., 0.],
        [-inf, 0., 0.],
        [-inf, -inf, 0.]])
    Returns:

    """
    mask = torch.triu(torch.ones(seq_len, seq_len))
    mask = torch.log(mask)
    print(mask)

展开全文 >>

mlp反向传播推导

更新

俺是发现了，还是得起一个比较牛逼的名字，不使用任何框架，只使用numpy来实现一个MLP，包括正向，反向，梯度更新等。🐶

—————————-此处分割线—————————-

最近在Youtube上看到一个非常不错以及简洁实现mlp模型的视频，目标为预测两个数相加和，用两个linear，每层的输入或输出为 2, 5, 1

注意：所有代码可在github上找到，一个是mlp.py，为作者实现，另外torch_mlp.py为依据mlp.py的torch实现。

复习下推导…

强烈建议看代码哦🐶

展开全文 >>

expand和unsqueeze在一些情况使用的含义

情况一

input:

1
2
3
4
5
6
7
import torch

# a 模拟的是: batch_size: 2, sequence_length:3, feature: 4
a = torch.arange(24).reshape(2, 3, 4)
# b 代表的是: feature: 4 * 4
b = a.unsqueeze(2).expand(-1, -1, 4, -1) # shape: torch.Size([2, 3, 4, 4])

output:

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

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


b[0]

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

换种说法就是:

a: [B, L, F]
b: [B, L, F, F]

每个字对应一个[F, F]的矩阵
这个矩阵的第i行第j列的元素的含义是：上一时刻tag为i, 这一时刻tag为j的分数。比如应用到一阶马尔可夫相关的模型中。

情况二（这种情况没真实测试过，需谨慎对待）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# b 代表的是: sequence length: 3 * 3
b = a.unsqueeze(1).expand(-1, 3, -1, -1) # shape: torch.Size([2, 3, 3, 4])


b[0]

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

即这个长度为3的句子形成一个首尾的矩阵，最后一维代表相关的概率。

比如在嵌套ner任务中，

我 爱 北 京
我
爱
北 0.03 0.02 0.05 0.9
京

展开全文 >>

我最敬爱的老婆

昨晚10点多突然急性肠炎，躺在床上无心睡眠。前天就有相应症状了，只是没那么明显也没在意。

老婆看我难受，就开始拿手机在网上百度，拉肚子应该吃什么药，氯化钠盐水、抗生素什么的。
我说小区外药店应该还开着吧，老婆遂起床跑出去给我买药。随后我起床上厕所给她发消息说我在网上买，你赶紧回来吧。11点多吃了肠炎宁就睡了。

凌晨1点多肚子咕噜咕噜闹肚子，去了厕所，喝了自创的盐糖水，喝了两口瞬间呕吐。我瞬间觉得不能不看了。

老婆迷迷糊糊的从卧室出来，说你又拉肚子了。我嗯了下。她揉着眼说我陪你去医院吧。老婆拿着上衣，搜了急诊，离住的地方1公里多。路上走着准备打车，可惜没有一辆出租车停，老婆说应该人家是换班了。

到了医院，扫了健康码，登记病情，抽血等待40分钟，1楼查看抽血报告、交钱，2楼拿药，4楼挂水。

终于坐着挂吊水了，前前后后等了那么久。

期间有喝醉酒的和他女朋友发着脾气般的打情骂俏。

我老婆直接怼了回去，能不能小点声，人家还得睡觉呢。

哈哈哈，再也不怂了。

拿着手机又去刷吴亦凡的瓜去了～

觉得这个时刻应该记录下来，遂拍了几张照片，老婆的照片就不放出来了。

等我拍了那几张照片翻回来看时，突然觉得冥冥之中遇到我老婆早已缘分注定，科学的尽头便是神学，更坚定了我的想法。

能遇到我老婆是我人生中最大的福气吧。

展开全文 >>

ubuntu16.04多GPU风扇转速调整

最近闲置出来两块1080ti GPU，内心那叫一个激动哇，虽然有些老，另外训练时转速提不上去，此次就解决这个问题。

方法一（个人只在单GPU上实验成功）

1. 生成xorg.conf

如果:

cannot stat /etc/x11/xorg.conf no such file or directory

1
2
3
4
# 生成这个文件

$ sudo nvidia-xconfig --enable-all-gpus --cool-bits=4

2. vim /etc/x11/xorg.conf

添加Option "Coolbits" "4"到device nvidia 里面.如果有多个就每个都add。

3. reboot

4.nvidia-settings

打开nvidia-settings软件，然后调风扇转速即可。

方法二

使用coolgpus

1. 关闭图形化界面

1
systemctl stop lightgdm  && systemctl lightgdm disable lightgdm

2. 使用coolgpus

1
2
3
4
5
6
7
8
9
10
11
12
13
[Unit]
Description=Headless GPU Fan Control
After=syslog.target

[Service]
ExecStart=/home/ajones/conda/bin/coolgpus --kill 
Restart=on-failure
RestartSec=5s
ExecStop=/bin/kill -2 $MAINPID
KillMode=none 

[Install]
WantedBy=multi-user.target
1
2
sudo systemctl enable coolgpus
sudo systemctl start coolgpus

个人建议

如果使用coolgpus的时候先确保可以正常使用，然后再添加到systemctl里面去。

1
2
3
systemctl stop lightgdm
sudo $(which coolgpus) --speed 99 99

如果可以了再后续操作。

展开全文 >>

lstm使用示例

注意，本文代码来自于plm-nlp-code。

学习任何模型都需要一个简单可行的例子进行说明，我会基于plm-nlp-code的代码进行说明lstm在序列标注和句子极性二分类两个例子的应用。

序列标注

参考文件lstm_postag.py.

1. 加载数据

1
2
#加载数据
train_data, test_data, vocab, pos_vocab = load_treebank()

其中load_treebank代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def load_treebank():
    # 需要翻墙下载，可以自行设置代码
    nltk.set_proxy('http://192.168.0.28:1080')
    # 如果没有的话那么则会下载，否则忽略
    nltk.download('treebank')
    from nltk.corpus import treebank

    sents, postags = zip(*(zip(*sent) for sent in treebank.tagged_sents()))

    vocab = Vocab.build(sents, reserved_tokens=["<pad>"])

    tag_vocab = Vocab.build(postags)

    train_data = [(vocab.convert_tokens_to_ids(sentence), tag_vocab.convert_tokens_to_ids(tags)) for sentence, tags in zip(sents[:3000], postags[:3000])]
    test_data = [(vocab.convert_tokens_to_ids(sentence), tag_vocab.convert_tokens_to_ids(tags)) for sentence, tags in zip(sents[3000:], postags[3000:])]

    return train_data, test_data, vocab, tag_vocab


加载后可以看到，train_data和test_data都是list，其中每一个sample都是tuple,分别是input和target。如下：

1
2
3
4
>>> train_data[0]
>>> Out[1]: 
([2, 3, 4, 5, 6, 7, 4, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18],
 [1, 1, 2, 3, 4, 5, 2, 6, 7, 8, 9, 10, 8, 5, 9, 1, 3, 11])

2. 数据处理

1
2
3
4
5
6
7
8
9
10

# 这个函数就是将其变成等长，填充使用<pad>，至于是0还是1还是其他值并不重要，因为还有mask~
def collate_fn(examples):
    lengths = torch.tensor([len(ex[0]) for ex in examples])
    inputs = [torch.tensor(ex[0]) for ex in examples]
    targets = [torch.tensor(ex[1]) for ex in examples]
    inputs = pad_sequence(inputs, batch_first=True, padding_value=vocab["<pad>"])
    targets = pad_sequence(targets, batch_first=True, padding_value=vocab["<pad>"])
    return inputs, lengths, targets, inputs != vocab["<pad>"]

3. 模型部分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class LSTM(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_class):
        super(LSTM, self).__init__()
        self.embeddings = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)
        self.output = nn.Linear(hidden_dim, num_class)
        init_weights(self)

    def forward(self, inputs, lengths):
        embeddings = self.embeddings(inputs)
        x_pack = pack_padded_sequence(embeddings, lengths, batch_first=True, enforce_sorted=False)
        hidden, (hn, cn) = self.lstm(x_pack)
        hidden, _ = pad_packed_sequence(hidden, batch_first=True)
        outputs = self.output(hidden)
        log_probs = F.log_softmax(outputs, dim=-1)
        return log_probs

其中有几个地方可能需要注意的：

  • pack_padded_sequence和pad_packed_sequence
    因为lstm为rnn模型，样本输入不一定是等长的，那么torch提供了这两个函数进行统一处理，length告诉lstm，等超过length时这个样本后面pad进来的就不再计算了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
>>> seq = torch.tensor([[1,2,0], [3,0,0], [4,5,6]])
>>> lens = [2, 1, 3]
>>> packed = pack_padded_sequence(seq, lens, batch_first=True, enforce_sorted=False)
>>> packed
PackedSequence(data=tensor([4, 1, 3, 5, 2, 6]), batch_sizes=tensor([3, 2, 1]),
                sorted_indices=tensor([2, 0, 1]), unsorted_indices=tensor([1, 2, 0]))
>>> seq_unpacked, lens_unpacked = pad_packed_sequence(packed, batch_first=True)
>>> seq_unpacked
tensor([[1, 2, 0],
        [3, 0, 0],
        [4, 5, 6]])
>>> lens_unpacked
tensor([2, 1, 3])
  • lstm输出

hidden, (hn, cn)分别表示每个timestep的输出,最后一个时刻的每层输出,cn表示保存c的值。

所以可以看到，序列标注会用到每个timestep的输出来表示每个token。

  • F.log_softmax和损失函数计算

如果看源码较多的情况下，你会发现log_softmax或者softmax会和CrossEntropyLoss出现在一起，这里很简单理解，因为CrossEntropyLoss由两个函数组成，log_softmax和NLLLoss，log_softmax或者softmax是做归一化，由分数转成概率，log_softmax是平滑。NLLLoss负责取target index对应的logits score，然后除以总分。目的使之最大。

3. 训练

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#训练过程
nll_loss = nn.NLLLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001) #使用Adam优化器

model.train()
for epoch in range(num_epoch):
    total_loss = 0
    for batch in tqdm(train_data_loader, desc=f"Training Epoch {epoch}"):
        inputs, lengths, targets, mask = [x.to(device) for x in batch]
        lengths = lengths.cpu()
        log_probs = model(inputs, lengths)
        loss = nll_loss(log_probs[mask], targets[mask])
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Loss: {total_loss:.2f}")

这部分没啥好说的了，log_probs为三维矩阵，比如torch.Size([32, 58, 47]),表示batch_size=32,seq_length=58,一共47个tags。

推理部分就是argmax取其最大的tag index，可以看：

1
2
3
4
5
6
7
8
acc = 0
total = 0
for batch in tqdm(test_data_loader, desc=f"Testing"):
    inputs, lengths, targets, mask = [x.to(device) for x in batch]
    with torch.no_grad():
        output = model(inputs, lengths)
        acc += (output.argmax(dim=-1) == targets)[mask].sum().item()
        total += mask.sum().item()

句子极性二分类

参考文件lstm_sent_polarity.py。

这个名字自己起的，任务目标具体就是对输入句子做二分类。

1. 加载数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def load_sentence_polarity():
    nltk.set_proxy('http://192.168.0.28:1080')
    nltk.download('sentence_polarity')
    from nltk.corpus import sentence_polarity

    vocab = Vocab.build(sentence_polarity.sents())

    train_data = [(vocab.convert_tokens_to_ids(sentence), 0)
                  for sentence in sentence_polarity.sents(categories='pos')[:4000]] \
        + [(vocab.convert_tokens_to_ids(sentence), 1)
            for sentence in sentence_polarity.sents(categories='neg')[:4000]]

    test_data = [(vocab.convert_tokens_to_ids(sentence), 0)
                 for sentence in sentence_polarity.sents(categories='pos')[4000:]] \
        + [(vocab.convert_tokens_to_ids(sentence), 1)
            for sentence in sentence_polarity.sents(categories='neg')[4000:]]

    return train_data, test_data, vocab

关于数据格式:

1
2
3
train_data[321]
Out[2]: ([6, 6, 6, 4489, 1337, 15065, 3252, 6], 0)
# 前面部分表示句子的每个token，后面表示label。

label一共有两个，0和1,所以为二分类。

2. 有趣的点

整个训练过程貌似和上例没什么不同，但是可以举几个比较有意思的地方。

  • 关于二分类使用CrossEntropyLoss还是BCELoss

这两者本质是一样的，BCELoss就是CrossEntropyLoss的特例。你可以看loss.py。

BCEWithLogitsLoss和BCELoss的区别就是一个需要用sigmoid一个不需要。

你可以尝试改动这个代码，将作者使用到的log_softmax和NLLLoss改成使用sigmoid和BCELoss。

  • lstm中hn的输出

既然hn表示timestep的最后一个时刻的输出，那么我们也有理由相信，最后一个时刻的feature可以代表整个句子的feature。

那么就需要关注下hn的输出具体是什么样子了。

源码输出example比如:

1
2
hn.shape
Out[2]: torch.Size([1, 32, 256])

其中1是因为num_layers为1，又不是双向lstm，所以为1。

而如果改成双向lstm，bidirectional=True，那么，

1
2
hn.shape
Out[2]: torch.Size([2, 32, 256])

如果num_layers为3,那么：

1
2
hn.shape
Out[2]: torch.Size([6, 32, 256])

到这里我们就要理解下他输出的含义了？

他表示一共有6个层，即3个双向lstm，而双向的实现，就是正向计算一次，反向再计算一次，即[::-1]，那么一共6层。

整个模型更改如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class LSTM(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_class):
        super(LSTM, self).__init__()
        self.embeddings = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True, bidirectional=True, num_layers=3)
        self.output = nn.Linear(hidden_dim * 6, num_class)

    def forward(self, inputs, lengths):
        embeddings = self.embeddings(inputs)
        x_pack = pack_padded_sequence(embeddings, lengths, batch_first=True, enforce_sorted=False)
        hidden, (hn, cn) = self.lstm(x_pack)
        outputs = self.output(hn.permute(1,0,2).reshape(-1, 6 * 256))
        log_probs = F.log_softmax(outputs, dim=-1)
        return log_probs

展开全文 >>

python bdist_wheel

利用cython进行编译成库.

1. setup.py

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
# coding: utf-8
import os
import sysconfig


from setuptools import setup, find_packages

# https://stackoverflow.com/questions/21594925/error-each-element-of-ext-modules-option-must-be-an-extension-instance-or-2-t
# 注意，这个顺序必须在这里，要比setup低.
from Cython.Build import cythonize

from setuptools.command.build_py import build_py as _build_py


def read():
    with open("./requirements.txt", "r") as f:
        return f.readlines()


# Notice1: your modules.
packages = set(find_packages()) | {'your modules.'}

# Notice2: exclude files.
EXCLUDE_FILES = [
    # 'your package/ignore python files.'
    'package/file1.py'

]


def get_ext_paths(root_dir, exclude_files):
    """get filepaths for compilation"""
    paths = []

    for root, dirs, files in os.walk(root_dir):
        for filename in files:
            if os.path.splitext(filename)[1] != '.py':
                continue

            file_path = os.path.join(root, filename)
            if file_path in exclude_files:
                continue

            paths.append(file_path)
    return paths


# noinspection PyPep8Naming
class build_py(_build_py):

    def find_package_modules(self, package, package_dir):
        ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')
        modules = super().find_package_modules(package, package_dir)
        filtered_modules = []
        for (pkg, mod, filepath) in modules:
            if os.path.exists(filepath.replace('.py', ext_suffix)):
                continue
            filtered_modules.append((pkg, mod, filepath,))
        return filtered_modules


setup(
    name='package name', # Notice3
    version='0.3.0',

    ext_modules=cythonize(
        get_ext_paths('project root path', EXCLUDE_FILES), # Notice4
        compiler_directives={'language_level': 3.6}
    ),
    cmdclass={
        'build_py': build_py
    },
    packages=packages,
    include_package_data=True,
    install_requires=read(),
)

2. build

1
2
3
python setup.py build_ext --inplace
python setup.py bdist_wheel

3. 结论

通过这种方式编译成一个库，正常情况下无法查看源码。
在开发过程中，IDE无法自动导入，就正常打包方便开发同学调试、使用，而在生产环境使用2方式进行编译成一个安装包，开发替换一下安装包路径即可。

展开全文 >>

pytorch学习率调整

keras

在keras中，比如动态调整学习率，可以：

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

import tensorflow as tf


def step_decay(epoch):
        if epoch < 3:
            lr = 1e-5
        else:
            lr = 1e-6
        return lr

tf.keras.callbacks.LearningRateScheduler(step_decay, verbose=2)


lr_scheduler

在pytorch中，提供了torch.optim.lr_scheduler

1. StepLR

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
# -*- coding: utf8 -*-
#

import torch
from pyecharts import options
from pyecharts.charts import Line
from torch import optim
from torch.nn import Linear
from torch.optim import lr_scheduler


class TestModel(torch.nn.Module):
    def __init__(self):
        super(TestModel, self).__init__()
        self.linear = Linear(100, 2)

    def forward(self, x):
        return self.linear(x)


def line_graph(xs, ys):
    line = Line()
    line.add_xaxis(xs)
    line.add_yaxis(series_name='学习率', y_axis=ys, is_smooth=True)
    line.set_global_opts(
        title_opts=options.TitleOpts(title='学习率调整图'),
        toolbox_opts=options.ToolboxOpts()
    )
    line.set_series_opts(
        label_opts=options.LabelOpts(is_show=False),
        # markline_opts=options.MarkLineOpts(
        #     # 设置平均值的标记线
        #     data=[options.MarkLineItem(name='平均值', type_='average')],
        #     # 设置最大值的标记线
        #     # data = [options.MarkLineItem(name='最大值', type_='max')]
        # )
    )

    line.render('折线图.html')


model = TestModel()

optimizer = optim.Adam(params=model.parameters(), lr=0.05)

# Assuming optimizer uses lr = 0.05 for all groups
# lr = 0.05     if epoch < 30
# lr = 0.005    if 30 <= epoch < 60
# lr = 0.0005   if 60 <= epoch < 90

scheduler = lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

x = list(range(100))
y = []
for epoch in range(100):
    optimizer.step()
    scheduler.step()
    lr = scheduler.get_lr()
    y.append(scheduler.get_lr()[0])

line_graph(x, y)


2. MultiStepLR

1
2
3
4

scheduler = lr_scheduler.MultiStepLR(optimizer, [30, 80], 0.1)


这个可以设置区间，在30 ~ 80 为一个学习率

3. ExponentialLR

1
scheduler = lr_scheduler.ExponentialLR(optimizer, gamma=0.9)

指数衰减

transformers库

在transformers库中，也提供了一些，比如：

1. get_linear_schedule_with_warmup

学习率预热

1
num_warmup_steps = 0.05 * len(train_dataloader) * epochs
1
2
3
4
5
6
optimizer = optim.Adam(params=model.parameters(), lr=1e-3)

scheduler = get_linear_schedule_with_warmup(
    optimizer=optimizer,
    num_warmup_steps=10000,
    num_training_steps=100000)

学习率先不断上升，然后再不断减小。

在预热期间，学习率从0线性增加到优化器中的初始lr。随后线性降低到0

理论

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

探索世界美好的存在。