基于深度学习神经网络协同过滤模型(NCF)的图书推荐系统

本文涉及的产品
智能开放搜索 OpenSearch行业算法版,1GB 20LCU 1个月
推荐全链路深度定制开发平台,高级版 1个月
智能开放搜索 OpenSearch向量检索版,4核32GB 1个月
简介: 登录注册热门图书图书分类图书推荐借阅图书购物图书个人中心可视化大屏后台管理

基于深度学习神经网络协同过滤模型(NCF)的图书推荐系统

一、效果图

点我查看在线demo
图书推荐效果图.png

二、功能简介

本系统具有功能有:

# -*- coding: utf-8 -*-

"""
@contact: 微信 1257309054
@file: test.py
@time: 2024/6/16 21:41
@author: LDC
"""
登录注册
热门图书
图书分类
图书推荐
借阅图书
购物图书
个人中心
可视化大屏
后台管理

三、技术栈

开发语言是python,版本是3.8;

数据库是mysql版本是5.7;

后端使用的是django,版本是3;

前端使用的是django渲染的;

后台管理使用的是xadmin,版本是3。

神经网络框架使用的是tensorflow,版本是1.14.0。

四、启发式推荐系统

推荐系统的核心是根据用户的兴趣需求,给用户推荐喜欢的内容。常用的推荐算法有启发式推荐算法,可分为基于用户的 协同过滤,基于物品的协同过滤。

1、基于用户的协同过滤(UCF)

主要考虑的是用户和用户之间的相似度,只要找出相似用户喜欢的物品,并预测目标用户对对应物品的评分,就可以找到评分最高的若干个物品推荐给用户。

举例:
--------+--------+--------+--------+--------+
    |   X    |    Y   |    Z   |    R   |
--------+--------+--------+--------+--------+
a   |   5    |    4   |    1   |    5   |
--------+--------+--------+--------+--------+
b   |   4    |    3   |    1   |    ?   |
--------+--------+--------+--------+--------+
c   |   2    |    2   |    5   |    1   |
--------+--------+--------+--------+--------+

a用户给X物品打了5分,给Y打了4分,给Z打了1分
b用户给X物品打了4分,给Y打了3分,给Z打了1分
c用户给X物品打了2分,给Y打了2分,给Z打了5分

那么很容易看到a用户和b用户非常相似,但是b用户没有看过R物品,
那么我们就可以把和b用户很相似的a用户打分很高的R物品推荐给b用户,
这就是基于用户的协同过滤。

2、基于物品的协同过滤(ICF)

主要考虑的是物品和物品之间的相似度,只有找到了目标用户对某些物品的评分,那么就可以对相似度高的类似物品进行预测,将评分最高的若干个相似物品推荐给用户。

举例:
--------+--------+--------+--------+--------+
    |   X    |    Y   |    Z   |    R   |
--------+--------+--------+--------+--------+
a   |   5    |    5   |    1   |    5   |
--------+--------+--------+--------+--------+
b   |   5    |    5   |    1   |    2   |
--------+--------+--------+--------+--------+
c   |   5    |    5   |    5   |    1   |
--------+--------+--------+--------+--------+
d   |   5    |    ?   |    ?   |    ?   |
--------+--------+--------+--------+--------+

a用户给X物品打了5分,给Y打了5分,给Z打了1分,给R打了5分
b用户给X物品打了5分,给Y打了5分,给Z打了1分,给R打了2分
c用户给X物品打了5分,给Y打了5分,给Z打了5分,给R打了1分

那么很容易看到a用户、b用户、c用户都喜欢图书X,Y,
那么当用户d也喜欢图书X时,就会把图书Y推荐给用户d
因为基于用户a、b、c的评分,系统会认为喜欢X书籍的人在很大程度上会喜欢Y书籍。
这就是基于物品的协同过滤。

3、启发式推荐算法优缺点

优点:易于实现,并且推荐结果的可解释性强。

缺点:

难以处理冷启动问题:当一个用户或一个物品没有足够的评分数据时,启发式协同过滤算法无法对其进行有效的预测,因为它需要依赖于已有的评分数据。

对数据稀疏性敏感:如果数据集中存在大量的缺失值,启发式协同过滤算法的预测准确率会受到影响,因为它需要依赖于完整的评分数据来进行预测。

