公式

说明

1. 所有测试代码以此为准。
2. 以torch0.4.1的代码为准进行debug rnn代码， 可以pip install 指定版本的torch.

从测试代码可以看到：

1. num_layers相当初始化多少层rnn layer，比如此例子的10，
2. input_size表示上一层的hidden_size(例如本例子的embedding)
3. hidden_size表示rnn的输出hidden_size
4. batch_first简单来讲就是内存存储的问题，if batch_first=True，那么维度(batch_size, seq_length, hidden_size)，否则seq_length和batch_size对调，另外cudnn底层就是seq_length放在第一位，torch底层也会根据batch_first进行转换

1. 初始化一些参数

以embedding出来为准，输出维度为: (32, 3, 30)
rnn第一步初始化hx(10, 32, 4)，一共初始化了num_layer=10层，batch_size=32，hidden_size=4，白话文就是每一层rnn都有一个(32, 4)的矩阵来保存最后一个时刻(ht)的结果。

这个可以看class RNNBase(Module):。
另外还有2个weight，2个bias的初始化。即公式中的w和b

2. AutogradRNN

初始化参数后，调用此方法，进行rnn计算，如果支持GPU，就会使用cudnn提供好的，此处忽略这里。

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

def AutogradRNN(mode, input_size, hidden_size, num_layers=1, batch_first=False,
                dropout=0, train=True, bidirectional=False, variable_length=False,
                dropout_state=None, flat_weight=None):
    # 使用不同的cell进行计算，每一层rnn layer即一个cell。
    if mode == 'RNN_RELU':
        cell = RNNReLUCell
    elif mode == 'RNN_TANH':
        cell = RNNTanhCell
    elif mode == 'LSTM':
        cell = LSTMCell
    elif mode == 'GRU':
        cell = GRUCell
    else:
        raise Exception('Unknown mode: {}'.format(mode))
    # rec_factory即表示Recurrent，就是第四步的函数
    rec_factory = variable_recurrent_factory if variable_length else Recurrent

    if bidirectional:
        # 可以看到哦，反向就是进行reverse一下
        # 对应代码：steps = range(input.size(0) - 1, -1, -1) if reverse else range(input.size(0))
        # 意思就是从最后一个时刻反向进行更新hidden_size（不同时刻的y）。
        layer = (rec_factory(cell), rec_factory(cell, reverse=True))
    else:
        layer = (rec_factory(cell),)
    # 这地方疯狂使用闭包...
    func = StackedRNN(layer,
                      num_layers,
                      (mode == 'LSTM'),
                      dropout=dropout,
                      train=train)

    def forward(input, weight, hidden, batch_sizes):
        if batch_first and not variable_length:
            # 囔，这里就会batch_size 和  sequence_length对调
            input = input.transpose(0, 1)

        nexth, output = func(input, hidden, weight, batch_sizes)

        if batch_first and not variable_length:
            output = output.transpose(0, 1)

        return output, nexth

    return forward

3. StackedRNN

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

def StackedRNN(inners, num_layers, lstm=False, dropout=0, train=True):
    
    """
     拿到每一层Recurrent layer计算出来的结果，进行concat到一起进行返回
     
     inner表示 Recurrent，代码如下

    """

    num_directions = len(inners)
    total_layers = num_layers * num_directions

    def forward(input, hidden, weight, batch_sizes):
        """
        input: 3, 32, 30 (sequence_length, batch_size, embedding input hidden_size),
        hidden: 10, 32, 4 (num_layers, batch_size, output hidden_size),
        """
        assert(len(weight) == total_layers)
        next_hidden = []

        if lstm:
            hidden = list(zip(*hidden))
        # 遍历rnn中num_layers
        for i in range(num_layers):
            all_output = []
            for j, inner in enumerate(inners): # inner表示 Recurrent，代码如下
                l = i * num_directions + j

                hy, output = inner(input, hidden[l], weight[l], batch_sizes)
                next_hidden.append(hy)
                all_output.append(output)

            input = torch.cat(all_output, input.dim() - 1)

            if dropout != 0 and i < num_layers - 1:
                input = F.dropout(input, p=dropout, training=train, inplace=False)

        if lstm:
            next_h, next_c = zip(*next_hidden)
            next_hidden = (
                torch.cat(next_h, 0).view(total_layers, *next_h[0].size()),
                torch.cat(next_c, 0).view(total_layers, *next_c[0].size())
            )
        else:
            next_hidden = torch.cat(next_hidden, 0).view(
                total_layers, *next_hidden[0].size())

        return next_hidden, input

    return forward

4. Recurrent

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

def Recurrent(inner, reverse=False):
    """
    表示单层layer的计算
    """
    def forward(input, hidden, weight, batch_sizes):
        """
        input: 3, 32, 30
        hidden: 32, 4 (表示遍历每一个单独的rnn进来，一共10次)
        weight:List[  (4, 30), (4,4), (4, ), (4, ) ]
        """
        output = []
        steps = range(input.size(0) - 1, -1, -1) if reverse else range(input.size(0))
        for i in steps: # steps为3,因为sequence_length为3
            hidden = inner(input[i], hidden, *weight) # hidden就代表上一个时刻的输出， inner为RNNTanhCell，代码如下
            # hack to handle LSTM
            output.append(hidden[0] if isinstance(hidden, tuple) else hidden)

        if reverse:
            output.reverse()
        output = torch.cat(output, 0).view(input.size(0), *output[0].size())
        # 此处hidden就代表最后一个时刻的输出(32, 4)，output表示每一个时刻的输出(3, 32, 4)
        # torch.any(output[-1,:,:] == hidden)
        return hidden, output

    return forward

5. Recurrent中的inner：

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

# 针对rnn
def RNNTanhCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None):
    """
    input: 32, 30
    hidden: 32, 4
    w_ih: 4,30
    w_hh: 4,4
    b_ih: 4
    b_hh: 4
    """
    hy = torch.tanh(F.linear(input, w_ih, b_ih) + F.linear(hidden, w_hh, b_hh))
    return hy

# 针对lstm cell.
def LSTMCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None):
    """
    input: (32, 30)
    hidden: ( (32, 4), (32, 4) )
    w_ih: (16, 30)
    w_hh: (16, 4)
    b_ih: (16, )
    b_hh: (16, )
    """
    if input.is_cuda: # 自行忽略此处代码
        igates = F.linear(input, w_ih)
        hgates = F.linear(hidden[0], w_hh)
        state = fusedBackend.LSTMFused.apply
        return state(igates, hgates, hidden[1]) if b_ih is None else state(igates, hgates, hidden[1], b_ih, b_hh)

    hx, cx = hidden
    # 看到么，也是rnn公式哦
    gates = F.linear(input, w_ih, b_ih) + F.linear(hx, w_hh, b_hh)
    # 但是此处不一样了，在第一维分割4份出来
    ingate, forgetgate, cellgate, outgate = gates.chunk(4, 1)
    # 看到下面这几行公式么，为啥子就能解决梯度消失呢？
    # 神不神奇，意不意外
    ingate = torch.sigmoid(ingate)
    forgetgate = torch.sigmoid(forgetgate)
    cellgate = torch.tanh(cellgate)
    outgate = torch.sigmoid(outgate)

    cy = (forgetgate * cx) + (ingate * cellgate)
    hy = outgate * torch.tanh(cy)
    # hy: (32,4), (32,4)
    return hy, cy

