多渠道归因分析（Attribution）：用attention-RNN来做归因建模（附代码demo）（五）

﹏ヽ暗。殇╰゛Y 2022-10-12 12:22 53阅读 0赞

之前几篇多渠道归因分析应该算是比较通用的一些方法论：

*  [多渠道归因分析（Attribution）：传统归因（一）][Attribution]
 *  [多渠道归因分析：互联网的归因江湖（二）][Link 1]
 *  [多渠道归因分析：python实现马尔可夫链归因（三）][python]
 *  [多渠道归因分析（Attribution）：python实现Shapley Value（四）][Attribution_python_Shapley Value]
 *  [多渠道归因分析（Attribution）：用attention-RNN来做归因建模（附代码demo）（五）][Attribution_attention-RNN_demo]

之前在查阅资料的时候，有看到一篇更进阶的，用深度学习来解决问题，  
论文可参考18年的一篇：  
[Deep Neural Net with Attention for Multi-channel Multi-touch Attribution][]

我们来看这篇以及品鉴一下关联代码：  
官方：[channel-attribution-model][]

我把可以跑通demo代码放在自己的github之中：[mattzheng/Attention-RNN-Multi-Touch-Attribution][mattzheng_Attention-RNN-Multi-Touch-Attribution]

--------------------

### 文章目录 ###

*  1 基于注意力的循环神经网络多点触摸归因模型
 *   *  1.1 与markov、Sharpley 的差异
     *  1.2 注意力的循环神经网络多点触摸归因模型框架
     *  1.3 LSTM 来捕捉长路径模式
     *  1.4 RNN with Attention 将时间衰减作为attention加入
     *  1.5 customer profile — embedding layer + ANN：额外融入用户属性信息
     *  1.6 融合层
 *  2 下游应用
 *   *  2.1 下游应用一：分配路径权重
     *  2.2 下游应用二：预算评估
     *  2.3 确定最有影响力的路径
 *  3 案例代码demo解读
 *   *  3.1 数据样式
     *  3.2 训练与预测
     *  3.3 确定最优影响力的路径
     *  3.4 确定attention weight
 *  4 后续YY
 *  参考文献

--------------------

# 1 基于注意力的循环神经网络多点触摸归因模型 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70]

假设有 如下7-13个 触点的路径：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 1]

## 1.1 与markov、Sharpley 的差异 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 2]  
markov、Sharpley 是市面上最、最常见的两种归因分析的方法了，但是两种都缺少考虑：

*  长路径序列下路径间的影响（markov考虑了顺序）
 *  未融入用户属性信息  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 3]

## 1.2 注意力的循环神经网络多点触摸归因模型框架 ##

一种基于注意力的循环神经网络多点触摸归因模型，以监督学习的方式预测一系列事件是否导致转换(购买)。  
模型可以输出不同节点的重要性（LSTM的），同时还结合了非常关键的信息，将用户背景信息(如用户人口统计和行为)作为控制变量，以减少媒体效应的估计偏差。  
来说明几个特色：

*  LSTM 来捕捉长路径模式
 *  RNN with Attention 将时间衰减作为attention加入
 *  customer profile — embedding layer + ANN：额外融入用户属性信息
 *  还可以输出每个触点的重要性（即LSTM的节点）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 4]  
用LSTM来解读路径周期，将路径作为input输入LSTM之中  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 5]  
将时间衰减作为attention加入

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 6]  
整个架构图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 7]  
左边是路径模块，右边是用户属性模块，

*  路径模块带有attenion（时间衰减）
 *  用户模块，属性embedding之后输出  
    最后两者add()在一起做输出。

## 1.3 LSTM 来捕捉长路径模式 ##

路径变量作为输入数据被发送到LSTM层，并获得每个路径变量的输出。LSTM体系结构能够捕获通道数据的顺序模式。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 8]

## 1.4 RNN with Attention 将时间衰减作为attention加入 ##

这个环节是节点模块的比较有意思的模块：

> The time-lapse data are scaled and will be used in the revised softmax function in Attention layer.

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 9]  
在机器翻译上下文中，重复这一步，得到长度等于翻译单词数的输出向量上下文，然后将这些输出再次发送到另一个LSTM中，得到最终的翻译结果。但在本例中，我们只需要从注意力输出一个结果。  
值得注意的是，由于时间衰减元素在客户路径中起着作用，我们将修改softmax函数来考虑这个因素。  
![在这里插入图片描述][20210705225419401.png]  
源码中为，参考[FFDNA.py][] ：