推荐类型单一化:推荐结果容易陷入一个小范围的困境,如果某个用户特别喜欢小说类的图书,那么这种系统就会不断地推荐小说类图书,实际上这个用户很有可能也喜欢历史、文学、传记类的图书,但是囿于冷启动问题,无法进行推荐。

五、神经网络协同过滤模型(NCF)

为了解决启发式推荐算法的问题,基于神经网络的协同过滤算法诞生了,神经网络的协同过滤算法可以通过将用户和物品的特征向量作为输入,来预测用户对新物品的评分,从而解决冷启动问题。

对数据稀疏性的鲁棒性:神经网络的协同过滤算法可以自动学习用户和物品的特征向量,并能够通过这些向量来预测评分,因此对于数据稀疏的情况也能进行有效的预测。

更好的预测准确率:神经网络的协同过滤算法可以通过多层非线性变换来学习用户和物品之间的复杂关系,从而能够提高预测准确率。

可解释性和灵活性:神经网络的协同过滤算法可以通过调整网络结构和参数来优化预测准确率,并且可以通过可视化方法来解释预测结果。

所以基于神经网络协同过滤模型是目前推荐系统的主流形态。

六、算法实现

安装库:

pip install numpy
pip install pandas
pip install tensorflow

1、构造数据矩阵

从用户评分表中加载所有用户的评分数据。

# -*- coding: utf-8 -*-

"""
@contact: 微信 1257309054
@file: recommend_ncf.py
@time: 2024/6/16 22:13
@author: LDC
"""
import os
import django
import joblib
import numpy as np
import pandas as pd
import tensorflow as tf
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from keras.models import load_model

os.environ["DJANGO_SETTINGS_MODULE"] = "book_manager.settings"
django.setup()
from book.models import *

def get_all_data():
    '''
    从数据库中获取所有物品评分数据
    [用户特征(点赞,收藏,评论,
    物品特征(收藏人数,点赞人数,浏览量,评分人数,平均评分)
    ]
    '''
    # 定义字典列表
    user_book_list = []
    # 从评分表中获取所有图书数据
    book_rates = RateBook.objects.all().values('book_id').distinct()
    # 获取每个用户的评分数据
    for user in User.objects.all():
        user_rate = RateBook.objects.filter(user=user)
        if not user_rate:
            # 用户如果没有评分过任何一本图书则跳过循环
            continue
        data = {
   
   'User': f'user_{user.id}'}
        for br in book_rates:
            book_id = br['book_id']
            ur = user_rate.filter(book_id=book_id)
            if ur:
                data[f'book_{book_id}'] = ur.first().mark  # 对应图书的评分
            else:
                data[f'book_{book_id}'] = np.nan  # 设置成空
        user_book_list.append(data)
    data_pd = pd.DataFrame.from_records(user_book_list)
    print(data_pd)
    return data_pd

输出:

  User    1    2    5    7   10  ...  1610  9137  10468  10546  10548  10550
0    1  3.0  NaN  NaN  NaN  NaN  ...   NaN   NaN    3.0    5.0    NaN    NaN
1    2  5.0  5.0  NaN  NaN  NaN  ...   5.0   NaN    NaN    3.0    NaN    NaN
2    3  5.0  NaN  NaN  NaN  NaN  ...   NaN   4.0    5.0    4.0    NaN    NaN
3    4  NaN  NaN  2.0  4.0  5.0  ...   NaN   NaN    NaN    NaN    5.0    3.0
4   67  NaN  NaN  NaN  NaN  NaN  ...   NaN   NaN    NaN    NaN    NaN    NaN
5    9  NaN  NaN  NaN  NaN  NaN  ...   NaN   NaN    4.0    5.0    NaN    NaN

[6 rows x 25 columns]

有数据的列代表用户评分过,1-5代表评分高低,如果没评过分就是NAN,现在我们的目的就是“猜”出来这些没评分过的图书评分是多少?从而根据评分数据完成图书推荐系统。

2、数据向量化

使用神经网络计算,必须将数据进行向量化操作。

