动手学机器学习双线性模型+习题

本文介绍了在推荐系统中如何使用矩阵分解技术,如基于用户和电影特征的矩阵乘法,以及如何通过MF和FM模型预测用户对电影的评分。讨论了正则化方法和梯度更新策略,特别强调了FM模型的双线性特性及其在处理稀疏数据时的优势。
摘要由CSDN通过智能技术生成

在数学中,双线性的含义为,二元函数固定任意一个自变量时,函数关于另一个自变量线性

矩阵分解

设想有N个用户和M部电影,构建一个用户画像库,包含每个用户更偏好哪些类型的特征,以及偏好的程度。假设特征的个数是d,那么所有电影的特征构成的矩阵是P∈R^Mxd,用户喜好构成的矩阵是Q∈R^Nxd

 最后,用这两个矩阵的乘积 R = P.T * Q 可以还原出用户对电影的评分。即使用户对某部电影并没有打分,我们也能通过矩阵乘积,根据用户喜欢的特征和该电影具有的特征,预测出用户对电影的喜好程度

实际上,我们通常能获取到的并不是P和Q,而是打分的结果R。并且由于一个用户只会对极其有限的一部分电影打分,矩阵R是非常稀疏的,绝大多数元素都是空白。因此,我们需要从R有限的元素中推测出用户的喜好P和电影的特征Q

 变成MSE形式+正则化得到:

这里的正则化不是针对整个矩阵,而是每一行,因为电影之间、用户之间是相互独立的

对p和q的梯度:

 

动手实现矩阵分解

import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm # 进度条工具

data = np.loadtxt('movielens_100k.csv', delimiter=',', dtype=int)
print('数据集大小:', len(data))
# 用户和电影都是从1开始编号的,我们将其转化为从0开始
data[:, :2] = data[:, :2] - 1

# 计算用户和电影数量
users = set()
items = set()
for i, j, k in data:
    users.add(i)
    items.add(j)
user_num = len(users)
item_num = len(items)
print(f'用户数:{user_num},电影数:{item_num}')

# 设置随机种子,划分训练集与测试集
np.random.seed(0)

ratio = 0.8
split = int(len(data) * ratio)
np.random.shuffle(data)
train = data[:split]
test = data[split:]

# 统计训练集中每个用户和电影出现的数量,作为正则化的权重
user_cnt = np.bincount(train[:, 0], minlength=user_num)
item_cnt = np.bincount(train[:, 1], minlength=item_num)
print(user_cnt[:10])
print(item_cnt[:10])

# 用户和电影的编号要作为下标,必须保存为整数
user_train, user_test = train[:, 0], test[:, 0]
item_train, item_test = train[:, 1], test[:, 1]
y_train, y_test = train[:, 2], test[:, 2]

用set去重

user_cnt用np.bincount计算数组 train 中第一列中每个元素出现的次数

class MF:
    def __init__(self, N, M, d):
        # N是用户数量,M是电影数量,d是特征维度
        # 定义模型参数
        self.user_params = np.ones((N, d))
        self.item_params = np.ones((M, d))

    def pred(self, user_id, item_id):
        # 预测用户user_id对电影item_id的打分
        # 获得用户偏好和电影特征
        user_param = self.user_params[user_id]
        item_param = self.item_params[item_id]
        # 返回预测的评分
        rating_pred = np.sum(user_param * item_param, axis=1)
        return rating_pred

    def update(self, user_grad, item_grad, lr):
        # 根据参数的梯度更新参数
        self.user_params -= lr * user_grad
        self.item_params -= lr * item_grad

给定用户 ID 和电影 ID,计算用户参数和电影参数的乘积,并返回预测的评分