# 针对gru
def GRUCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None):

    if input.is_cuda:
        gi = F.linear(input, w_ih)
        gh = F.linear(hidden, w_hh)
        state = fusedBackend.GRUFused.apply
        return state(gi, gh, hidden) if b_ih is None else state(gi, gh, hidden, b_ih, b_hh)

    # 这里就变了哦
    gi = F.linear(input, w_ih, b_ih)
    gh = F.linear(hidden, w_hh, b_hh)

    i_r, i_i, i_n = gi.chunk(3, 1)
    h_r, h_i, h_n = gh.chunk(3, 1)

    resetgate = torch.sigmoid(i_r + h_r)
    inputgate = torch.sigmoid(i_i + h_i)
    newgate = torch.tanh(i_n + resetgate * h_n)
    hy = newgate + inputgate * (hidden - newgate)

    return hy

6. 测试代码完整如下

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

# -*- coding: utf8 -*-
#
from torch.nn import Embedding, Sigmoid, Linear
from torch.nn.modules.rnn import RNN

import torch
from torch.nn import BCELoss
from torch.optim import RMSprop


class RNNModel(torch.nn.Module):
    def __init__(self):
        super(RNNModel, self).__init__()
        self.embed = Embedding(6, 30)
        self.rnn = RNN(input_size=30, hidden_size=4, batch_first=True, num_layers=10)
        self.linear = Linear(4, 1)

    def forward(self, input):
        input = self.embed(input)
        # rnn_out: (32, 3, 4) 返回batch_size下每个时刻(sequence_length)的最终输出
        # _ : (10, 32, 4) 表示batch_size下每个rnn layer最后一个时刻的输出
        rnn_out, _ = self.rnn(input)
        y_pred = self.linear(_.sum(0))
        return y_pred


class RNNDemo(object):
    def __init__(self):
        self.model = RNNModel()

        self.optim = RMSprop(self.model.parameters())

    def loss(self, y_pred, y_true):
        y_pred = Sigmoid()(y_pred)
        return BCELoss()(y_pred, y_true.float())

    def train(self, x, y):
        for i in range(100):
            for _x, _y in zip(x, y):
                _x = _x.repeat(32, 1)
                _y = _y.repeat(32, 1)
                y_pred = self.model(_x)
                loss = self.loss(y_pred, _y)
                loss.backward()
                print(loss.item())
                self.optim.step()
                self.optim.zero_grad()


if __name__ == '__main__':
    train_data = [
        (['A', 'B', 'C'], 'right'),
        (['C', 'D', 'E'], 'false')
    ]
    id_map = {
        'A': 1,
        'B': 2,
        'C': 3,
        'D': 4,
        'E': 5,
        'right': 6,
        'false': 7

    }
    rnn = RNNDemo()
    rnn.train(
        [torch.tensor([id_map[i] for i in sample[0]]).reshape(1, 3) for sample in train_data],
        [torch.tensor(id_map[sample[1]]).reshape(1, 1) for sample in train_data]
    )

至此，前向过程完结。

1. 什么是条件随机场

条件随机场是一种给定输入随机变量x，求解条件概率p(y|x)的概率无向图模型。用于序列标注任务时，会特例化为线性链条件随机场。此时输入和输出序列为等长。

2. 为什么需要条件随机场

对于序列标注任务，此类任务有分词、词性标注等，本质是对每一个字（假设bert做特征提取）进行预测，然后接全连接层进行softmax激活，如下图所示：

以词性标注任务来讲，x表示观测序列，y表示预测序列，即词性分布。

按照中文使用规律来讲，动词后面接动词的可能性基本不存在（或者对于分词任务来讲蝴后面基本就是蝶），而在上述模型中，观测序列没有考虑彼此之间的关联。
对于一个长度为n的句子，一共有m个词性，那么一共有m * n个可能性。

crf引入了预测序列的关联，并以路径为单元，预测m^n个可能性中求最优的路径。

3. 如何求解loss值

在计算下面条件概率时，引入了以下几个假设进行简化计算：

1

P(y1,…,yn|x1,…,xn)=P(y1,…,yn|x),x=(x1,…,xn)

计算简化

1. 假设该分布呈指数族分布
2. 输出之间是相邻位置关联的
3. 发射概率通过rnn进行获取

对其进行-log，变成相加问题，求其最大似然估计。

其中：

这个函数前一部分表示rnn到输出（标签）的发射概率矩阵，后一部分表示相邻标签的状态转移概率矩阵。

第一部分获取上述公式的计算结果，即分子项的计算结果，为目标的序列的打分结果。计算函数

第二部分是要求解分母项，需要在所有可能的路径上进行打分进行指数求和。计算函数
因为只考虑临近项，那么就可以递归的求出归一化因子，使用动态规划的方式获取所有路径的得分指数和。

4. 预测

在计算好的状态转移矩阵和发射概率矩阵，使用viterbi算法获取序列的最优路径解。

5. 有向无环图的求解（延展）

viterbi算法不是为nlp所生的，求解最优路径也有其他的算法，比如dijkstra，prim等。但是本质区别在于viterbi是动态规划算法，后两者属于贪心算法，计算资源消耗更多。另外动态规划本质是空间换时间。

关于viterbi动态规划求解，求解步骤如下：

从最左边开始，
A1,A2,A3都是起点,A1 -> B1为1, A2 -> B1为3,A3 -> B1(我擦，漏了。。假设为4)，那么A1,A2,A3到B1的最短路径为1（即A1 -> B1）。
同理得到B2的最短路径为2(即A1->B2),到B3的最短路径为1(A1->B3)。

从B1,B2,B3到C1的最短路径为2(即B1 -> C1)，到C2的最短路径为2,(B2 -> C2),后续忽略。那么得到下张图:

可以看出，到C1最短路径为(A1 -> B1 -> C1)，到C2最短路径为(A1 -> B2 -> C2)。

至此，求解过程完毕。

6. 参考

1. https://kexue.fm/archives/5542
2. http://fancyerii.github.io/books/sequential_labeling2/

什么是马尔可夫性质？

“……一个随机过程，在这个过程中，鉴于现在，未来独立于过去。”

假设一个带有公平硬币的简化抛硬币游戏。暂停怀疑并假设马尔可夫性质尚不清楚，我们想预测 10 次翻转后翻转正面的概率。在条件依赖的假设下（硬币具有过去状态的记忆，未来状态取决于过去状态的顺序），我们必须记录导致第 11 次翻转的特定顺序以及这些翻转的联合概率。所以想象在 10 次翻转后，我们有一个随机的正面和反面序列。该序列的联合概率为 0.5^10 = 0.0009765625。在条件依赖下，下一次翻转的概率为 0.0009765625 * 0.5 = 0.00048828125。

这是第 11 次翻转的真实概率吗？一定不行！

我们知道，抛硬币的事件并不取决于之前抛硬币的结果。硬币没有记忆。连续翻转的过程不会对先前的结果进行编码。每次翻转都是一个独特的事件，正面或反面的概率相等，也就是有条件地独立于过去的状态。这就是马尔可夫性质。

什么是马尔科夫模型？

马尔可夫链（模型）描述了一个随机过程，其中未来状态的假设概率仅取决于当前过程状态，而不取决于它之前的任何状态（shocker）。

让我们进入一个简单的例子。假设您想对给定当前状态的狗处于三种状态之一的未来概率进行建模。为此，我们需要指定状态空间、初始概率和转移概率。

想象一下你有一只非常懒惰的胖狗，所以我们将状态空间定义为睡觉、吃饭或大便。我们将初始概率分别设置为 35%、35% 和 30%。

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