def get_data_vector(data):
    '''
    对矩阵进行向量化,便于神经网络学习
    '''
    user_index = data[data.columns[0]]
    data = data.reset_index(drop=True)
    data[data.columns[0]] = data.index.astype('int')
    scaler = 5  # 评分最高为5,把用户的评分归一化到0-1

    df_vector = pd.melt(data, id_vars=[data.columns[0]],
                        ignore_index=True,
                        var_name='book_id',
                        value_name='rate').dropna()
    df_vector.columns = ['user_id', 'book_id', 'rating']
    df_vector['rating'] = df_vector['rating'] / scaler
    df_vector['user_id'] = df_vector['user_id'].apply(lambda x: user_index[x])
    print(df_vector)
    return df_vector

输出:

    user_id book_id  rating
0         1       1     0.6
1         2       1     1.0
2         3       1     1.0
7         2       2     1.0
15        4       5     0.4
21        4       7     0.8
27        4      10     1.0
30        1      15     0.6
...

3、数据进行训练

具体流程为:

1、对数据进行打标签操作
2、定义64个维度针对向量进行处理(神经网络是非线性多维度)
3、创建NCF模型
4、合并 embeddings向量
5、添加全连接层
6、编译模型
7、模型评估
8、模型保存

代码:

def evaluation(y_true, y_pred):
    '''
    模型评估:获取准确率、精准度、召回率、F1-score值
    y_true:正确标签
    y_pred:预测标签
    '''
    accuracy = round(classification_report(y_true, y_pred, output_dict=True)['accuracy'], 3)  # 准确率
    s = classification_report(y_true, y_pred, output_dict=True)['weighted avg']
    precision = round(s['precision'], 3)  # 精准度
    recall = round(s['recall'], 3)  # 召回率
    f1_score = round(s['f1-score'], 3)  # F1-score
    print('神经网络协同推荐(NCF):准确率是{},精准度是{},召回率是{},F1值是{}'.format(accuracy, precision, recall, f1_score))
    return accuracy, precision, recall, f1_score


def get_data_fit(df_vector):
    '''
    数据训练,得到模型
    '''
    scaler = 5  # 特征标准化:最高分为5,需要归一化到0~1
    dataset = df_vector  # 已向量化的数据集
    # 使用LabelEncoder将字符串标签转换为整数标签
    user_encoder = LabelEncoder()
    book_encoder = LabelEncoder()
    dataset['user_id'] = user_encoder.fit_transform(dataset['user_id'])
    dataset['book_id'] = book_encoder.fit_transform(dataset['book_id'])

    # Split the dataset into train and test sets
    train, test = train_test_split(dataset, test_size=0.2, random_state=42)  # 划分训练集与测试集
    # train = dataset

    # Model hyperparameters
    num_users = len(dataset['user_id'].unique())
    num_countries = len(dataset['book_id'].unique())

    embedding_dim = 64  # 64维向量标识

    # 创建NCF模型
    inputs_user = tf.keras.layers.Input(shape=(1,))
    inputs_book = tf.keras.layers.Input(shape=(1,))
    embedding_user = tf.keras.layers.Embedding(num_users, embedding_dim)(inputs_user)
    embedding_book = tf.keras.layers.Embedding(num_countries, embedding_dim)(inputs_book)

    # 合并 embeddings向量
    merged = tf.keras.layers.Concatenate()([embedding_user, embedding_book])
    merged = tf.keras.layers.Flatten()(merged)

    # 添加全连接层
    dense = tf.keras.layers.Dense(64, activation='relu')(merged)
    dense = tf.keras.layers.Dense(32, activation='relu')(dense)
    output = tf.keras.layers.Dense(1, activation='sigmoid')(dense)

    # 编译模型
    model = tf.keras.Model(inputs=[inputs_user, inputs_book], outputs=output)
    model.compile(optimizer='adam', loss='mse', metrics=['mae'])
    # 模型训练
    model.fit(
        [train['user_id'].values, train['book_id'].values],
        train['rating'].values,
        batch_size=64,
        epochs=100,
        verbose=0,
        # validation_split=0.1,
    )


    book_rates = RateBook.objects.all().values('book_id').distinct()
    # 获取每个用户的评分数据
    result_df = {
   
   }
    for user in User.objects.all():
        user_rate = RateBook.objects.filter(user=user)
        if not user_rate:
            # 用户如果没有评分过任何一本图书则跳过循环
            continue
        user = f'user_{user.id}'
        result_df[user] = {
   
   }
        for br in book_rates:
            book_id = br['book_id']
            book = f'book_{book_id}'
            pred_user_id = user_encoder.transform([user])
            pred_book_id = book_encoder.transform([book])
            result = model.predict(x=[pred_user_id, pred_book_id], verbose=0)
            result_df[user][book] = result[0][0]
    result_df = pd.DataFrame(result_df).T
    result_df *= scaler

    print('全部用户预测结果', result_df)

    # 预测测试集并转成整形列表
    y_pred_ = np.floor(model.predict(x=[test['user_id'], test['book_id']], verbose=0) * scaler).tolist()
    y_pred = []
    for y in y_pred_:
        y_pred.append(int(y[0]))
    y_true = (test['rating'] * scaler).tolist()
    evaluation(y_true, y_pred)  # 模型评估
    joblib.dump(user_encoder, 'user_encoder.pkl')  # 保存用户标签
    joblib.dump(book_encoder, 'book_encoder.pkl')  # 保存图书标签
    model.save('ncf.dat')  # 模型保存