input_att = Input(shape=(self.Tx, self.vocab_size), name='input_path')
    s0 = Input(shape=(self.n_s,), name='s0')
    s = s0
    # input time decay data
    t0 = Input(shape=(self.Tx,1), name='input_timeDecay')
    t = t0
    # Step 1: Define pre-attention LSTM.
    a = LSTM(self.n_a,return_sequences=True)(input_att)
    
    # Step 2: import attention model
    context = self.one_step_attention(a,s,t)
    c = Flatten()(context)
    out_att = Dense(32, activation = "sigmoid", name='single_output')(c)

这里主要是路径模块，完全可以当做文本来看待，这里有三个需要输入的：

*  `input_att` ，第一个输入，主要记录路径的，其中`self.vocab_size`一般是总词量 +1，这边就是所有路径节点数+ 1（5个）；`self.Tx` 代表文字的padding 长度，这里是20，之后 -> 进入到LSTM -> attention层
 *  `s0 = Input(shape=(self.n_s,), name='s0')`，初始化decoder LSTM隐藏层 -> attenion层
 *  `t0 = Input(shape=(self.Tx,1), name='input_timeDecay')` 时间维度因素 -> attention层

然后简单来看一下attention层，上面的三个输入如何计算：

def one_step_attention(self, a, s_prev,t0):
        repeator = RepeatVector(Tx)
        concatenator = Concatenate(axis=-1)
        densor1 = Dense(10, activation = "tanh")
        densor2 = Dense(1, activation = "relu")
        activator = Activation(self.softmax, name='attention_weights') # We are using a custom softmax(axis = 1) loaded in this notebook
        dotor = Dot(axes = 1)
        # Use repeator to repeat s_prev to be of shape (m, Tx, n_s) so that you can concatenate it with all hidden states "a".
        s_prev = repeator(s_prev)
        # Use concatenator to concatenate a and s_prev on the last axis
        concat = concatenator([s_prev,a])
        # Use densor1 to propagate concat through a small fully-connected neural network to compute the "intermediate energies" variable e.
        e = densor1(concat)
        # Use densor2 to propagate e through a small fully-connected neural network to compute the "energies" variable energies.
        energies = densor2(e)
        # Use "activator" on "energies" to compute the attention weights "alphas" 
        energies = Subtract(name='data-time')([energies,t0])
        alphas = activator(energies)
        # Use dotor together with "alphas" and "a" to compute the context vector to be given to the next layer
        context = dotor([alphas,a])
        return context

大概是先计算`attention weights`：  
将三个Input，`concatenator([s_prev,a])`，然后求差`Subtract(name='data-time')([energies,t0])`，进入`activator`激活层中特别的`softmax`，计算`attention weights`  
然后将`attention weights` 点积 路径的lstm隐含层，得到输出项

这里的`attention weights`就是非常关键的每个节点的权重了

## 1.5 customer profile — embedding layer + ANN：额外融入用户属性信息 ##

一个简单的全连接神经网络来处理客户数据。这部分非常简单，只有几个密集的层。  
之前用户编码会用one-hot encoding，这里使用的是embedding layer自训练。

嵌入层 Embedding:将正整数（索引值）转换为固定尺寸的稠密向量。  
例如： `[[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]]`  
来看一个keras官方的例子[\[Embedding\]][Embedding]：

model = Sequential()
    model.add(Embedding(1000, 64, input_length=10))
    # 模型将输入一个大小为 (batch, input_length) 的整数矩阵。
    # 输入中最大的整数（即词索引）不应该大于 999 （词汇表大小）
    # 现在 model.output_shape == (None, 10, 64)，其中 None 是 batch 的维度。
    
    input_array = np.random.randint(1000, size=(32, 10))
    
    model.compile('rmsprop', 'mse')
    output_array = model.predict(input_array)
    assert output_array.shape == (32, 10, 64)

来看一下开源的代码,整个用户属性模块的embedding张这样，参考[FFDNA.py][] ：