import numpy as np
import pandas as pd
import networkx as nx
import matplotlib.pyplot as plt
%matplotlib inline

# create state space and initial state probabilities

states = ['sleeping', 'eating', 'pooping']
pi = [0.35, 0.35, 0.3]
state_space = pd.Series(pi, index=states, name='states')
print(state_space)
print(state_space.sum())

下一步是定义转移概率。它们只是在给定当前状态的情况下保持相同状态或移动到不同状态的概率。

1
2
3
4
5
6
7
8
9
10

q_df = pd.DataFrame(columns=states, index=states)
q_df.loc[states[0]] = [0.4, 0.2, 0.4]
q_df.loc[states[1]] = [0.45, 0.45, 0.1]
q_df.loc[states[2]] = [0.45, 0.25, .3]

print(q_df)

q = q_df.values
print('\n', q, q.shape, '\n')
print(q_df.sum(axis=1))

现在我们已经设置了初始和转移概率，我们可以使用Networkx 包创建一个马尔可夫图。

要做到这一点，需要一点灵活的思维。Networkx 创建 由节点和边组成的图。在我们的玩具示例中，狗的可能状态是节点，边是连接节点的线。转移概率是权重。它们表示在给定当前状态的情况下转换到某个状态的概率。

需要注意的是 networkx 主要处理字典对象。话虽如此，我们需要创建一个字典对象来保存我们的边及其权重。

不错。如果你沿着任何节点的边走，它会告诉你狗转换到另一个状态的概率。例如，如果狗在睡觉，我们可以看到狗有 40% 的机会继续睡觉，40% 的机会狗醒来并拉屎，20% 的机会狗醒来吃东西。

什么是马克可夫隐藏状态

考虑这样一种情况，您的狗行为异常，并且您想对狗的行为是由于疾病或其他方面健康时的古怪行为进行建模的可能性。

在这种情况下，狗的真实状态是未知的，因此 对您隐藏。对此进行建模的一种方法是假设 狗具有 代表真实隐藏状态的可观察行为。让我们来看一个例子。

首先，我们创建我们的状态空间——健康或生病。我们假设它们是等概率的。

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

hidden_states = ['healthy', 'sick']
pi = [0.5, 0.5]
state_space = pd.Series(pi, index=hidden_states, name='states')
print(state_space)
print('\n', state_space.sum())


a_df = pd.DataFrame(columns=hidden_states, index=hidden_states)
a_df.loc[hidden_states[0]] = [0.7, 0.3]
a_df.loc[hidden_states[1]] = [0.4, 0.6]

print(a_df)

a = a_df.values
print('\n', a, a.shape, '\n')
print(a_df.sum(axis=1))

这是它变得更有趣的地方。现在我们创建发射或观测 概率矩阵。该矩阵的大小为 M x O，其中 M 是隐藏状态的数量，O 是可能的可观察状态的数量。

给定当前的可观察状态，发射矩阵告诉我们狗处于隐藏状态之一的概率。

让我们保持与上一个示例相同的可观察状态。狗可以睡觉、吃东西或大便。现在我们做出最好的猜测来填充概率。

看这个图时，将healthy和sick作为同一level,从sleeping，pooping, eating到healthy和sick的边就是发射概率。

隐马尔可夫图稍微复杂一些，但原理是相同的。例如，您会预期，如果您的狗正在进食，那么它健康的可能性很高 (60%)，而生病的可能性非常低 (10%)。

现在，如果您需要根据一系列观察结果随着时间的推移辨别您的狗的健康状况怎么办？

使用Viterbi 算法，我们可以根据观察序列确定最可能的隐藏状态序列。

高的水平，在每个时间步长Viterbi算法的增量，寻找最大 的是得到陈述的任何路径的概率我在时间牛逼，那也 有序列最多时间正确的观察牛逼。

该算法还跟踪每个阶段概率最高的状态。在序列的末尾，算法将向后迭代，选择每个时间步“获胜”的状态，从而创建最可能的路径，或可能导致观察序列的隐藏状态序列。

最终代码：

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
101

# -*- coding: utf8 -*-

import numpy as np

import pandas as pd



def viterbi(pi, a, b, obs):
    """Viterbi algorithm for solving the uncovering problem

    Notebook: C5/C5S3_Viterbi.ipynb

    Args:
        a (np.ndarray): State transition probability matrix of dimension I x I
        pi (np.ndarray): Initial state distribution  of dimension I
        b (np.ndarray): Output probability matrix of dimension I x K
        obs (np.ndarray): Observation sequence of length N

    Returns:
        path (np.ndarray): Optimal state sequence of length N
        delta (np.ndarray): Accumulated probability matrix
        E (np.ndarray): Backtracking matrix
    """
    n_states = a.shape[0]  # Number of states
    T = len(obs)  # Length of observation sequence

    # Initialize D and E matrices
    delta = np.zeros((n_states, T))
    E = np.zeros((n_states, T - 1)).astype(np.int32)
    delta[:, 0] = np.multiply(pi, b[:, obs[0]])

    # Compute D and E in a nested loop
    print('start walk forward'.center(30, '-'))
    for n in range(1, T):
        for i in range(n_states):
            temp_product = np.multiply(a[:, i], delta[:, n - 1])
            delta[i, n] = np.max(temp_product) * b[i, obs[n]]
            E[i, n - 1] = np.argmax(temp_product)
            print('s={s} and t={t}: phi[{s}, {t}] = {phi}'.format(s=i, t=n, phi=E[i, n - 1]))

    # Backtracking
    print('start backtrace'.center(30, '-'))
    path = np.zeros(T).astype(np.int32)
    path[-1] = np.argmax(delta[:, -1])
    for n in range(T - 2, -1, -1):
        path[n] = E[int(path[n + 1]), n]
        print('path[{}] = {}'.format(n, path[n]))
    return path, delta, E




states = ['sleeping', 'eating', 'pooping']
pi = [0.35, 0.35, 0.3]
state_space = pd.Series(pi, index=states, name='states')

q_df = pd.DataFrame(columns=states, index=states)
q_df.loc[states[0]] = [0.4, 0.2, 0.4]
q_df.loc[states[1]] = [0.45, 0.45, 0.1]
q_df.loc[states[2]] = [0.45, 0.25, .3]

q = q_df.values

hidden_states = ['healthy', 'sick']
pi = np.array([0.5, 0.5])
state_space = pd.Series(pi, index=hidden_states, name='states')

a_df = pd.DataFrame(columns=hidden_states, index=hidden_states)
a_df.loc[hidden_states[0]] = [0.7, 0.3]
a_df.loc[hidden_states[1]] = [0.4, 0.6]

a = a_df.values

observable_states = states

b_df = pd.DataFrame(columns=observable_states, index=hidden_states)
b_df.loc[hidden_states[0]] = [0.2, 0.6, 0.2]
b_df.loc[hidden_states[1]] = [0.4, 0.1, 0.5]

b = b_df.values

obs_map = {'sleeping': 0, 'eating': 1, 'pooping': 2}
obs = np.array([1, 1, 2, 1, 0, 1, 2, 1, 0, 2, 2, 0, 1, 0, 1])
inv_obs_map = dict((v,k) for k, v in obs_map.items())
obs_seq = [inv_obs_map[v] for v in list(obs)]

path, delta, phi = viterbi(pi, a, b, obs)
print('\nsingle best state path: \n', path)
print('delta:\n', delta)
print('phi:\n', phi)


state_map = {0:'healthy', 1:'sick'}
state_path = [state_map[v] for v in path]