输出:

全部用户预测结果           book_1    book_2    book_5  ...  book_10546  book_10548  book_10550
user_1  3.110437  4.324692  2.444845  ...    4.462238    4.399863    1.958362
user_2  4.581644  4.819267  4.083292  ...    4.827301    4.841383    3.094142
user_3  4.728746  4.884580  4.376239  ...    4.892247    4.899843    3.552579
user_4  4.525998  4.803295  4.025316  ...    4.819880    4.832502    3.011951
user_5  4.780589  4.910366  4.502923  ...    4.916562    4.922859    3.671103
user_9  4.551242  4.820321  4.107899  ...    4.833554    4.845706    3.052876

[6 rows x 24 columns]

模型评估:

神经网络协同推荐(NCF):准确率是0.778,精准度是0.611,召回率是0.778,F1值是0.683

可以看到,机器通过神经网络的“学习”,直接“猜出来”所有用户给未评分的书籍可能会评的分数。那么,我们只需要给这些用户推荐他未评分的,但是机器“猜”他评分高的图书即可。

4、数据推荐

代码:

def get_ncf_recommend(user_id, n=10):
    '''
    # 获取推荐
    user_id:用户id
    n:只取前十个推荐结果
    '''
    scaler = 5  # 特征标准化:最高分为5,需要归一化到0~1
    model = load_model('ncf.dat')  # 加载模型
    # 加载标签
    user_encoder = joblib.load('user_encoder.pkl')
    book_encoder = joblib.load('book_encoder.pkl')

    result_df = {
   
   }
    book_rates = RateBook.objects.all().values('book_id').distinct()
    for book in book_rates:
        book_id = book['book_id']
        user = f'user_{user_id}'
        book = f"book_{book_id}"
        pred_user_id = user_encoder.transform([user])
        pred_book_id = book_encoder.transform([book])
        result = model.predict(x=[pred_user_id, pred_book_id], verbose=0)
        if not RateBook.objects.filter(user_id=user_id, book_id=book_id):
            # 过滤掉用户已评分过的
            result_df[book_id] = result[0][0] * scaler
    result_df_sort = sorted(result_df.items(), key=lambda x: x[1], reverse=True)  # 推荐结果按照评分降序排列
    print('预测结果', result_df_sort)
    recommend_ids = []
    for rds in result_df_sort[:n]:
        recommend_ids.append(rds[0])
    print(f'前{n}个推荐结果', recommend_ids)
    return recommend_ids

输出:

预测结果 [(10, 4.443216919898987), (10548, 4.3998634815216064), (1610, 4.373263120651245), (2, 4.324692189693451), (9137, 2.871088683605194), (5, 2.4448448419570923), (7, 2.353670746088028), (683, 2.274640202522278), (51, 2.2518157958984375), (24, 2.241026908159256), (86, 2.1394330263137817), (10550, 1.9583618640899658)]
前10个推荐结果 [10, 10548, 1610, 2, 9137, 5, 7, 683, 51, 24]

5、全部代码

