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

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)

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 

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)

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

 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])

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)))

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

data_all = process_data(data,seq_length = seq_length)

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)

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)))

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)