五种算法B站视频推荐系统|vue+springboot前后端分离架构、多层感知机+矩阵奇异值分解+协同过滤四种推荐算法集成+机器学习预测算法、B站视频爬取

文章结尾部分有CSDN官方提供的学长 联系方式名片
文章结尾部分有CSDN官方提供的学长 联系方式名片

功能特色

🩷编号：R08
🩷架构：3+1架构，网站端+大屏端+管理端端+后端,vue+springbot+mysql
🩷功能：四种推荐算法+机器学习预测算法+大屏可视化+管理端增上改查
🩵算法：多层感知神经网络推荐、矩阵奇异值分解推荐、UserCF推荐、ItemCF推荐、机器学习回归算法预测Up流量；
🩷网站端：视频推荐、视频详情、视频搜索、流量预测、实名认证、登录注册等
🩷大屏端：酷炫echarts可视化展示
🩷管理端：数据增删改查、用户管理、视频管理
🩷Scrapy爬取数据：数据爬取

视频解说

网站功能

推荐中

推荐中显示等待，提高用户体验。

多层感知神经网络推荐

一种深度学习模型，通过神经网络学习用户和视频的隐含特征，能够捕捉更复杂的用户行为模式，从而做出精准推荐，适合处理非线性关系。

矩阵奇异值分解推荐

通过对用户-视频交互矩阵进行奇异值分解，提取潜在的用户兴趣和视频特征，从而推荐与用户兴趣最匹配的视频，通常用于解决稀疏数据问题。

UserCF推荐

基于用户行为相似性，推荐与当前用户相似的其他用户喜好的视频。通过比较用户之间的历史互动，找出“邻近用户”并推荐他们喜欢的内容。

ItemCF推荐

根据视频间的相似性进行推荐，推荐与用户历史观看的视频相似的其他视频。通过计算视频的相似度，找出常被同一类用户观看的相关视频。

机器学习回归算法预测Up流量

实名认证

视频详情

视频查询

评论LSTM情感分析

利用LSTM进行评论的好评、差评的情感分析：

大屏功能

echarts 实现花瓣图、漏斗图、柱状图、词云、等分析视频推荐系统各个指标

管理功能

登录

后台主页

用户管理

视频管理

评论管理

推荐算法

import sys

import numpy as np
from torch.utils.data import DataLoader
from torch import nn
import torch.nn.functional as F
import torch
from sklearn.metrics import precision_score,recall_score,accuracy_score

import dataloader