# -*- coding: utf-8 -*-

"""
@contact: 微信 1257309054
@file: recommend_ncf.py
@time: 2024/6/16 22:13
@author: LDC
"""
import os
import django
import joblib
import numpy as np
import pandas as pd
import tensorflow as tf
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from keras.models import load_model

os.environ["DJANGO_SETTINGS_MODULE"] = "book_manager.settings"
django.setup()
from book.models import *


def get_all_data():
    '''
    从数据库中获取所有物品评分数据
    [用户特征(点赞,收藏,评论,
    物品特征(收藏人数,点赞人数,浏览量,评分人数,平均评分)
    ]
    '''
    # 定义字典列表
    user_book_list = []
    # 从评分表中获取所有图书数据
    book_rates = RateBook.objects.all().values('book_id').distinct()
    # 获取每个用户的评分数据
    for user in User.objects.all():
        user_rate = RateBook.objects.filter(user=user)
        if not user_rate:
            # 用户如果没有评分过任何一本图书则跳过循环
            continue
        data = {
   
   'User': f'user_{user.id}'}
        for br in book_rates:
            book_id = br['book_id']
            ur = user_rate.filter(book_id=book_id)
            if ur:
                data[f'book_{book_id}'] = ur.first().mark  # 对应图书的评分
            else:
                data[f'book_{book_id}'] = np.nan  # 设置成空
        user_book_list.append(data)
    data_pd = pd.DataFrame.from_records(user_book_list)
    print(data_pd)
    return data_pd


def get_data_vector(data):
    '''
    对矩阵进行向量化,便于神经网络学习
    '''
    user_index = data[data.columns[0]]
    data = data.reset_index(drop=True)
    data[data.columns[0]] = data.index.astype('int')
    scaler = 5  # 评分最高为5,把用户的评分归一化到0-1

    df_vector = pd.melt(data, id_vars=[data.columns[0]],
                        ignore_index=True,
                        var_name='book_id',
                        value_name='rate').dropna()
    df_vector.columns = ['user_id', 'book_id', 'rating']
    df_vector['rating'] = df_vector['rating'] / scaler
    df_vector['user_id'] = df_vector['user_id'].apply(lambda x: user_index[x])
    print(df_vector)
    return df_vector


def evaluation(y_true, y_pred):
    '''
    模型评估:获取准确率、精准度、召回率、F1-score值
    y_true:正确标签
    y_pred:预测标签
    '''
    accuracy = round(classification_report(y_true, y_pred, output_dict=True)['accuracy'], 3)  # 准确率
    s = classification_report(y_true, y_pred, output_dict=True)['weighted avg']
    precision = round(s['precision'], 3)  # 精准度
    recall = round(s['recall'], 3)  # 召回率
    f1_score = round(s['f1-score'], 3)  # F1-score
    print('神经网络协同推荐(NCF):准确率是{},精准度是{},召回率是{},F1值是{}'.format(accuracy, precision, recall, f1_score))
    return accuracy, precision, recall, f1_score