def train(model, learning_rate, lbd, max_training_step, batch_size):
    train_losses = []
    test_losses = []
    batch_num = int(np.ceil(len(user_train) / batch_size))
    with tqdm(range(max_training_step * batch_num)) as pbar:
        for epoch in range(max_training_step):
            # 随机梯度下降
            train_rmse = 0
            for i in range(batch_num):
                # 获取当前批量
                st = i * batch_size
                ed = min(len(user_train), st + batch_size)
                user_batch = user_train[st: ed]
                item_batch = item_train[st: ed]
                y_batch = y_train[st: ed]
                # 计算模型预测
                y_pred = model.pred(user_batch, item_batch)
                # 计算梯度
                P = model.user_params
                Q = model.item_params
                errs = y_batch - y_pred
                P_grad = np.zeros_like(P)
                Q_grad = np.zeros_like(Q)
                for user, item, err in zip(user_batch, item_batch, errs):
                    P_grad[user] = P_grad[user] - err * Q[item] + lbd * P[user]
                    Q_grad[item] = Q_grad[item] - err * P[user] + lbd * Q[item]
                model.update(P_grad / len(user_batch), Q_grad / len(user_batch), learning_rate)

                train_rmse += np.mean(errs ** 2)
                # 更新进度条
                pbar.set_postfix({
                    'Epoch': epoch,
                    'Train RMSE': f'{np.sqrt(train_rmse / (i + 1)):.4f}',
                    'Test RMSE': f'{test_losses[-1]:.4f}' if test_losses else None
                })
                pbar.update(1)

            # 计算测试集上的RMSE
            train_rmse = np.sqrt(train_rmse / len(user_train))
            train_losses.append(train_rmse)
            y_test_pred = model.pred(user_test, item_test)
            test_rmse = np.sqrt(np.mean((y_test - y_test_pred) ** 2))
            test_losses.append(test_rmse)

    return train_losses, test_losses

np.ceil 用于计算数组中每个元素的向上取整值

遍历训练集中的每个批量,进行随机梯度下降训练

根据梯度公式求梯度,并根据批大小调整

通过 set_postfix 方法设置进度条的附加信息,在更新完附加信息后,使用 pbar.update(1) 更新进度条,使其前进一步

pred的结果:也差不多相差1

因子分解机

FM 的应用场景与 MF 有一些区别,MF 的目标是从交互的结果中计算出用户和物品的特征;而 FM 则正好相反,希望通过物品的特征和某个用户点击这些物品的历史记录,预测该用户点击其他物品的概率,即点击率(click through rate,CTR)

由于被点击和未被点击是一个二分类问题,CTR 预估可以用逻辑斯谛回归模型来解决,然而逻辑回归的线性参数化假设中不同的特征xi与xj之间并没有运算,因此需要进一步引入双线性部分:

写成向量形式:

物体的特征向量one-hot后会过于稀疏,y(x)对w求导后得到的xixj大多地方都是0,所以难以对wij更新

从该结果中可以看出,只要xs≠0,参数的梯度vs就不为零,可以用梯度相关的算法对其更新。因此,即使特征向量非常稀疏,FM 模型也可以正常进行训练

模型还存在一个问题。双线性模型考虑不同特征之间乘积的做法,虽然提升了模型的能力,但也引入了额外的计算开销。可以对上面的公式做一些变形,改变计算顺序来降低时间复杂度

 至此,FM 的预测公式为:

 动手实现因子分解机

class FM:
    def __init__(self, feature_num, vector_dim):
        # vector_dim代表公式中的k,为向量v的维度
        self.theta0 = 0.0 # 常数项
        self.theta = np.zeros(feature_num) # 线性参数
        self.v = np.random.normal(size=(feature_num, vector_dim)) # 双线性参数
        self.eps = 1e-6 # 精度参数

    def _logistic(self, x):
        # 工具函数,用于将预测转化为概率
        return 1 / (1 + np.exp(-x))

    def pred(self, x):
        # 线性部分
        linear_term = self.theta0 + x @ self.theta
        # 双线性部分
        square_of_sum = np.square(x @ self.v)
        sum_of_square = np.square(x) @ np.square(self.v)
        # 最终预测
        y_pred = self._logistic(linear_term \
            + 0.5 * np.sum(square_of_sum - sum_of_square, axis=1))
        # 为了防止后续梯度过大,对预测值进行裁剪,将其限制在某一范围内
        y_pred = np.clip(y_pred, self.eps, 1 - self.eps)
        return y_pred

    def update(self, grad0, grad_theta, grad_v, lr):
        self.theta0 -= lr * grad0
        self.theta -= lr * grad_theta
        self.v -= lr * grad_v

np.clip将预测值限制在 [self.eps, 1 - self.eps] 的范围内,如果预测值超出了这个范围,就将其设置为边界值(因为用了sigmoid)

习题

1.B。只要有不为0的特征就能训练

2.C。C不涉及θ1和θ2之间的乘积或内积,因此不是一个双线性模型;D不是标准的双线性形式,但它可以被视为双线性的,它涉及到了θ1和θ2的乘积