class ALS_MLP (nn.Module):
    def __init__(self, n_users, n_items, dim):
        super(ALS_MLP, self).__init__()
        '''
        :param n_users: 用户数量
        :param n_items: 物品数量
        :param dim: 向量维度
        '''
        # 随机初始化用户的向量,
        self.users = nn.Embedding( n_users, dim, max_norm=1 )
        # 随机初始化物品的向量
        self.items = nn.Embedding( n_items, dim, max_norm=1 )

        #初始化用户向量的隐层
        self.u_hidden_layer1 = self.dense_layer(dim, dim // 2)
        self.u_hidden_layer2 = self.dense_layer(dim//2, dim // 4)

        #初始化物品向量的隐层
        self.i_hidden_layer1 = self.dense_layer(dim, dim // 2)
        self.i_hidden_layer2 = self.dense_layer(dim//2, dim // 4)

        self.sigmoid = nn.Sigmoid()

    def dense_layer(self,in_features,out_features):
        #每一个mlp单元包含一个线性层和激活层，当前代码中激活层采取Tanh双曲正切函数。
        return nn.Sequential(
            nn.Linear(in_features, out_features),
            nn.Tanh()
        )

    def forward(self, u, v, isTrain=True):
        '''
         :param u: 用户索引id shape:[batch_size]
         :param i: 用户索引id shape:[batch_size]
         :return: 用户向量与物品向量的内积 shape:[batch_size]
         '''
        u = self.users(u)
        v = self.items(v)

        u = self.u_hidden_layer1(u)
        u = self.u_hidden_layer2(u)

        v = self.i_hidden_layer1(v)
        v = self.i_hidden_layer2(v)

        #训练时采取dropout来防止过拟合
        if isTrain:
            u = F.dropout(u)
            v = F.dropout(v)

        uv = torch.sum( u*v, axis = 1)
        logit = self.sigmoid(uv*3)
        return logit

def doEva(net, d):
    d = torch.LongTensor(d)
    u, i, r = d[:, 0], d[:, 1], d[:, 2]
    with torch.no_grad():
        out = net(u,i,False)
    y_pred = np.array([1 if i >= 0.5 else 0 for i in out])
    y_true = r.detach().numpy()
    p = precision_score(y_true, y_pred)
    r = recall_score(y_true, y_pred)
    acc = accuracy_score(y_true,y_pred)
    return p,r,acc

def train( epochs = 10, batchSize = 1024, lr = 0.001, dim = 256, eva_per_epochs = 1):
    '''
    :param epochs: 迭代次数
    :param batchSize: 一批次的数量
    :param lr: 学习率
    :param dim: 用户物品向量的维度
    :param eva_per_epochs: 设定每几次进行一次验证
    '''
    #读取数据
    user_set, item_set, train_set, test_set = \
        dataloader.readRecData(test_ratio = 0.1)
    #初始化ALS模型
    net = ALS_MLP(len(user_set), len(item_set), dim)
    #定义优化器
    optimizer = torch.optim.AdamW( net.parameters(), lr = lr, weight_decay=0.2)
    #定义损失函数
    criterion = torch.nn.BCELoss()
    #开始迭代
    for e in range(epochs):
        all_lose = 0
        #每一批次地读取数据
        for u, i, r in DataLoader(train_set,batch_size = batchSize, shuffle = True):
            optimizer.zero_grad()
            r = torch.FloatTensor(r.detach().numpy())
            result = net(u,i)
            loss = criterion(result,r)
            all_lose += loss
            loss.backward()
            optimizer.step()
        print('epoch {}, avg_loss = {:.4f}'.format(e,all_lose/(len(train_set)//batchSize)))

        #评估模型
        if e % eva_per_epochs==0:
            p, r, acc = doEva(net, train_set)
            print('train: Precision {:.4f} | Recall {:.4f} | accuracy {:.4f}'.format(p, r, acc))
            p, r, acc = doEva(net, test_set)
            print('test: Precision {:.4f} | Recall {:.4f} | accuracy {:.4f}'.format(p, r, acc))

def als_mlp_predict(userId=1, itemSize=100, count=4, dim=64):
    # 读取数据
    user_set, item_set, train_set, test_set = \
        dataloader.readRecData( test_ratio=0.1)

    # 预测一个用户的所有的评分形成一个元祖
    train_set = []
    for i in range(1, itemSize):
        train_set.append((userId, i, 0))
    # print(train_set)
    # print(train_set)
    # 初始化ALS模型
    net = ALS_MLP(len(user_set), len(item_set), dim)

    d = torch.LongTensor(train_set)
    u, i, r = d[:, 0], d[:, 1], d[:, 2]
    with torch.no_grad():
        out = net(u, i)

    predict = []
    preds = out.tolist()
    # print(len(preds))
    # 找出最大值,通过这种方式可以求出多个
    for i in range(0, count):
        m = max(preds)
        idx = preds.index(m)
        predict.append(dict(iid=idx, score=m))
        del preds[idx]

    # print(predict)
    return predict

def test(dim = 64):
    result = als_mlp_predict(1, 2000, 5)
    print(result)

if __name__ == '__main__':
    # train()
    # test()
    param1 = sys.argv[1]
    # param1 = "1"
    result = als_mlp_predict(int(param1), 55, 4)
    list = []
    # print(result)
    for r in result:
        list.append(dict(iid=r['iid'], rate=r['score']))
    print(list)