print(pd.DataFrame()
 .assign(Observation=obs_seq)
 .assign(Best_Path=state_path))

结果：

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

------start walk forward------
s=0 and t=1: phi[0, 1] = 0
s=1 and t=1: phi[1, 1] = 0
s=0 and t=2: phi[0, 2] = 0
s=1 and t=2: phi[1, 2] = 0
s=0 and t=3: phi[0, 3] = 0
s=1 and t=3: phi[1, 3] = 1
s=0 and t=4: phi[0, 4] = 0
s=1 and t=4: phi[1, 4] = 0
s=0 and t=5: phi[0, 5] = 0
s=1 and t=5: phi[1, 5] = 1
s=0 and t=6: phi[0, 6] = 0
s=1 and t=6: phi[1, 6] = 0
s=0 and t=7: phi[0, 7] = 0
s=1 and t=7: phi[1, 7] = 1
s=0 and t=8: phi[0, 8] = 0
s=1 and t=8: phi[1, 8] = 0
s=0 and t=9: phi[0, 9] = 0
s=1 and t=9: phi[1, 9] = 1
s=0 and t=10: phi[0, 10] = 1
s=1 and t=10: phi[1, 10] = 1
s=0 and t=11: phi[0, 11] = 1
s=1 and t=11: phi[1, 11] = 1
s=0 and t=12: phi[0, 12] = 1
s=1 and t=12: phi[1, 12] = 1
s=0 and t=13: phi[0, 13] = 0
s=1 and t=13: phi[1, 13] = 0
s=0 and t=14: phi[0, 14] = 0
s=1 and t=14: phi[1, 14] = 1
-------start backtrace--------
path[13] = 0
path[12] = 0
path[11] = 1
path[10] = 1
path[9] = 1
path[8] = 1
path[7] = 0
path[6] = 0
path[5] = 0
path[4] = 0
path[3] = 0
path[2] = 0
path[1] = 0
path[0] = 0

single best state path: 
 [0 0 0 0 0 0 0 0 1 1 1 1 0 0 0]
delta:
 [[3.00000000e-01 1.26000000e-01 1.76400000e-02 7.40880000e-03
  1.03723200e-03 4.35637440e-04 6.09892416e-05 2.56154815e-05
  3.58616741e-06 5.02063437e-07 7.37725866e-08 2.21317760e-08
  1.59348787e-08 2.23088302e-09 9.36970868e-10]
 [5.00000000e-02 9.00000000e-03 1.89000000e-02 1.13400000e-03
  8.89056000e-04 5.33433600e-05 6.53456160e-05 3.92073696e-06
  3.07385778e-06 9.22157333e-07 2.76647200e-07 6.63953280e-08
  3.98371968e-09 1.91218545e-09 1.14731127e-10]]
phi:
 [[0 0 0 0 0 0 0 0 0 1 1 1 0 0]
 [0 0 1 0 1 0 1 0 1 1 1 1 0 1]]
   Observation Best_Path
0       eating   healthy
1       eating   healthy
2      pooping   healthy
3       eating   healthy
4     sleeping   healthy
5       eating   healthy
6      pooping   healthy
7       eating   healthy
8     sleeping      sick
9      pooping      sick
10     pooping      sick
11    sleeping      sick
12      eating   healthy
13    sleeping   healthy
14      eating   healthy

Process finished with exit code 0

相关代码: https://github.com/geasyheart/algo/commit/6cf0beca368d6c94f4a19c87f43b31e63306e0a3

介绍

下派一个任务,研究下推荐系统,貌似后面和电信搞一个类似电视视频内容推荐之类的项目.

基于流行度的推荐

这个推荐比较简单些,就是根据视频的得分来进行排序,排除掉当前用户已经看过的,剩下的再排序返回给用户就行.

好处是这是一个非常简单但是非常有效的算法,基本来说我们看视频都是根据播放量高、得分高进行播放。
坏处是有一个长尾效应，过于小众的基本不会推荐出来，看看京东，其实也有点类似这样～

关于视频的打分，这个可以根据一些特征工程来获得，比如用户点赞，收藏，喜欢，浏览，基于不同权重进行得分。
如果没有这些特征，可以手动构造这些视频的得分（不行可以抓豆瓣。。。）甚者直接根据用户的浏览记录进行排序就能上线。

对于长尾效应，可以运营分出几大类，根据类别再进行排序也是可以一定程度多了新的选择。
对于冷启动，这个咋说呢，一开始肯定都是没有数据的，可以先按照热度排个序上了线后续优化。

基于内容的推荐

这是一个基于内容特征进行推荐的方式。

比如说，张三看过言情、虐心电影A，那如果电影B也具有这种feature，就可以计算这些feature的相似度进行排序推荐给A。
至于特征有多少，emmm，可以打标签，比如导演，演员，简介tfidf，小清新，狗血之类。

另外如果基于深度学习的话，就要获得视频的向量，根据向量来进行排序推荐给A。

协同过滤的推荐

协同过滤推荐重点在于协同。这里可以分成两类：

1. 基于用户的协同过滤
2. 基于内容的协同过滤

啥意思呢，用户张三喜欢看A，B，D电视剧，用户李四喜欢看A，D，那么张三和李四是挺相似的，那么就可以推荐给李四用户B电视剧。这个就叫基于用户的协同过滤。

至于特征，也可以说张三和李四有其他特征，比如都是男的，年龄相仿，兴趣相仿，那就可以认为是同一类人，那推荐的内容也是可以类似的。

基于内容的呢，其实和上面的基于内容的推荐是挺类似的。

核心点是基于历史的数据进行来预测用户的相似程度来进行推荐内容，将人和人也关联到一起。

一种做法通过SVD（奇异值分解）来实现。
比如下面例子：

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

# -*- coding: utf8 -*-
#
import numpy as np
import pandas as pd
from scipy.sparse import csc_matrix
from scipy.sparse.linalg import svds

# value为用户对不同的item的喜欢程度
df = pd.DataFrame({"军事": [0, 10, 7], '言情': [10, 3, 0], '动漫': [5, 3, 0], '小说': [3, 5, 0]}, dtype='float64')
#    军事    言情   动漫   小说
# 0   0.0  10.0  5.0  3.0
# 1  10.0   3.0  3.0  5.0
# 2   7.0   0.0  0.0  0.0
# 可以看到user0喜欢言情和动漫，用户1、2喜欢军事

U, s, Vt = svds(csc_matrix(df), k=2) # K可以理解成用多少feature来进行表示，主要用于降维和减少稀疏性，超参数

matrix_new = U.dot(np.diag(s)).dot(Vt)
print(matrix_new)
# [[-0.1314746 ,  9.7949323 ,  5.08515349,  3.45149176],
# [10.28341738,  3.44206066,  2.81643619,  4.02672754],
# [ 6.55257518, -0.6978715 ,  0.28978818,  1.53648395]] # 推荐顺序-> 军事,小说,动漫

# ################################ 推荐
item_user_matrix = matrix_new.transpose()
svd_df = pd.DataFrame(item_user_matrix, columns=['user0', 'user1', 'user2'], index=df.columns)
svd_df['user2'].sort_values(ascending=False)


# Out[18]:
# 军事    6.552575
# 小说    1.536484
# 动漫    0.289788
# 言情   -0.697871
# Name: 2, dtype: float64

# ###################################### 计算用户喜好相似度
def cos(vec1, vec2):
    return vec1.dot(vec2) / np.linalg.norm(vec1) * np.linalg.norm(vec2)