3.题目中这种编码方式叫作label encoder

避免顺序假设: Label Encoder 将类别按照它们出现的顺序进行编码,这可能会给模型引入错误的假设,认为类别之间存在顺序关系

避免偏好性: Label Encoder 可能会给编码后的类别赋予不同的数值,这可能导致模型在训练过程中对数值较大的类别产生偏好

适用性广泛: One-Hot Encoder 适用于大多数机器学习模型,包括线性模型、树模型等

4.

class MF:
    def __init__(self, N, M, d):
        # N是用户数量,M是电影数量,d是特征维度
        # 定义模型参数
        self.user_params = np.ones((N, d))
        self.item_params = np.ones((M, d))
        self.global_bias = 0.0  # 全局打分偏置
        self.user_bias = np.zeros(N)  # 用户打分偏置
        self.item_bias = np.zeros(M)  # 物品打分偏置

    def pred(self, user_id, item_id):
        # 预测用户user_id对电影item_id的打分
        # 获得用户偏好和电影特征
        user_param = self.user_params[user_id]
        item_param = self.item_params[item_id]
        # 计算预测分数
        pred_score = np.sum(user_param * item_param, axis=1)
        pred_score += self.global_bias  # 添加全局打分偏置
        pred_score += self.user_bias[user_id]  # 添加用户打分偏置
        pred_score += self.item_bias[item_id]  # 添加物品打分偏置
        return pred_score

    def update(self, user_grad, item_grad, global_bias_grad, user_bias_grad, item_bias_grad, lr):
        # 根据参数的梯度更新参数
        self.user_params -= lr * user_grad
        self.item_params -= lr * item_grad
        self.global_bias -= lr * global_bias_grad
        self.user_bias -= lr * user_bias_grad
        self.item_bias -= lr * item_bias_grad

def train(model, learning_rate, lbd, max_training_step, batch_size):
    train_losses = []
    test_losses = []
    batch_num = int(np.ceil(len(user_train) / batch_size))
    with tqdm(range(max_training_step * batch_num)) as pbar:
        for epoch in range(max_training_step):
            # 随机梯度下降
            train_rmse = 0
            for i in range(batch_num):
                # 获取当前批量
                st = i * batch_size
                ed = min(len(user_train), st + batch_size)
                user_batch = user_train[st: ed]
                item_batch = item_train[st: ed]
                y_batch = y_train[st: ed]
                # 计算模型预测
                y_pred = model.pred(user_batch, item_batch)
                # 计算梯度
                P = model.user_params
                Q = model.item_params
                errs = y_batch - y_pred
                P_grad = np.zeros_like(P)
                Q_grad = np.zeros_like(Q)
                # 计算全局打分偏置、用户打分偏置和物品打分偏置的梯度
                global_bias_grad = -np.mean(errs)  # 全局打分偏置梯度
                user_bias_grad = np.zeros_like(model.user_bias)
                item_bias_grad = np.zeros_like(model.item_bias)
                for user, item, err in zip(user_batch, item_batch, errs):
                    user_bias_grad[user] += -err
                    item_bias_grad[item] += -err
                    P_grad[user] = P_grad[user] - err * Q[item] + lbd * P[user]
                    Q_grad[item] = Q_grad[item] - err * P[user] + lbd * Q[item]
                model.update(P_grad / len(user_batch), Q_grad / len(user_batch), 
                             global_bias_grad, user_bias_grad / len(user_batch), 
                             item_bias_grad / len(user_batch), learning_rate)
                
                train_rmse += np.mean(errs ** 2)
                # 更新进度条
                pbar.set_postfix({
                    'Epoch': epoch,
                    'Train RMSE': f'{np.sqrt(train_rmse / (i + 1)):.4f}',
                    'Test RMSE': f'{test_losses[-1]:.4f}' if test_losses else None
                })
                pbar.update(1)

            # 计算 RMSE 损失
            train_rmse = np.sqrt(train_rmse / len(user_train))
            train_losses.append(train_rmse)
            y_test_pred = model.pred(user_test, item_test)
            test_rmse = np.sqrt(np.mean((y_test - y_test_pred) ** 2))
            test_losses.append(test_rmse)
    
    return train_losses, test_losses

之前

加了之后可以看到loss低了

5.略

6.对不起,做不到>_<

  • 9
    点赞
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值