TensorFlow2实现协同过滤算法中的矩阵分解（首家基于TS2版本）

目标：

用TensorFlow2，实现协同过滤算法中的矩阵分解。网上找的绝大部分是基于一个模板复制出来的，且基于TensorFlow1，因此本人亲自动手，用TensorFlow2实现。

• 好奇为什么TensorFlow2不帮我们实现了，在Spark中，直接调用spark.mllib.recommendation.ALS() 就好了。

---

内容：

在推荐系统中，协同过滤算法是很常用的推荐算法。中心思想：物以类聚，人以群分。也就是口味相同的人，把他喜欢的物品或者电影歌曲推荐给你；或者是将你喜欢的物品，类似的物品推荐给你。
整体流程：
1、 获取用户对商品的评分、购买记录等
2、 构造协同矩阵M
3、 基于矩阵进行分解M=U*V
4、 利用要推荐的物品或者用户，和U或者V计算相似度

---

代码：

TensorFlow2可以自动帮你求导更新参数，太方便了，你要做的就是构造损失函数loss而已。
loss函数可以理解为，我们分解得到U*V得到预测的M_pre，用M和M_pre求欧式距离：即欧几里得距离（Euclidean Distance）
公式具体为：

大致意思就是分解一个大矩阵为两个小矩阵相乘。

具体代码为：

'''=================================================
@Function -> 用TensorFlow2实现协同过滤矩阵的分解
@Author ：luoji
@Date   ：2021-10-19
=================================================='''

import numpy as np
import tensorflow as tf

def matrixDecomposition(alike_matix,rank=10,num_epoch= 5000,learning_rate=0.001,reg=0.5):
    row,column = len(alike_matix),len(alike_matix[0])
    y_true = tf.constant(alike_matix, dtype=tf.float32)  # 构建y_true
    U = tf.Variable(shape=(row, rank), initial_value=np.random.random(size=(row, rank)),dtype=tf.float32)  # 构建一个变量U，代表user权重矩阵
    V = tf.Variable(shape=(rank, column), initial_value=np.random.random(size=(rank, column)),dtype=tf.float32)  # 构建一个变量，代表权重矩阵，初始化为0

    variables = [U,V]
    optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
    for batch_index in range(num_epoch):
        with tf.GradientTape() as tape:
          y_pre = tf.matmul(U, V)
          loss = tf.reduce_sum(tf.norm(y_true-y_pre, ord='euclidean')
                               + reg*(tf.norm(U,ord='euclidean')+tf.norm(V,ord='euclidean')))  #正则化项
          print("batch %d : loss %f" %(batch_index,loss.numpy()))

        grads = tape.gradient(loss,variables)
        optimizer.apply_gradients(grads_and_vars=zip(grads,variables))
    return U,V,tf.matmul(U, V)

if __name__ == "__main__":
    # 把矩阵分解为 M=U*V ，U和V由用户指定秩rank
    alike_matrix = [[1.0, 2.0, 3.0],
                   [4.5, 5.0, 3.1],
                   [1.0, 2.0, 3.0],
                   [4.5, 5.0, 5.1],
                   [1.0, 2.0, 3.0]]
    U,V,preMatrix = matrixDecomposition(alike_matrix,rank=2,reg=0.5,num_epoch=2000) # reg 减小则num_epoch需增大

    print(U)
    print(V)
    print(alike_matrix)
    print(preMatrix)
    print("this difference between alike_matrix and preMatrix is :")
    print(alike_matrix-preMatrix)
    print('loss is :',sum(sum(abs(alike_matrix - preMatrix))))

待分解的矩阵：
[[1.0, 2.0, 3.0],
[4.5, 5.0, 3.1],
[1.0, 2.0, 3.0],
[4.5, 5.0, 5.1],
[1.0, 2.0, 3.0]]

分解后，相乘的到的矩阵：

[[1.0647349 1.929376 2.9957888]
[4.6015587 4.7999315 3.1697667]
[1.0643657 1.9290545 2.9957101]
[4.287443 5.211667 4.996485 ]
[1.0647217 1.9293401 2.9957187]],

可以看出两者还是很相似的，证明我们用TensorFlow2进行的矩阵分解是正确的。
注意，正则化项reg需要和num_epoch配套，reg越大，收敛越快，但效果不一定最好。

---

产出：

TensorFlow2，实现协同过滤算法中的矩阵分解，而且该模块可以直接复用。
1、加深了对TensorFlow2的理解，太神奇了，只要找到损失函数loss，模型就可以训练。Amazing！
2、CSDN 技术博客1 篇，全网找不到第二个基于TensorFlow2实现的。好奇为什么TensorFlow2不帮我们实现了，在Spark中，直接调用spark.mllib.recommendation.ALS() 就好了