for i in range(U.shape[0]):
    for j in range(i + 1, U.shape[0]):
        vec1 = U[i, :]
        vec2 = U[j, :]
        print(f'User{i}和User{j}的相似度:{cos(vec1, vec2)}')
# User0和User1的相似度:0.11017178104828797
# User0和User2的相似度:-0.11652231240752381
# User1和User2的相似度:0.28527719555421444

# 那同理，item之间的相似度也可以简单通过这种方式进行计算

更新

啦啦啦，现在也可以尝试其他做法，比如wide&deep，DSSM，DeepFM，pairwise,pointwise，具体看业务。

以后再有机会更新。

再次更新

前段时间面试了一个大佬，他之前在腾讯做过腾讯新闻个性化推荐，在2016～2019年期间，他的做法是这样的，
一共有三个graph，user，tag，article，将这三个进行关联到一起形成user-tag-article网络，基于这个网络进行随机游走，然后使用word2vec进行向量化，进行推荐。

虽然这种技术可能放到现在来说有点落伍了，但是对这种做法挺感兴趣，整体实现思路也并不难，所以尝试了下。

我将代码放到了graph word2vec embedding，感兴趣的话可以看看～

问题来源

之前线上代码更新的时候报了一个migration类似的错误，报错信息如下:

1
2

django.db.utils.OperationalError: (1054, "Unknown column 'age' in 'field list'")

出现错误的代码模型文件为:

出现错误的代码对应的migration/001.py文件为:

简单描述就是:

migration/001.py执行了插入动作，如上图红框所示，后台一位同学使用import模型的方式执行了一段python代码，简单来看这里insert没有任何问题，而报"Unknown column 'age' in 'field list'"这个错误是因为age字段是在migration/001.py之后才创建的，线上代码更新时那么导入的模型是有age字段的，而数据库是没有这个字段的。插入的时候没有给age值，所以django认为age这个字段是应该存在的，但是数据库实际没有age字段，所以出现了这个问题。

解决方式

其实这里应该有三种解决方式的:

1. 在migration/001.py并没有对age字段做任何操作，那么理论上来说这条语句应该通过的，如果通过不了，那应该也是sql语句本身除了问题，不过这个不是这么实现的，所以这种方式我只假设是可以解决这个问题的。
2. django引入了ModelState的概念来解决这个问题。(而我们系统没有这个概念，所以改写成裸sql的方式。。。)
3. 直接将模型引入到migration文件内（不过这个如果有外键或者python文件很复杂的话就不如写裸sql了，虽然有时候裸sql也很难写。。。）

漫谈migration

所有代码均在django/db/migrations文件夹下。

先看makemigration的实现方式

首先初始化MigrationLoader实例，第一步执行build_graph函数，如下图所示。

self.load_disk()就是查找项目里面所有的migration文件，然后保存到disk_migrations变量里面。
整个感兴趣的，在于这个MigrationGraph，这个为有向无环图，四个for循环构造出disk migrations所有的信息，然后是一些校验。

检测迁移历史记录的一致性

这里检查的已经保存到数据库的记录的parent是否在graph nodes里面，如果没有，则非一致性，那么则报错。

检测每一个migration directory是否有多个leaf nodes

如果有多个leaf nodes, 那么则是否merge，合并到一起。

至此，该检查的也检查了，剩下一步就是如何做diff操作，然后生成新的migration文件。

django会根据graph和数据库migration_history
的记录生成两个ProjectState,那么最终比较这两个ProjectState的不同。

而在生成ProjectState的时候，有一步叫做self.graph.make_state()，如下图

这一步会根据disk migrations生成的graph，然后根据leaf nodes通过dfs进行遍历然后生成ModelState,所以在这里age字段不会在001.py存在的。(这个地方就是django解决代码更新的地方。6啊)

所以下一步就是如何做diff操作，然后生成新的migration文件，简单如下图所示，此处忽略。

后记

简单来讲，django使用MigrationGraph构造出disk migration和database migration，然后根据sorted(migration)构造出时间线，获得ProjectState以及相应的ModelState,所以在做migrations.RunPython方法的时候，传入的参数models即为相应对应时刻的ModelState，从而避免了代码更新而miration未及时更新导致在orm层面做些操作的时候导致的问题。重点可以看看Graph这里以及如何构造State的。其余自行理解。后面migrate也是类似，以后慢慢讲。

使用graph同步组织架构图一个简单例子

miniconda快速创建python环境

1.下载

https://docs.conda.io/en/latest/miniconda.html

2. 安装

1
2
3
4
5

chmod +x /code/packages/Miniconda3-latest-Linux-x86_64.sh && \
     /code/packages/Miniconda3-latest-Linux-x86_64.sh -b -p /opt/conda && \
     /opt/conda/bin/conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/ && \
     /opt/conda/bin/conda install -y python=3.8

3. 使用

1
2
3

/opt/conda/bin/python3.8 -m venv ~/venv
# https://download.pytorch.org/whl/lts/1.8/torch_lts.html
wget -c https://download.pytorch.org/whl/lts/1.8/cu102/torch-1.8.1%2Bcu102-cp38-cp38-linux_x86_64.whl

cuda安装源（强烈推荐）

http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/

年终总结了，想了好久，一直想着应该总结些什么，但是总要开一个头。

相比南京，上海这里更多元（N维特征向量~），人来人往的人群，挤成狗而每天吵不完架的地铁，好吃的南京东路，标志性的打卡地方，惨淡的生活气息，努力的小伙伴，发挥着自己的才智和社交，这是我认识的北上广的生活。

这一年最重要的是遇到了自己喜欢的人，就像是突然抬起了头看了下天空，看，这更像是人生。

很遥远，但，就在那。

许巍的《故乡》中唱到，“你在我的心里永远是故乡”。

人生中还有比这更值得炫耀与努力的事情吗，貌似只有一个亿的小目标了~

如果不踏出这一步，人生一大遗憾。

踏出了，不知道。

但是不后悔。

我还年轻。

才28，算什么。

假设训练GPU不在自己机子上（悲伤脸），远程连接后，直接python train.py，但是如果一旦网络不稳定导致ssh断了，那这训练了一两天的心血可就白费了，所以需要一种简便的方式来后台运行，实现方式有多种，作为一个守护进程，比如supervisor或者systemctl那一些，但是对于算法人员来说这些都太复杂而不简单使用，所以此处推荐tmux。

使用步骤：

1
2
3
4
5
6
7
8
9
10

$ tmux
$(tmux) source venv/bin/activate
$(tmux) python train.py
$(tmux) 快捷键 `ctrl + b`，然后不松开按`d`
0: 1 windows (created .....) [215x57]
$ tmux ls
0: 1 windows (created .....) [215x57]

$ tmux attach -t 0 # 进入到tmux

万事大吉，退出ssh后训练保持运行。

爬虫与反爬虫，是一个很不阳光的行业。

这里说的不阳光，有两个含义。

第一是，这个行业是隐藏在地下的，一般很少被曝光出来。很多公司对外都不会宣称自己有爬虫团队，甚至隐瞒自己有反爬虫团队的事实。这可能是出于公司战略角度来看的，与技术无关。

第二是，这个行业并不是一个很积极向上的行业。很多人在这个行业摸爬滚打了多年，积攒了大量的经验，但是悲哀的发现，这些经验很难兑换成闪光的简历。面试的时候，因为双方爬虫理念或者反爬虫理念不同，也很可能互不认可，影响自己的求职之路。本来程序员就有“文人相轻”的倾向，何况理念真的大不同。