def get_data_fit(df_vector):
    '''
    数据训练,得到模型
    '''
    scaler = 5  # 特征标准化:最高分为5,需要归一化到0~1
    dataset = df_vector  # 已向量化的数据集
    # 使用LabelEncoder将字符串标签转换为整数标签
    user_encoder = LabelEncoder()
    book_encoder = LabelEncoder()
    dataset['user_id'] = user_encoder.fit_transform(dataset['user_id'])
    dataset['book_id'] = book_encoder.fit_transform(dataset['book_id'])

    # Split the dataset into train and test sets
    train, test = train_test_split(dataset, test_size=0.2, random_state=42)  # 划分训练集与测试集
    # train = dataset

    # Model hyperparameters
    num_users = len(dataset['user_id'].unique())
    num_countries = len(dataset['book_id'].unique())

    embedding_dim = 64  # 64维向量标识

    # 创建NCF模型
    inputs_user = tf.keras.layers.Input(shape=(1,))
    inputs_book = tf.keras.layers.Input(shape=(1,))
    embedding_user = tf.keras.layers.Embedding(num_users, embedding_dim)(inputs_user)
    embedding_book = tf.keras.layers.Embedding(num_countries, embedding_dim)(inputs_book)

    # 合并 embeddings向量
    merged = tf.keras.layers.Concatenate()([embedding_user, embedding_book])
    merged = tf.keras.layers.Flatten()(merged)

    # 添加全连接层
    dense = tf.keras.layers.Dense(64, activation='relu')(merged)
    dense = tf.keras.layers.Dense(32, activation='relu')(dense)
    output = tf.keras.layers.Dense(1, activation='sigmoid')(dense)

    # 编译模型
    model = tf.keras.Model(inputs=[inputs_user, inputs_book], outputs=output)
    model.compile(optimizer='adam', loss='mse', metrics=['mae'])
    # 模型训练
    model.fit(
        [train['user_id'].values, train['book_id'].values],
        train['rating'].values,
        batch_size=64,
        epochs=100,
        verbose=0,
        # validation_split=0.1,
    )


    book_rates = RateBook.objects.all().values('book_id').distinct()
    # 获取每个用户的评分数据
    result_df = {
   
   }
    for user in User.objects.all():
        user_rate = RateBook.objects.filter(user=user)
        if not user_rate:
            # 用户如果没有评分过任何一本图书则跳过循环
            continue
        user = f'user_{user.id}'
        result_df[user] = {
   
   }
        for br in book_rates:
            book_id = br['book_id']
            book = f'book_{book_id}'
            pred_user_id = user_encoder.transform([user])
            pred_book_id = book_encoder.transform([book])
            result = model.predict(x=[pred_user_id, pred_book_id], verbose=0)
            result_df[user][book] = result[0][0]
    result_df = pd.DataFrame(result_df).T
    result_df *= scaler

    print('全部用户预测结果', result_df)

    # 预测测试集并转成整形列表
    y_pred_ = np.floor(model.predict(x=[test['user_id'], test['book_id']], verbose=0) * scaler).tolist()
    y_pred = []
    for y in y_pred_:
        y_pred.append(int(y[0]))
    y_true = (test['rating'] * scaler).tolist()
    evaluation(y_true, y_pred)  # 模型评估
    joblib.dump(user_encoder, 'user_encoder.pkl')  # 保存用户标签
    joblib.dump(book_encoder, 'book_encoder.pkl')  # 保存图书标签
    model.save('ncf.dat')  # 模型保存

def get_ncf_recommend(user_id, n=10):
    '''
    # 获取推荐
    user_id:用户id
    n:只取前十个推荐结果
    '''
    scaler = 5  # 特征标准化:最高分为5,需要归一化到0~1
    model = load_model('ncf.dat')  # 加载模型
    # 加载标签
    user_encoder = joblib.load('user_encoder.pkl')
    book_encoder = joblib.load('book_encoder.pkl')

    result_df = {
   
   }
    book_rates = RateBook.objects.all().values('book_id').distinct()
    for book in book_rates:
        book_id = book['book_id']
        user = f'user_{user_id}'
        book = f"book_{book_id}"
        pred_user_id = user_encoder.transform([user])
        pred_book_id = book_encoder.transform([book])
        result = model.predict(x=[pred_user_id, pred_book_id], verbose=0)
        if not RateBook.objects.filter(user_id=user_id, book_id=book_id):
            # 过滤掉用户已评分过的
            result_df[book_id] = result[0][0] * scaler
    result_df_sort = sorted(result_df.items(), key=lambda x: x[1], reverse=True)  # 推荐结果按照评分降序排列
    print('预测结果', result_df_sort)
    recommend_ids = []
    for rds in result_df_sort[:n]:
        recommend_ids.append(rds[0])
    print(f'前{n}个推荐结果', recommend_ids)
    return recommend_ids


if __name__ == '__main__':
    data_pd = get_all_data()  # 获取数据
    df_vector = get_data_vector(data_pd)  # 数据向量化
    data_recommend = get_data_fit(df_vector)  # 获取数据训练模型
    user_id = 1
    recommend_ids = get_ncf_recommend(user_id)  # 获取用户1的推荐结果

6、总结

我们可以看到,整个流程,深度学习框架Tensorflow帮我们做了大部分的工作,我们其实只是简单的提供了基础数据而已。

首先定义一个embedding (多维空间) 用来理解需要学习的原始数据 :