def build_embedding_network(self, no_of_unique_cat=83, output_shape=32):
        inputss = []
        embeddings = []
        for c in self.categorical_vars:
            inputs = Input(shape=(1,),name='input_sparse_'+c)
            #no_of_unique_cat  = data_lr[categorical_var].nunique()
            embedding_size = min(np.ceil((no_of_unique_cat)/2), 50 )
            embedding_size = int(embedding_size)
            embedding = Embedding(no_of_unique_cat+1, embedding_size, input_length = 1)(inputs)
            embedding = Reshape(target_shape=(embedding_size,))(embedding)
            inputss.append(inputs)
            embeddings.append(embedding)
        input_numeric = Input(shape=(1,),name='input_constinuous')
        embedding_numeric = Dense(16)(input_numeric)
        inputss.append(input_numeric)
        embeddings.append(embedding_numeric)
    
        x = Concatenate()(embeddings)
    
        x = Dense(10, activation = 'relu')(x)
        x = Dropout(.15)(x)
        out_control = Dense(output_shape)(x)
        return inputss,out_control

这里每个用户属性categorical\_vars，都会进行一次Embedding，然后之后拼接在一起`Concatenate()(embeddings)`，进入一个`dense(10)`全连接层。  
该模块的输入：`inputss`，需要同时给入三个属性变量，  
输出：`out_control` 32维的全连接输出

## 1.6 融合层 ##

路径模块和客户属性模块，输出到另一个dense层，然后由sigmoid激活函数到最终，0/1分类

out_att = Dense(32, activation = "sigmoid", name='single_output')(c)
    
     # Step 3: import embedding data for customer-ralated variables
     input_con,out_control = self.build_embedding_network()
     added = Add()([out_att, out_control])

github中的代码两个输出直接相加`add()`，不是`conatenate()`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 10]  
作者自己的测试结果：

*  RNN-attenion模型，96% accuracy 和0.98 AUC
 *  markov模型，0.86 AUC

# 2 下游应用 #

## 2.1 下游应用一：分配路径权重 ##

我将使用性能最好的模型来计算分配给每个通道的权值。基本上，对于每一个送入模型的观测数据，如果输出概率大于0.5(这意味着该观测将被归类为转换)，我会从Attention层提取权值，并将其累加到相应的通道。  
在得到每个渠道的权重后，我们将使用下面的公式来分配营销预算。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 11]

## 2.2 下游应用二：预算评估 ##

哪些营销渠道在推动转化率和销售额，意味着你可以更好地将营销资金分配到最有效的渠道上，并更好地跟踪潜在客户的互动  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 12]  
如果你有一定预算，你会如何分配；当你通过模型得出不同路径的权重，就可以根据权重来分配。  
当然这种方式比较简单，详细可见我之前贴的俩论文：  
[预算分配Budget Allocation：两篇论文（二）][Budget Allocation]

## 2.3 确定最有影响力的路径 ##

根据每个客户路径的转换概率排名，我列出了最具影响力的N条路径。  
代码如下:

def critical_paths(self):
        prob = self.model.predict([self.X_tr,self.s0,self.time_decay_tr,self.X_tr_lr.iloc[:,0],self.X_tr_lr.iloc[:,1],
           self.X_tr_lr.iloc[:,2],self.X_tr_lr.iloc[:,3]])
        cp_idx = sorted(range(len(prob)), key=lambda k: prob[k], reverse=True)
        #print([prob[p] for p in cp_idx[0:100]])
        cp_p = [self.paths[p] for p in cp_idx[0:100]]
        
        cp_p_2 = set(map(tuple, cp_p))
        print(list(map(list,cp_p_2)))

--------------------

# 3 案例代码demo解读 #

笔者测试的时候的tf 、 keras版本号：

tf.__version__,keras.__version__
    Out[7]: ('1.14.0', '2.2.4')

## 3.1 数据样式 ##

在文章[How to implement an Attention-RNN model into solving a marketing problem: Multi-Channel Attribution][How to implement an Attention-RNN model into solving a marketing problem_ Multi-Channel Attribution]中没有放出数据，所以笔者自己造了按博文自己造了几条，代码可见：[mattzheng/Attention-RNN-Multi-Touch-Attribution][mattzheng_Attention-RNN-Multi-Touch-Attribution]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 13]

*  total\_conv就是最后是否转化
 *  last\_time\_lapse，节点访问时间经过，放入的是路径模块，作为attention模块，不过这个样式我自己造的时候也有点不确定，是否每个节点对应，可以自由灵活调配
 *  marketing\_area 、 tier 、 customer\_type都是用户属性类型，这里自由发挥，可以很多