然而这就是程序员的宿命。不管这个行业有多么的不阳光，依然无法阻挡大量的人进入这个行业，因为有公司的需求。

那么，公司到底有什么样的需求，导致了我们真的需要爬虫 / 反爬虫呢？

反爬虫很好理解，有了爬虫我们自然要反爬虫。对于程序员来说，哪怕仅仅是出于“我就是要证明我技术比你好”的目的，也会去做。对于公司来说，意义更加重大，最少，也能降低服务器负载，光凭这一点，反爬虫就有充足的生存价值。

那么爬虫呢？

最早的爬虫起源于搜索引擎。搜索引擎是善意的爬虫，可以检索你的一切信息，并提供给其他用户访问。为此他们还专门定义了 robots.txt 文件，作为君子协定，这是一个双赢的局面。

然而事情很快被一些人破坏了。爬虫很快就变的不再“君子”了。

后来有了“大数据”。无数的媒体鼓吹大数据是未来的趋势，吸引了一批又一批的炮灰去创办大数据公司。这些人手头根本没有大数据，他们的数据只要用一个 U 盘就可以装的下，怎么好意思叫大数据呢？这么点数据根本忽悠不了投资者。于是他们开始写爬虫，拼命地爬取各个公司的数据。很快他们的数据，就无法用一个 U 盘装下了。这个时候终于可以休息休息，然后出去吹嘘融资啦。

然而可悲的是，大容量 U 盘不断地在发布。他们总是在拼命地追赶存储增加的速度。

以上是爬虫与反爬虫的历史。

一. 爬虫反爬虫运行现状

电子商务行业的爬虫与反爬虫更有趣一些，最初的爬虫需求来源于比价。

这是某些电商网站的核心业务。大家如果买商品的时候，是一个价格敏感型用户的话，很可能用过网上的比价功能 (真心很好用啊)。毫无悬念，他们会使用爬虫技术来爬取所有相关电商的价格。他们的爬虫还是比较温柔的，对大家的服务器不会造成太大的压力。

然而，这并不意味着大家喜欢被他爬取。毕竟这对其他电商是不利的。于是需要通过技术手段来做反爬虫。

按照技术人员的想法，对方用技术怼过来，我们就要用技术怼回去，不能怂啊。这个想法是很好的，但是实际应用起来根本不是这么回事。

诚然，技术是很重要的，但是实际操作上，更重要的是套路。谁的套路更深，谁就能玩弄对方于鼓掌之中。谁的套路不行，有再好的技术，也只能被耍的团团转。这个虽然有点伤技术人员的自尊，然而，我们也不是第一天被伤自尊了。大家应该早就习惯了吧。

1. 真实世界的爬虫比例

大家应该听过一句话吧，大概意思是说，整个互联网上大概有 50% 以上的流量其实是爬虫。第一次听这句话的时候，我还不是很相信，我觉得这个说法实在是太夸张了。怎么可能爬虫比人还多呢？ 爬虫毕竟只是个辅助而已。

现在做了这么久的反爬虫，我依然觉得这句话太夸张了。50%？你在逗我？就这么少的量？

举个例子，某公司，某个页面的接口，每分钟访问量是 1.2 万左右。这里面有多少是正常用户呢？

50%？60%？还是？

正确答案是：500 以下。

也就是说，一个单独的页面，12000 的访问量里，有 500 是正常用户，其余是爬虫。

注意，统计爬虫的时候，考虑到你不可能识别出所有的爬虫，因此，这 500 个用户里面，其实还隐藏着一些爬虫。那么爬虫率大概是：(12000-500)/12000=95.8%

这个数字你猜到了吗？

这么大的爬虫量，这么少的用户量，大家到底是在干什么？ 是什么原因导致了明明是百人级别的生意，却需要万级别的爬虫来做辅助？ 95% 以上，19 保 1？

答案可能会相当令人喷饭。这些爬虫大部分是由于决策失误导致的。

2. 哭笑不得的决策思路

举个例子，这个世界存在 3 家公司，售卖相同的电商产品。三家公司的名字分别是 A，B，C。

这个时候，客户去 A 公司查询了下某商品的价格，看了下发现价格不好。于是他不打算买了。他对整个行业的订单贡献为 0。

然而 A 公司的后台会检测到，我们有个客户流失了，原因是他来查询了一个商品，这个商品我们的价格不好。没关系，我去爬爬别人试试。于是他分别爬取了 B 公司和 C 公司。

B 公司的后台检测到有人来查询价格，但是呢，最终没有下单。他会认为，嗯，我们流失了一个客户。怎么办呢？

我可以爬爬看，别人什么价格。于是他爬取了 A 和 C。

C 公司的后台检测到有人来查询价格。。。。。

过了一段时间，三家公司的服务器分别报警，访问量过高。三家公司的 CTO 也很纳闷，没有生成任何订单啊，怎么访问量这么高？ 一定是其他两家禽兽写的爬虫没有限制好频率。妈的，老子要报仇。于是分别做反爬虫，不让对方抓自己的数据。然后进一步强化自己的爬虫团队抓别人的数据。一定要做到：宁叫我抓天下人，休叫天下人抓我。然后，做反爬虫的就要加班天天研究如何拦截爬虫。做爬虫的被拦截了，就要天天研究如何破解反爬虫策略。大家就这么把资源全都浪费在没用的地方了。直到大家合并了，才会心平气和的坐下来谈谈，都少抓点。

最近国内的公司有大量的合并，我猜这种“心平气和”应该不少吧？

二. 爬虫反爬虫技术现状

下面我们谈谈，爬虫和反爬虫分别都是怎么做的。

1. 为 python 平反

首先是爬虫。爬虫教程你到处都可以搜的到，大部分是 python 写的。我曾经在一篇文章提到过：用 python 写的爬虫是最薄弱的，因为天生并不适合破解反爬虫逻辑，因为反爬虫都是用 javascript 来处理。然而慢慢的，我发现这个理解有点问题（当然我如果说我当时是出于工作需要而有意黑 python 你们信吗。。。）。

Python 的确不适合写反爬虫逻辑，但是 python 是一门胶水语言，他适合捆绑任何一种框架。而反爬虫策略经常会变化的翻天覆地，需要对代码进行大刀阔斧的重构，甚至重写。这种情况下，python 不失为一种合适的解决方案。

举个例子，你之前是用 selenium 爬取对方的站点，后来你发现自己被封了，而且封锁方式十分隐蔽，完全搞不清到底是如何封的，你会怎么办？你会跟踪 selenium 的源码来找到出错的地方吗？

你不会。你只会换个框架，用另一种方式来爬取。然后你就把两个框架都浅尝辄止地用了下，一个都没有深入研究过。因为没等你研究好，也许人家又换方式了。你不得不再找个框架来爬取。毕竟，老板等着明天早上开会要数据呢。老板一般都是早上八九点开会，所以你七点之前必须搞定。等你厌倦了，打算换个工作的时候，简历上又只能写“了解ｎ个框架的使用”，仅此而已。

这就是爬虫工程师的宿命，爬虫工程师比外包还可怜。外包虽然不容易积累技术，但是好歹有正常上下班时间，爬虫工程师连这个权利都没有。

然而反爬虫工程师就不可怜了吗？也不是的。反爬虫有个天生的死穴，就是：误伤率。

2. 无法绕开的误伤率

我们首先谈谈，面对对方的爬虫，你的第一反应是什么？

如果限定时间的话，大部分人给我的答案都是：封杀对方的 IP。