一个用户对象(含一个属性userId)

一个图书对象(含三个属性:bookId, userId, rating (用户评分))

这里需要进行学习的具体就是让机器理解那个“评分:rating”的含义)这里定义的embedding 维度为64, 本质就是让机器把评分rating 的值当作成一个64维度的空间来进行理解(其实就是从这个rating值当中提取出64个特征来重新定义这个rating)

随后对embedding 进行降维处理:

具体的操作与使用的降维函数曲线有关,这里采用的是先降为32维再降为1维的两道操作方式,原来的代表rating 的embedding 空间从64维降低到了1维。而此时的输出output 对象就是机器对rating完播向量所做出来的“自己的理解”。

最后通过对学习完的输出项output 进行mask(遮罩)测试,通过变换不同的mask(遮罩)来测试结果是否与原始数据相近,或一致,从而来证实机器学习的效果,也就是上文提到的反向传播方式的逆运算。

相关文章
|
23小时前
|
机器学习/深度学习 搜索推荐 TensorFlow
使用Python实现深度学习模型:个性化推荐与广告优化
【7月更文挑战第22天】 使用Python实现深度学习模型:个性化推荐与广告优化
118 70
|
7天前
|
机器学习/深度学习 数据可视化 算法框架/工具
使用Python实现深度学习模型:视频处理与动作识别
【7月更文挑战第16天】 使用Python实现深度学习模型:视频处理与动作识别
43 17
|
6天前
|
机器学习/深度学习 人工智能 自然语言处理
深入神经网络:从感知机到深度学习
【7月更文第17天】当我们谈论人工智能时,神经网络常常是那个闪亮的明星。从最初的简单模型——感知机,到当今复杂而强大的深度学习系统,这场技术革命正以前所未有的方式改变着我们的世界。今天,咱们就用通俗易懂的语言,搭配一些简单的代码示例,来一场《深入神经网络:从感知机到深度学习》的探索之旅。
22 8
|
8天前
|
机器学习/深度学习 人工智能 自然语言处理
算法金 | 秒懂 AI - 深度学习五大模型:RNN、CNN、Transformer、BERT、GPT 简介
**RNN**,1986年提出,用于序列数据,如语言模型和语音识别,但原始模型有梯度消失问题。**LSTM**和**GRU**通过门控解决了此问题。 **CNN**,1989年引入,擅长图像处理,卷积层和池化层提取特征,经典应用包括图像分类和物体检测,如LeNet-5。 **Transformer**,2017年由Google推出,自注意力机制实现并行计算,优化了NLP效率,如机器翻译。 **BERT**,2018年Google的双向预训练模型,通过掩码语言模型改进上下文理解,适用于问答和文本分类。
45 9
|
6天前
|
机器学习/深度学习 编解码 算法框架/工具
使用Python实现深度学习模型:图像超分辨率与去噪
【7月更文挑战第17天】 使用Python实现深度学习模型:图像超分辨率与去噪
22 4
|
2天前
|
机器学习/深度学习 自然语言处理 机器人
使用Python实现深度学习模型:自然语言理解与问答系统
【7月更文挑战第20天】 使用Python实现深度学习模型:自然语言理解与问答系统
11 0
使用Python实现深度学习模型:自然语言理解与问答系统
|
4天前
|
机器学习/深度学习 TensorFlow 语音技术
使用Python实现深度学习模型:语音合成与语音转换
【7月更文挑战第19天】 使用Python实现深度学习模型:语音合成与语音转换
18 1
|
5天前
|
机器学习/深度学习 监控 算法框架/工具
使用Python实现深度学习模型:人脸识别与人脸表情分析
【7月更文挑战第18天】 使用Python实现深度学习模型:人脸识别与人脸表情分析
18 2
|
8天前
|
机器学习/深度学习 数据可视化 TensorFlow
使用Python实现深度学习模型:图像语义分割与对象检测
【7月更文挑战第15天】 使用Python实现深度学习模型:图像语义分割与对象检测
28 2
|
1天前
|
机器学习/深度学习 存储 自然语言处理
使用Python实现深度学习模型:语言翻译与多语种处理
【7月更文挑战第21天】 使用Python实现深度学习模型:语言翻译与多语种处理
13 0