Python实现FFM【tensorflow2.0】

糖逗

论文：https://www.csie.ntu.edu.tw/~cjlin/papers/ffm.pdf

参考：https://zhuanlan.zhihu.com/p/170607706

说明：待验证

1. import tensorflow as tf
   
2. from tensorflow.keras import layers, optimizers
   
3. from tensorflow import keras
   
4. from sklearn.model_selection import train_test_split
   
5. import numpy as np
   
6. 
   
7. #将数据划分为测试集和训练集
   
8. def preprocess(x, y):
   
9.     x = tf.cast(x, dtype = tf.float64)
   
10.     y = tf.cast(y, dtype = tf.int64)
    
11.     return x, y
    
12. 
    
13. from sklearn.datasets import load_breast_cancer
    
14. from sklearn.model_selection import train_test_split
    
15. data = load_breast_cancer()
    
16. x_train, x_test, y_train, y_test = train_test_split(data.data, data.target, test_size=0.2,
    
17.                                                         random_state = 11, stratify = data.target)
    
18. print(x_train.shape, y_train.shape, x_test.shape, y_test.shape)
    
19. 
    
20. train_db = tf.data.Dataset.from_tensor_slices((np.array(x_train), y_train))
    
21. train_db = train_db.shuffle(123).map(preprocess).batch(20)
    
22. 
    
23. test_db = tf.data.Dataset.from_tensor_slices((np.array(x_test), y_test))
    
24. test_db = test_db.map(preprocess).batch(20)
    
25. 
    
26. sample = next(iter(train_db))
    
27. print('sample:', sample[0].shape, sample[1].shape,
    
28.       tf.reduce_min(sample[0]), tf.reduce_max(sample[0]))

复制代码

1. class FFM(keras.Model):
   
2.     def __init__(self, field_num, feature_field_dict, dim_num, k = 2):
   
3.         super(FFM, self).__init__()
   
4.         self.field_num = field_num
   
5.         self.k = k
   
6.         self.feature_field_dict = feature_field_dict
   
7.         self.dim_num = dim_num
   
8. 
   
9.     def build(self, input_shape):
   
10.         self.fc = tf.keras.layers.Dense(units = 1,
    
11.                                   bias_regularizer = tf.keras.regularizers.l2(0.01),
    
12.                                   kernel_regularizer = tf.keras.regularizers.l1(0.02))
    
13.         self.w = self.add_weight(shape = (input_shape[-1], self.field_num, self.k),
    
14.                                       initializer = 'glorot_uniform',
    
15.                                       trainable = True)
    
16.         super(FFM, self).build(input_shape)
    
17.         
    
18.     def call(self, x, training):
    
19.         linear = self.fc(x)
    
20.         temp = tf.cast(0, tf.float32)
    
21.         temp = tf.expand_dims(temp, axis = 0)
    
22.         for j1 in range(self.dim_num):
    
23.             for j2 in range(j1 + 1, self.dim_num):
    
24.                 f1 = self.feature_field_dict[j2]
    
25.                 f2 = self.feature_field_dict[j1]
    
26.                 #[, , k] * [, , k] = [, , k] -> [1, k]
    
27.                 ww = tf.expand_dims(tf.multiply(self.w[j1, f2, :], self.w[j2, f1, :]), axis = 0)
    
28.                 #[x, ] * [x, ] = [x, ] -> [x, 1]
    
29.                 xx = tf.expand_dims(tf.multiply(x[:, j1], x[:, j2]),axis = 1)
    
30.                 #[x, 1] @ [1, k] = [x, k]
    
31.                 store = tf.matmul(xx, ww)
    
32.                 #[x, k] -> [x]
    
33.                 temp += tf.reduce_mean(store, keepdims = True, axis = 1)
    
34.         out = layers.Add()([linear, temp])
    
35.         return tf.sigmoid(out)
    
36. 
    
37. store = {}   
    
38. for i in range(30):
    
39.         store[i] = int(i / 15)
    
40. model = FFM(field_num = 2, feature_field_dict = store, dim_num = 30)
    
41. model.build((None, 30))
    
42. model.summary()

复制代码

1. def main():
   
2.     store = {}
   
3.     for i in range(30):
   
4.         store[i] = int(i / 15) #实际要根据数据字段含义定义，这里只是做一个随意的分组
   
5.     model = FFM(field_num = 2, feature_field_dict = store, dim_num = 30)
   
6.     optimizer = optimizers.Adam(lr = 1e-2)
   
7.     for epoch in range(50):
   
8.         for step, (x,y) in enumerate(train_db):
   
9.             with tf.GradientTape() as tape:
   
10.                 logits = model(x,training=True)
    
11.                 loss = tf.reduce_mean(tf.losses.binary_crossentropy(y, logits))
    
12.                 loss_regularization = []
    
13.                 for i in model.trainable_variables:
    
14.                     loss_regularization.append(tf.nn.l2_loss(i))
    
15.                 loss_regularization = tf.reduce_sum(tf.stack(loss_regularization))
    
16.                 loss = 0.001 * loss_regularization + loss
    
17.             grads = tape.gradient(loss, model.trainable_variables)
    
18.             optimizer.apply_gradients(zip(grads, model.trainable_variables))
    
19.             print(epoch, step, 'loss:', float(loss))
    
20.             
    
21.         total_num = 0
    
22.         total_correct = 0
    
23.         for x,y in test_db:
    
24.             pred = model(x, training=False)
    
25.             pred = tf.squeeze(pred)
    
26.             pred = pred > 0.5
    
27.             pred = tf.cast(pred, dtype = tf.int64)
    
28.             correct = tf.cast(tf.equal(pred, y), tf.int64)
    
29.             correct = tf.reduce_sum(correct)
    
30.             total_num += x.shape[0]
    
31.             total_correct += int(correct)
    
32.         acc = total_correct / total_num
    
33.         print(epoch, 'acc:', acc)
    
34.         print("-"*25)
    
35.         
    
36. if __name__ == '__main__':
    
37.     main()

复制代码