然而，问题就出在，IP 不是每人一个的。大的公司有出口 IP，ISP 有的时候会劫持流量让你们走代理，有的人天生喜欢挂代理，有的人为了翻墙 24 小时挂 vpn，最坑的是，现在是移动互联网时代，你如果封了一个 IP？不好意思，这是中国联通的 4G 网络，5 分钟之前还是别人，5 分钟之后就换人了哦！

因此，封 IP 的误伤指数最高。并且，效果又是最差的。因为现在即使是最菜的新手，也知道用代理池了。你们可以去淘宝看下，几十万的代理价值多少钱。我们就不谈到处都有的免费代理了。

也有人说：我可以扫描对方端口，如果开放了代理端口，那就意味着是个代理，我就可以封杀了呀。

事实是残酷的。我曾经封杀过一个 IP，因为他开放了一个代理端口，而且是个很小众的代理端口。不出一天就有人来报事件，说我们一个分公司被拦截了。我一查 IP，还真是我封的 IP。我就很郁闷地问他们 IT，开这个端口干什么？他说做邮件服务器啊。我说为啥要用这么奇怪的端口？他说，这不是怕别人猜出来么？我就随便取了个。

扫描端口的进阶版，还有一种方式，就是去订单库查找这个 IP 是否下过订单，如果没有，那么就是安全的。如果有，那就不安全。有很多网站会使用这个方法。然而这其实只是一种自欺欺人的办法而已。只需要下一单，就可以永久洗白自己的 IP，天下还有比这更便宜的生意吗？

因此，封 IP，以及封 IP 的进阶版：扫描端口再封 IP，都是没用的。根本不要考虑从 IP 下手，因为对手会用大量的时间考虑如何躲避 IP 封锁，你干嘛和人家硬刚呢。这没有任何意义。

那么，下一步你会考虑到什么？

很多站点的工程师会考虑：既然没办法阻止对方，那我就让它变的不可读吧。我会用图片来渲染关键信息，比如价格。这样，人眼可见，机器识别不出来。

这个想法曾经是正确的，然而，坑爹的技术发展，带给我们一个坑爹的技术，叫机器学习。顺便带动了一个行业的迅猛发展，叫 OCR。很快，识别图像就不再是任何难题了。甚至连人眼都很难识别的验证码，有的 OCR 都能搞定，比我肉眼识别率都高。更何况，现在有了打码平台，用资本都可以搞定，都不需要技术。

那么，下一步你会考虑什么？

这个时候，后端工程师已经没有太多的办法可以搞了。　不过后端搞不定的事情，一般都推给前端啊，前端从来都是后端搞不定问题时的背锅侠。　多少年来我们都是这么过来的。前端工程师这个时候就要勇敢地站出来了：

“都不要得瑟了，来比比谁的前端知识牛逼，你牛逼我就让你爬。”

我不知道这篇文章的读者里有多少前端工程师，我只是想顺便提一下：你们以后将会是更加抢手的人才。

3. 前端工程师的逆袭

我们知道，一个数据要显示到前端，不仅仅是后端输出就完事了，前端要做大量的事情，　比如取到 json 之后，至少要用 template 转成 html 吧？ 这已经是步骤最少最简单的了。然后你总要用 css 渲染下吧？ 这也不是什么难事。

等等，你还记得自己第一次做这个事情的时候的经历吗？真的，不是什么难事吗？

有没有经历过，一个 html 标签拼错，或者没有闭合，导致页面错乱？一个 css 没弄好，导致整个页面都不知道飘到哪去了？

这些事情，你是不是很想让别人再经历一次？

这件事情充分说明了：让一个资深的前端工程师来把事情搞复杂一点，对方如果配备了资深前端工程师来破解，也需要耗费 3 倍以上的时间。毕竟是读别人的代码，别人写代码用了一分钟，你总是要读两分钟，然后骂一分钟吧？这已经算很少的了。如果对方没有配备前端工程师。。。那么经过一段时间，他们会成长为前端工程师。

之后，由于前端工程师的待遇比爬虫工程师稍好一些，他们很快会离职做前端，既缓解了前端人才缺口，又可以让对方缺人，重招。而他们一般是招后端做爬虫，这些人需要再接受一次折磨，再次成长为前端工程师。这不是很好的事情吗。

所以，如果你手下的爬虫工程师离职率很高，请仔细思考下，是不是自己的招聘方向有问题。

那么前端最坑爹的技术是什么呢？前端最坑爹的，也是最强大的，就是我们的：javascript。

Javascript 有大量的花样可以玩，毫不夸张的说，一周换一个 feature(bug) 给对方学习，一年不带重样的。这个时候你就相当于一个面试官，对方要通过你的面试才行。

举个例子，Array.prototype 里，有没有 map 啊？什么时候有啊？你说你是 xx 浏览器，那你这个应该是有还是应该没有啊？你说这个可以有啊？可是这个真没有啊。那 [] 能不能在 string 里面获取字符啊？哪个浏览器可以哪个不行啊？咦你为什么支持 webkit 前缀啊？等等，刚刚你还支持怎么现在不支持了啊？你声明的不对啊。

这些对于前端都是简单的知识，已经习以为常了。但是对于后端来说简直就是噩梦。

然而，前端人员自己作死，研究出了一个东西，叫：nodejs。基于 v8，秒杀所有的 js 运行。

不过 nodejs 实现了大量的 feature，都是浏览器不存在的。你随随便便访问一些东西（比如你为什么会支持 process.exit），都会把 node 坑的好惨好惨。而且。。。浏览器里的 js，你拉到后台用 nodejs 跑，你是不是想到了什么安全漏洞？这个是不是叫，代码与数据混合？如果他在 js 里跑点恶心的代码，浏览器不支持但是 node 支持怎么办？

还好，爬虫工程师还有 phantomjs。但是，你怎么没有定位啊？ 哈哈，你终于模拟出了定位，但是不对啊，根据我当前设置的安全策略你现在不应该能定位啊？你是怎么定出来的？连 phantomjs 的作者自己都维护不下去了，你真的愿意继续用吗？

当然了，最终，所有的反爬虫策略都逃不脱被破解的命运。但是这需要时间，反爬虫需要做的就是频繁发布，拖垮对方。如果对方两天可以破解你的系统，你就一天一发布，那么你就是安全的。这个系统甚至可以改名叫做“每天一道反爬题，轻轻松松学前端”。

4. 误伤，还是误伤

这又回到了我们开始提到的“误伤率”的问题了。我们知道，发布越频繁，出问题的概率越高。那么，如何在频繁发布的情况下，还能做到少出问题呢？

此外还有一个问题，我们写了大量的“不可读代码”给对方，的确能给对方造成大量的压力，但是，这些代码我们自己也要维护啊。如果有一天忽然说，没人爬我们了，你们把代码下线掉吧。这个时候写代码的人已经不在了，你们怎么知道如何下线这些代码呢？

这两个问题我暂时不能公布我们的做法，但是大家都是聪明人，应该都是有自己的方案的，软件行业之所以忙的不得了，无非就是在折腾两件事，一个是如何将代码拆分开，一个是如何将代码合并起来。关于误伤率，我只提一个小的 tip：你可以只开启反爬虫，但是不拦截，先放着，发统计信息给自己，相当于模拟演练。等统计的差不多了，发现真的开启了也不会有什么问题，那就开启拦截或者开启造假。

这里就引发了一个问题，往往一个公司的各个频道，爬取难度是不一样的。原因就是，误伤检测这种东西与业务相关，公司的基础部门很难做出通用的。只能各个部门自己做。甚至有的部门做了有的没做。因此引发了爬虫界一个奇葩的通用做法：如果 PC 页面爬不到，　就去 H5 试试。如果 H5 很麻烦，就去 PC 碰碰运气。