这里在[process\_data.py][process_data.py]中经过预处理之后：

data_all = process_data(data,seq_length = seq_length)

需要输出的内容：

*  time\_decay\_tr, 训练集时间
 *  time\_decay\_te,测试集时间
 *  X\_tr, 用户路径模块 -训练集X
 *  X\_te,用户路径模块 - 测试集X
 *  X\_tr\_lr,用户属性模块-训练集X
 *  X\_te\_lr,用户属性模块-测试集X
 *  Y\_train,
 *  Y\_test,
 *  all\_X, 所有x
 *  time\_decay,所有时间
 *  newlines.shape,17\*20,pad\_sequence
 *  y ,所有y
 *  categorical\_vars,用户属性模块 哪些字段
 *  paths , 所有路径

## 3.2 训练与预测 ##

def train_model(self,save_name, loss='binary_crossentropy',opt='adam',metrics=['accuracy']):
        self.model.compile(loss=loss,optimizer=opt,metrics=metrics)
        self.history = self.model.fit([self.X_tr,self.s0,self.time_decay_tr,self.X_tr_lr.iloc[:,0],self.X_tr_lr.iloc[:,1],
               self.X_tr_lr.iloc[:,2],self.X_tr_lr.iloc[:,3]
              ], self.Y_train, epochs=self.epochs, batch_size=self.batch_size,verbose=2)
    
        self.save_weight(save_name,self.model)

从`model.fit`来看，这里需要Input的内容非常多；而且，这里的用户属性`self.X_tr_lr.iloc[:,1],self.X_tr_lr.iloc[:,2],self.X_tr_lr.iloc[:,3]`为什么分为三个？  
因为用户属性每个属性特征都需要独立embedding

## 3.3 确定最优影响力的路径 ##

其实这里就是一个预测，所有数据集中，因为本次训练target是购买率0/1，所以最高购买率的就是有影响力的。

prob = ana_mta_model.model.predict([ana_mta_model.X_tr,ana_mta_model.s0,ana_mta_model.time_decay_tr,\
                                        ana_mta_model.X_tr_lr.iloc[:,0],\
                                            ana_mta_model.X_tr_lr.iloc[:,1],
       ana_mta_model.X_tr_lr.iloc[:,2],ana_mta_model.X_tr_lr.iloc[:,3]])
    
        # 训练集预测 - 找到预测概率比较高的路径
    cp_idx = sorted(range(len(prob)), key=lambda k: prob[k], reverse=True)
    #print([prob[p] for p in cp_idx[0:100]])
    cp_p = [ana_mta_model.paths[p] for p in cp_idx[0:100]]
    
    cp_p_2 = set(map(tuple, cp_p))
    print(list(map(list,cp_p_2)))

是在原函数的`critical_paths`之中

## 3.4 确定attention weight ##

确定每个节点的权重

layer = ana_mta_model.model.layers[20]
    m_all,_,_ = ana_mta_model.all_X.shape  # 训练集
    ana_mta_model.s_all = np.zeros((m_all, ana_mta_model.n_s))
    f_f = K.function([ana_mta_model.model.input[0],ana_mta_model.model.input[1],ana_mta_model.model.input[2]], [layer.output])
    r=f_f([ana_mta_model.all_X[ana_mta_model.y==1],ana_mta_model.s_all[ana_mta_model.y==1],ana_mta_model.time_decay[ana_mta_model.y==1]])[0].reshape(ana_mta_model.all_X[ana_mta_model.y==1].shape[0],ana_mta_model.all_X[ana_mta_model.y==1].shape[1])
    
    
    # att_f = {m:0 for m in range(1,6)}
    # att_count_f = {m:0 for m in range(1,6)}
    att_f = {m:0 for m in range(1,n_channels+1)}
    att_count_f = {m:0 for m in range(1,n_channels+1)}
    
    chan_used = ana_mta_model.newlines[ana_mta_model.y==1]
    for m in range(chan_used.shape[0]):
        for n in range(chan_used.shape[1]):
            if chan_used[m,n]!=0:
                att_f[chan_used[m,n]] += r[m,n]
                att_count_f[chan_used[m,n]] += 1
    for n in range(n_channels):
        att_f[channels[n]] = att_f.pop(n+1)