三. 爬虫反爬虫套路现状

那么一旦有发现对方数据造假怎么办？

早期的时候，大家都是要抽查数据，通过数据来检测对方是否有造假。这个需要人工核对，成本非常高。可是那已经是洪荒时代的事情了。如果你们公司还在通过这种方式来检测，说明你们的技术还比较落伍。之前我们的竞争对手是这么干的：他们会抓取我们两次，一次是他们解密出来 key 之后，用正经方式来抓取，这次的结果定为 A。一次是不带 key，直接来抓，这次的结果定为 B。根据前文描述，我们可以知道，B 一定是错误的。那么如果 A 与 B 相等，说明自己中招了。这个时候会停掉爬虫，重新破解。

1. 不要回应

所以之前有一篇关于爬虫的文章，说如何破解我们的。一直有人要我回复下。我一直觉得没什么可以回复的。

第一，反爬虫被破解了是正常的。这个世界上有个万能的爬虫手段，叫“人肉爬虫”。假设我们就是有钱，在印度开个分公司，每天雇便宜的劳动力用鼠标直接来点，你能拿我怎么办？ 第二，我们真正关心的是后续的这些套路。而我读了那篇文章，发现只是调用了 selenium 并且拿到了结果，就认为自己成功了。

我相信你读到这里，应该已经明白为什么我不愿意回复了。我们最重要的是工作，而不是谁打谁的脸。大家如果经常混技术社区就会发现，每天热衷于打别人脸的，一般技术都不是很好。

当然这并不代表我们技术天下第一什么的。我们每天面对大量的爬虫，还是遇到过很多高手的。就如同武侠小说里一样，高手一般都比较低调，他们默默地拿走数据，很难被发现，而且频率极低，不会影响我们的考评。你们应该明白，这是智商与情商兼具的高手了。

我们还碰到拉走我们 js，砍掉无用的部分直接解出 key，相当高效不拖泥带水的爬虫，一点废请求都没有（相比某些爬虫教程，总是教你多访问写没用的 url 免得被发现，真的不知道高到哪里去了。这样做除了会导致机器报警，导致对方加班封锁以外，对你自己没有任何好处）。

而我们能发现这一点仅仅是是因为他低调地写了一篇博客，通篇只介绍技术，没有提任何没用的东西。

这里我只是顺便发了点小牢骚，就是希望后续不要总是有人让我回应一些关于爬虫的文章。线下我认识很多爬虫工程师，水平真的很好，也真的很低调（不然你以为我是怎么知道如何对付爬虫的。。。），大家都是一起混的，不会产生“一定要互相打脸”的情绪。

2. 进化

早期我们和竞争对手打的时候，双方的技术都比较初级。后来慢慢的，爬虫在升级，反爬虫也在升级。这个我们称为“进化”。我们曾经给对方放过水，来试图拖慢他们的进化速度。然而，效果不是特别理想。爬虫是否进化，取决于爬虫工程师自己的 KPI，而不是反爬虫的进化速度。

后期打到白热化的时候，用的技术越来越匪夷所思。举个例子，很多人会提，做反爬虫会用到 canvas 指纹，并认为是最高境界。其实这个东西对于反爬虫来说也只是个辅助，canvas 指纹的含义是，因为不同硬件对 canvas 支持不同，因此你只要画一个很复杂的 canvas，那么得出的 image，总是存在像素级别的误差。考虑到爬虫代码都是统一的，就算起 selenium，也是 ghost 的，因此指纹一般都是一致的，因此绕过几率非常低。

但是！这个东西天生有两个缺陷。第一是，无法验证合法性。当然了，你可以用非对称加密来保证合法，但是这个并不靠谱。其次，canvas 的冲突概率非常高，远远不是作者宣称的那样，冲突率极低。也许在国外冲突是比较低，因为国外的语言比较多。但是国内公司通常是 IT 统一装机，无论是软件还是硬件都惊人的一致。我们测试 canvas 指纹的时候，在携程内部随便找了 20 多台机器，得出的指纹都完全一样，一丁点差别都没有。因此，有些“高级技巧”其实一点都不实用。

3. 法律途径

此外就是大家可能都考虑过的：爬虫违法吗？能起诉对方让对方不爬吗？法务给的答案到是很干脆，可以，前提是证据。遗憾的是，这个世界上大部分的爬虫爬取数据是不会公布到自己网站的，只是用于自己的数据分析。因此，即使有一些关于爬虫的官司做为先例，并且已经打完了，依然对我们没有任何帮助。反爬虫，在对方足够低调的情况下，注定还是个技术活。

4. 搞事情，立 Flag

到了后来，我们已经不再局限于打打技术了。反爬虫的代码里我们经常埋点小彩蛋给对方，比如写点注释给对方。双方通过互相交战，频繁发布，居然聊的挺 high 的。

比如问问对方，北京房价是不是很高啊？ 对方回应，欧巴，我可是凭本事吃饭哦。继续问，摇到号了吗？诸如此类等等。这样的事情你来我往的，很容易动摇对方的军心，还是很有作用的。试想一下，如果你的爬虫工程师在大年三十还苦逼加班的时候，看到对方留言说自己拿到了 n 个月的年终奖，你觉得你的工程师，离辞职还远吗？

最后，我们终于搞出了大动作，觉得一定可以坑对方很久了。我们还特意去一家小火锅店吃了一顿，庆祝一下，准备明天上线。大家都知道，一般立 flag 的下场都比较惨的。两个小时的自助火锅，我们刚吃五分钟，就得到了我们投资竞争对手的消息。后面的一个多小时，团队气氛都很尴尬，谁也说不出什么话。我们组有个实习生，后来鼓足勇气问了我一个问题：“我还能留下来吗？”毕竟，大部分情况下，技术还是要屈服于资本的力量。

四. 爬虫反爬虫的未来

与竞争对手和解之后，我们去拜访对方，大家坐在了一起。之前网上自称妹子的，一个个都是五大三粗的汉子，这让我们相当绝望，在场唯一的一个妹子还是我们自己带过去的（就是上面提到的实习生），感觉套路了这么久，最终还是被对方套路了。

好在，吃的喝的都很好，大家玩的还是比较 high 的。后续就是和平年代啦，大家不打仗了，反爬虫的逻辑扔在那做个防御，然后就开放白名单允许对方爬取了。群里经常叫的就是：xxx 你怎么频率这么高，xxx 你为什么这个接口没给我开放，为什么我爬的东西不对我靠你是不是把我封了啊。诸如此类的。

和平年代的反爬虫比战争年代还难做。因为战争年代，误伤率只要不是太高，公司就可以接受。和平年代大家不能搞事情，误伤率稍稍多一点，就会有人叫：好好的不赚钱，瞎搞什么搞。此外，战争年代只要不拦截用户，就不算误伤。和平年代还要考虑白名单，拦截了合作伙伴也是误伤。因此各方面会更保守一些。不过，总体来说还是和平年代比较 happy。毕竟，谁会喜欢没事加班玩呢。

然而和平持续的不是很久，很快就有了新的竞争对手选择爬虫来与我们打。毕竟，这是一个利益驱使的世界。只要有大量的利润，资本家就会杀人放火，这不是我们这些技术人员可以决定的。我们希望天下无虫，但是我们又有什么权利呢。

好在，这样可以催生更多的职位，顺便提高大家的身价，也算是个好事情吧。

Reference