在原函数的`attributes`,因为我是自己造的数据，channel不一样，所以需要自己改造一下这个函数。  
就可以得到每个节点的权重。

--------------------

# 4 后续YY #

确定购买潜力以及其他更多的变形  
如果有顾客点击了很多路径内容还没转化，可以通过模型得到他购买的可能性。

例如，如果你的公司也关心每个渠道其他转化情况(如电子邮件活动中的广告的点击率)，你将在LSTM之上添加更多的层来实现这一点，如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 14]

此外，您还可以预测一次购买的平均支出或金额，这可能会使分配权重更准确，也可以提供您关于调整供应链的信息。可以参考上文的输出接入：average spending

沿着这个一直再设想一下，一切NLP的模型都可以使用上；  
比如利用预训练模型，后续可以接上非常多的应用，包括预测用户下一个点击页面是什么（NSP）  
总之，这块应该还有非常多空间可以思考与继续深究

--------------------

# 参考文献 #

[How to implement an Attention-RNN model into solving a marketing problem: Multi-Channel Attribution][How to implement an Attention-RNN model into solving a marketing problem_ Multi-Channel Attribution]  
[Attention-RNN Channel-Attribution Model][]  
[jeremite/channel-attribution-model][channel-attribution-model]

[Attribution]: https://mattzheng.blog.csdn.net/article/details/117290387
[Link 1]: https://mattzheng.blog.csdn.net/article/details/117294925
[python]: https://mattzheng.blog.csdn.net/article/details/117296062
[Attribution_python_Shapley Value]: https://blog.csdn.net/sinat_26917383/article/details/117443680
[Attribution_attention-RNN_demo]: https://mattzheng.blog.csdn.net/article/details/118469466
[Deep Neural Net with Attention for Multi-channel Multi-touch Attribution]: https://arxiv.org/pdf/1809.02230.pdf
[channel-attribution-model]: https://github.com/jeremite/channel-attribution-model
[mattzheng_Attention-RNN-Multi-Touch-Attribution]: https://github.com/mattzheng/Attention-RNN-Multi-Touch-Attribution
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70]: /images/20221005/c012b8dd30414f3e82eb0e63775b203f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 1]: /images/20221005/1be794cfa0e14102965ac8da87fec2c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 2]: /images/20221005/aeebd3040cce44f8b7ac0e8cb9141fc2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 3]: /images/20221005/fa2b2a368e014b39ad1a2925172fa52d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 4]: /images/20221005/d59421303dde48d88973bbe518a458c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 5]: /images/20221005/3592b2406be74ffc8ab6edc1809b300e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 6]: /images/20221005/2b78864cac5d427bb07a2ac765788a3b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 7]: /images/20221005/08a37501f54a4e5f9174b591d410337e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 8]: /images/20221005/94f1d71b7a8346a997482f82463eb4cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 9]: /images/20221005/f6ff1b500464487b8adfa6446d6acfbd.png
[20210705225419401.png]: /images/20221005/52f4dd494dcc4c83bc427e38ce2f581f.png
[FFDNA.py]: https://github.com/mattzheng/Attention-RNN-Multi-Touch-Attribution/blob/main/FFDNA.py
[Embedding]: https://keras.io/zh/layers/embeddings/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 10]: /images/20221005/8be7fff812324205aa3b5561f4f4c349.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 11]: /images/20221005/fcde83af7bf341a2b6ca9c5df8e0c805.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 12]: /images/20221005/deea64d20fa94337b10c8387eba4d2e4.png
[Budget Allocation]: https://blog.csdn.net/sinat_26917383/article/details/117713999
[How to implement an Attention-RNN model into solving a marketing problem_ Multi-Channel Attribution]: https://medium.com/machine-learning-for-business-problem/how-to-implement-an-attention-rnn-into-solving-the-multi-channel-attribution-problem-6fa90d935859
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 13]: /images/20221005/d96293e821c3409eb3b74e9aeacc2b3d.png
[process_data.py]: https://github.com/mattzheng/Attention-RNN-Multi-Touch-Attribution/blob/main/process_data.py
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz_size_16_color_FFFFFF_t_70 14]: /images/20221005/f2f2ce619bc1430daa87f4827eecd114.png
[Attention-RNN Channel-Attribution Model]: https://jeremite.github.io/RNN-Channel-Attribution-Model/