Funk-SVD实现的矩阵分解

最新推荐文章于 2024-07-16 17:31:06 发布
最新推荐文章于 2024-07-16 17:31:06 发布
阅读量1.6k 收藏 16
点赞数 3
文章标签： 矩阵 线性代数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rick_rui/article/details/124971303
版权

一、算法简介

1.1 基本特性

        所谓的矩阵分解其实就是将一个矩阵分解为两个或者多个低维矩阵的，这两个低维矩阵能够代表原矩阵特性并且预测原矩阵中未知的特性——在推荐系统矩阵中的描述就是：通过评估低维矩阵乘积来拟合评分矩阵。

        沿用之前图，面对一个有m个用户与n个项目的稀疏的矩阵R_{m\times n}，第i行表示第i个用户对于每个项目的评分，图中的问号部分表示这部分没有具体的评分；第j列表示某个项目不同用户给予的评分状况。

 现在假设将此矩阵分解为两个或者多个矩阵的乘积，这里假设有两个低维矩阵P_{m\times k}与Q_{k\times n}，存在R_{m\times n}=P_{m\times k}Q_{k\times n}（这里为了方便，我们将矩阵R中的那些未评分项目默认写为0）

这里采用的技术是 奇异值分解（Singular Value Decomposition，SVD）这个算法在降维、数据压缩、推荐系统中都有广泛的应用。但是！今天使用的SVD是一种基于机器学习的“ 伪 ”SVD，因为SVD本身是要求将原矩阵分解为可取的两个矩阵，但是这里的SVD我们是做近似分解(所以上图我用的约等于)，然后通过拟合让分解得到的矩阵的部分元素不断接近原矩阵的有效元素，最终使得原矩阵的无效元素(0元素)也能被拟合预测出来。这种SVD最早被Simon Funk在博客中发布，因此又叫做Funk-SVD。

       具体的思路是先随机构建矩阵P与Q，然后通过矩阵P×Q取得的每个数据同主要矩阵R的有效值进行差值计算，并通过得到的差值逐步调整P与Q的每个向量，如此反复操作直到这样的差值达到足够小的程度，或者说执行调整的次数满足某个上限后（比如MAE或者RSME在某个可接受的范围）

        可以发现，在P矩阵中可以取出m个k维向量，在Q矩阵中可以取出n个k维向量。这俩矩阵所具有的这(m+n)个向量可以唯一表示R矩阵中的某个用户或者项目情况，而m×n相互交叉可以得到对于某个用户-项目的评分的估计。于是不妨将那m个向量命名为用户向量，其余n个为项目向量。然后下面继续为这个定义建立数学模型：

        取出稀疏矩阵中的实值定义为一个三元组数组，正如我们数据集的txt文本所示这样：

0,0,5
0,1,3
0,2,4
0,3,3
0,4,3
0,5,5
0,6,4
0,7,1
0,8,5
0,9,3
0,10,2
0,11,5
0,12,5
0,13,5
...

 分别表示：{用户，项目，评分}，这里的评分是确定的实值，不能为0（因为我们定义0为无实际评分），有集合S={(u,v)|r_{uv}≠∅}，这里u表示用户下标，v为项目下标，需要注意，集合S拥有的组合数目是要小于 用户数 * 项目数，集合S中的组合(u,v)也并非全部u取值与v取值的枚举。

通过矩阵分解将用户向量与项目向量定义为：


        因此不难得出对于用户u与物品v的预测评分\hat{r}_{uv}=\vec{p}_{u}\vec{q}_{v}。这里要注意一个细节，\vec{p}_{u}是面向矩阵P的向量，\vec{q}_{v}是面向Q的向量，而这俩矩阵本身是基于随机值生成的，因此得到的某个预测评分\hat{r}_{uv}有可能在原R矩阵中\hat{r}_{uv}=0，这个细节正是奇异值分解具有预测能力的原理。所以有等式R_{m\times n}\approx P_{m\times k}\times Q_{k\times n}=\hat{R}_{m\times n}，而算法正是通过\hat{R}_{m\times n}预测R_{m\times n}，预测准确度由r_{uv}=0时|\hat{r}_{uv}-r_{uv}|的大小保证。

        那么这些向量是否具有一些实际含义呢，一种可以用来解释的含义就是：向量kk维可以表示这个向量的语义对于kk个隐含因子的重视程度。例如\vec{p}_{u}是面向用户的向量，假设k=3有\vec{p}_{u}=(u_{1},u_{2},u_{3})，这里的u1可以是用户觉得的电影情节是否精彩对于她来说的重要性，u2可以是演员演技水平对于他来说的重要性......而对于\vec{q}_{v}，我们假设是电影，那么这里就可以是电影本身的精彩程度、电影演员水平......而得到\hat{r}_{uv}正式用户自己认为的重要性同电影本身这个属性的占比作乘积，然后各属性加权的结果。本身各维度在逻辑上是可以自由扩展的隐因子，不必解释也性，这里用语义去解释能更加方便理解吧。

        另一个问题，特征空间k的大小应该设置为多大合适呢，这个并没有非常确定的设置，其本身也没有非常好的解释性，常常称之为" 隐因子向量 "，只用知道其存在即可，是用户向量\vec{p}_{u}与项目向量\vec{q}_{v}的基本维度。

二、损失函数与梯度下降(Gradient descent)

2.1 损失函数

 确定了平方损失函数之后，沿着损失的方向利用梯度下降方法进行求解。

 简单来说，其实梯度下降法就是让变量沿着目标函数的负梯度方向进行下降直到局部最低点，因为我们当前这个问题本身就是求取损失函数的最小值，因此只要对损失函数求偏导然而确定一个两个向量（所代表P与Q向量）梯度下降的迭代式{\vec{p}}'_{u}与{\vec{q}}'_{v}即可.

 

就如同上图，从x0得到逆梯度方向（正向）的变量位移移动x1，但在x1的到逆梯度方向（负向）的位移移动到x2吗，如此反复直到一个稳定的局部最小。当然本文的案例中抽象出来是二维的，而并非此处一维的，此图于此只为说明此方法罢了。

         首先对于平方损失函数分别求向量\vec{p}_{u}与\vec{q}_{v}方向的偏导，从而得到损失函数的负梯度：

  然后依据负梯度方向更新P与Q的每个向量，同时自定义一个极小的参数α>0，这样便得到了基础的调节函数：

 

 这里的α其实有步长之功效，即是学习速率，也是梯度向量，需要调参确定。不同的步长对于地图下降的方式都会存在影响，当步长过小其下降速度会过慢：

                                               当α过小

合适时，很快就能抵达谷底：

  当这个值为1的时候，会在两侧同等移动，陷入僵局：

  当这个值大于1时，反而会想希望到达的最小值的反方向走

 2.3 加入正则项的损失函数

 还有一种损失函数的评判标准，就是引入正则项||\vec{p}_{u}||^{2}+||\vec{q}_{v}||^{2}来进一步丰富损失函数的含义。之前的平方误差可以权衡模型的欠拟合程度，保证系统对于训练集的基本学习程度。而正则项就如同方差，能权衡模型的稳定性，如此一来：一旦损失函数ff高也预示模型不稳定、对非训练集数据可能表现笨拙、过拟合。一般来说，在Rn×m过于稀疏时会出现这种过拟合情况。

        至于使用二范数限制而不是一范数限制似乎也是有一定说法(二范数：向量全维度的平方和，然后开根号；一范数：向量全维度绝对值和)，一范数会使得很多因子为0，削减模型大小，而二范数值会令因子接近0而不是为0。

        最终有损失函数：

 

  其中映入了控制参数λ/2，继续，模仿之前的梯度下降的方式，对于f2求偏导可得损失函数的负梯度：

然后引入α，构造原向量按照负梯度方向进行更新的调整函数：

 

  如此便得到携带正则式的求解迭代式，这个迭代过程引入了方差的限制，控制了最终的P与Q矩阵预测的结果不会过拟合。

2.4 算法思路总结

1.确定k值之后，针对用户-项目矩阵R_{m\times n}生成矩阵P_{m\times k}与Q_{k\times n}，其中生成内容为随机数。
2.计算矩阵R_{m\times n}中的实际取值r_{uv}同P_{m\times k}Q_{k\times n}中得到的预测值\hat{r}_{uv}的差值
3.通过第二步取得的差值，利用公式4、5或者公式进行9、10去调整P矩阵的n个向量\vec{p}_{u}与Q矩阵的m个向量\vec{q}_{v}，得到全新的矩阵P与Q
4.重复2、3两步，直到最终MAE或者RSME收敛于一个预定义可靠的范围内。或者单纯循环若干次即可

完整代码：

package machinelearning.recommendersystem;

import java.io.*;
import java.util.Random;

/*
 * Matrix factorization for recommender systems.
 * 
 * @author Rui Chen 1369097405@qq.com.
 */

public class MatrixFactorization {
	/**
	 * Used to generate random numbers.
	 */
	Random rand = new Random();

	/**
	 * Number of users.
	 */
	int numUsers;

	/**
	 * Number of items.
	 */
	int numItems;

	/**
	 * Number of ratings.
	 */
	int numRatings;

	/**
	 * Training data.
	 */
	Triple[] dataset;

	/**
	 * A parameter for controlling learning regular.
	 */
	double alpha;

	/**
	 * A parameter for controlling the learning speed.
	 */
	double lambda;

	/**
	 * The low rank of the small matrices.
	 */
	int rank;

	/**
	 * The user matrix U.
	 */
	double[][] userSubspace;

	/**
	 * The item matrix V.
	 */
	double[][] itemSubspace;

	/**
	 * The lower bound of the rating value.
	 */
	double ratingLowerBound;

	/**
	 * The upper bound of the rating value.
	 */
	double ratingUpperBound;

	/**
	 ************************ 
	 * The first constructor.
	 * 
	 * @param paraFilename
	 *            The data filename.
	 * @param paraNumUsers
	 *            The number of users.
	 * @param paraNumItems
	 *            The number of items.
	 * @param paraNumRatings
	 *            The number of ratings.
	 ************************ 
	 */
	public MatrixFactorization(String paraFilename, int paraNumUsers, int paraNumItems,
			int paraNumRatings, double paraRatingLowerBound, double paraRatingUpperBound) {
		numUsers = paraNumUsers;
		numItems = paraNumItems;
		numRatings = paraNumRatings;
		ratingLowerBound = paraRatingLowerBound;
		ratingUpperBound = paraRatingUpperBound;

		try {
			readData(paraFilename, paraNumUsers, paraNumItems, paraNumRatings);
			// adjustUsingMeanRating();
		} catch (Exception ee) {
			System.out.println("File " + paraFilename + " cannot be read! " + ee);
			System.exit(0);
		} // Of try
	}// Of the first constructor

	/**
	 ************************ 
	 * Set parameters.
	 * 
	 * @param paraRank
	 *            The given rank.
	 * @throws IOException
	 ************************ 
	 */
	public void setParameters(int paraRank, double paraAlpha, double paraLambda) {
		rank = paraRank;
		alpha = paraAlpha;
		lambda = paraLambda;
	}// Of setParameters

	/**
	 ************************ 
	 * Read the data from the file.
	 * 
	 * @param paraFilename
	 *            The given file.
	 * @throws IOException
	 ************************ 
	 */
	public void readData(String paraFilename, int paraNumUsers, int paraNumItems,
			int paraNumRatings) throws IOException {
		File tempFile = new File(paraFilename);
		if (!tempFile.exists()) {
			System.out.println("File " + paraFilename + " does not exists.");
			System.exit(0);
		} // Of if
		BufferedReader tempBufferReader = new BufferedReader(new FileReader(tempFile));

		// Allocate space.
		dataset = new Triple[paraNumRatings];
		String tempString;
		String[] tempStringArray;
		for (int i = 0; i < paraNumRatings; i++) {
			tempString = tempBufferReader.readLine();
			tempStringArray = tempString.split(",");
			dataset[i] = new Triple(Integer.parseInt(tempStringArray[0]),
					Integer.parseInt(tempStringArray[1]), Double.parseDouble(tempStringArray[2]));
		} // Of for i

		tempBufferReader.close();
	}// Of readData

	/**
	 ************************ 
	 * Initialize subspaces. Each value is in [0, 1].
	 ************************ 
	 */
	void initializeSubspaces() {
		userSubspace = new double[numUsers][rank];

		for (int i = 0; i < numUsers; i++) {
			for (int j = 0; j < rank; j++) {
				userSubspace[i][j] = rand.nextDouble();
			} // Of for j
		} // Of for i

		itemSubspace = new double[numItems][rank];
		for (int i = 0; i < numItems; i++) {
			for (int j = 0; j < rank; j++) {
				itemSubspace[i][j] = rand.nextDouble();
			} // Of for j
		} // Of for i
	}// Of initializeSubspaces

	/**
	 ************************ 
	 * Predict the rating of the user to the item
	 * 
	 * @param paraUser
	 *            The user index.
	 ************************ 
	 */
	public double predict(int paraUser, int paraItem) {
		double resultValue = 0;
		for (int i = 0; i < rank; i++) {
			// The row vector of an user and the column vector of an item
			resultValue += userSubspace[paraUser][i] * itemSubspace[paraItem][i];
		} // Of for i
		return resultValue;
	}// Of predict

	/**
	 ************************ 
	 * Train.
	 * 
	 * @param paraRounds
	 *            The number of rounds.
	 ************************ 
	 */
	public void train(int paraRounds) {
		initializeSubspaces();

		for (int i = 0; i < paraRounds; i++) {
			updateNoRegular();
			if (i % 50 == 0) {
				// Show the process
				System.out.println("Round " + i);
				System.out.println("MAE: " + mae());
			} // Of if
		} // Of for i
	}// Of train

	/**
	 ************************ 
	 * Update sub-spaces using the training data.
	 ************************ 
	 */
	public void updateNoRegular() {
		for (int i = 0; i < numRatings; i++) {
			int tempUserId = dataset[i].user;
			int tempItemId = dataset[i].item;
			double tempRate = dataset[i].rating;

			double tempResidual = tempRate - predict(tempUserId, tempItemId); // Residual

			// Update user subspace
			double tempValue = 0;
			for (int j = 0; j < rank; j++) {
				tempValue = 2 * tempResidual * itemSubspace[tempItemId][j];
				userSubspace[tempUserId][j] += alpha * tempValue;
			} // Of for j

			// Update item subspace
			for (int j = 0; j < rank; j++) {
				tempValue = 2 * tempResidual * userSubspace[tempUserId][j];

				itemSubspace[tempItemId][j] += alpha * tempValue;
			} // Of for j
		} // Of for i
	}// Of updateNoRegular

	/**
	 ************************ 
	 * Compute the RSME.
	 * 
	 * @return RSME of the current factorization.
	 ************************ 
	 */
	public double rsme() {
		double resultRsme = 0;
		int tempTestCount = 0;

		for (int i = 0; i < numRatings; i++) {
			int tempUserIndex = dataset[i].user;
			int tempItemIndex = dataset[i].item;
			double tempRate = dataset[i].rating;

			double tempPrediction = predict(tempUserIndex, tempItemIndex);// +
																			// DataInfo.mean_rating;

			if (tempPrediction < ratingLowerBound) {
				tempPrediction = ratingLowerBound;
			} else if (tempPrediction > ratingUpperBound) {
				tempPrediction = ratingUpperBound;
			} // Of if

			double tempError = tempRate - tempPrediction;
			resultRsme += tempError * tempError;
			tempTestCount++;
		} // Of for i

		return Math.sqrt(resultRsme / tempTestCount);
	}// Of rsme

	/**
	 ************************ 
	 * Compute the MAE.
	 * 
	 * @return MAE of the current factorization.
	 ************************ 
	 */
	public double mae() {
		double resultMae = 0;
		int tempTestCount = 0;

		for (int i = 0; i < numRatings; i++) {
			int tempUserIndex = dataset[i].user;
			int tempItemIndex = dataset[i].item;
			double tempRate = dataset[i].rating;

			double tempPrediction = predict(tempUserIndex, tempItemIndex);

			if (tempPrediction < ratingLowerBound) {
				tempPrediction = ratingLowerBound;
			} // Of if
			if (tempPrediction > ratingUpperBound) {
				tempPrediction = ratingUpperBound;
			} // Of if

			double tempError = tempRate - tempPrediction;

			resultMae += Math.abs(tempError);
			// System.out.println("resultMae: " + resultMae);
			tempTestCount++;
		} // Of for i

		return (resultMae / tempTestCount);
	}// Of mae

	/**
	 ************************ 
	 * Compute the MAE.
	 * 
	 * @return MAE of the current factorization.
	 ************************ 
	 */
	public static void testTrainingTesting(String paraFilename, int paraNumUsers, int paraNumItems,
			int paraNumRatings, double paraRatingLowerBound, double paraRatingUpperBound,
			int paraRounds) {
		try {
			// Step 1. read the training and testing data
			MatrixFactorization tempMF = new MatrixFactorization(paraFilename, paraNumUsers,
					paraNumItems, paraNumRatings, paraRatingLowerBound, paraRatingUpperBound);

			tempMF.setParameters(5, 0.0001, 0.005);

			// Step 3. update and predict
			System.out.println("Begin Training ! ! !");
			tempMF.train(paraRounds);

			double tempMAE = tempMF.mae();
			double tempRSME = tempMF.rsme();
			System.out.println("Finally, MAE = " + tempMAE + ", RSME = " + tempRSME);
		} catch (Exception e) {
			e.printStackTrace();
		} // Of try
	}// Of testTrainingTesting

	/**
	 ************************ 
	 * @param args
	 ************************ 
	 */
	public static void main(String args[]) {
		testTrainingTesting("D:/data/movielens-943u1682m.txt", 943, 1682, 10000, 1, 5, 2000);
	}// Of main

	public class Triple {
		public int user;
		public int item;
		public double rating;

		/**
		 *********************
		 * The constructor.
		 *********************
		 */
		public Triple() {
			user = -1;
			item = -1;
			rating = -1;
		}// Of the first constructor

		/**
		 *********************
		 * The constructor.
		 *********************
		 */
		public Triple(int paraUser, int paraItem, double paraRating) {
			user = paraUser;
			item = paraItem;
			rating = paraRating;
		}// Of the first constructor

		/**
		 *********************
		 * Show me.
		 *********************
		 */
		public String toString() {
			return "" + user + ", " + item + ", " + rating;
		}// Of toString
	}// Of class Triple

}// Of class MatrixFactorization
Rick_rui
关注
Funk-SVD_funk-svd_funksvd_矩阵分解代码FunkSVD_
09-29
矩阵分解FUNKSVD代码，可用作推荐系统
推荐算法 SVD、FunkSVD、BiasSVD、SVD++原理
Irvinfaith的博客
01-14 2094
1. 介绍 SVD（奇异值分解）多用于数据降维等领域，在推荐算法中多用于评分的矩阵预测。 2. 基本概念 2.1 SVD 2.1.1 原理 对于非对称且非方阵的矩阵不能直接进行特征值分解，且由于AATAA^TAAT与ATAA^TAATA是对称的方阵，所以可以得到以下式子： AAT=PΛ1PT AA^T=P\Lambda_1 P^T AAT=PΛ1​PT ATA=QΛ2QT A^TA=Q\Lambda_2 Q^T ATA=QΛ2​QT 且Λ1和Λ2\Lambda_1和\Lambda_2Λ1​和Λ2​为对角矩阵
机器学习——Funk-SVD实现的矩阵分解
m0_45085885的博客
05-27 556
文章目录一、算法简介1.1 基本特性1.2 奇异值分解（Singular Value Decomposition，SVD）二、算法思路三、代码实现 一、算法简介 1.1 基本特性 矩阵分解将一个矩阵分解为两个或者多个低维矩阵的，这两个低维矩阵能够代表原矩阵特性并且预测原矩阵中未知的特性——在推荐系统矩阵中的描述就是：通过评估低维矩阵乘积来拟合评分矩阵。 图 1. 如图1所示，一个有m个用户与n个项目的稀疏的矩阵Rm×nR_{m×n}Rm×n​，第i行表示第i个用户对于每个项目的评分，第j列表示某个项目不同
SVD分解详解
最新发布
qq_61636702的博客
07-16 546
对于一个nxn\text{nxn}nxn的方阵A\text{A}A，如果A\text{A}A可以分解为APDP−1A=PDP^{-1}APDP−1，其中P\text{P}P是由A\text{A}A的特征向量构成的矩阵，D\text{D}D是对角矩阵，对角线上是A\text{A}A的特征值，那么A\text{A}A的特征值分解就存在。A\text{A}A是nxn\text{nxn}nxn的方阵。P\text{P}P是一个nxn。
【矩阵分解二】FunkSVD
凝眸伏笔的博客
05-26 6202
一句话总结改进点和优化点：改进SVD的计算效率问题、数据稀疏问题；将矩阵R分解为两个低维矩阵，通过重构的低维矩阵预测用户对物品的评分，目标函数中加入正则，控制模型方差。
[推荐系统] SVD、FunkSVD、BiasSVD和SVD++
藏知阁
08-29 1744
FunkSVD FunkSVD方法是Simon Funk在Netflix电影推荐比赛中使用并取得良好效果，因此得名。 不同传统SVD分解成3个矩阵，FunkSVD为了简化运算，只分解为2个矩阵： Mm×n=Pm×kTQk×n M_{m \times n} = P_{m \times k}^T Q_{k \times n} Mm×n​=Pm×kT​Qk×n​ 那么怎么得到矩阵P和Q呢？这里巧妙地利用了优化的思想： 假设函数： y=qjTpi y = q_j^Tp_i y=qjT​pi​ 损失函数： L=∑i,
推荐系统入门（三）：矩阵分解MF&因子分解机FM（附代码）
南有芙蕖
10-24 8693
推荐系统入门（三）：矩阵分解MF&因子分解机FM（附代码） 目录推荐系统入门（三）：矩阵分解MF&因子分解机FM（附代码）一、 矩阵分解MF1. 隐含语义分析技术1.1 隐语义模型1.2 矩阵分解算法1.3 矩阵分解算法求解2. Funk-SVD算法3. Bias SVD算法4. 编程实现思考二、 因子分解机FM1. FM模型的引入1.1 逻辑回归模型及其缺点1.2 二阶交叉项的考虑及改进2. FM公式的理解3. FM模型的应用4. 代码实践4.1 调包实现4.1.1 电影评分数据集实战4.
大数据——协同过滤推荐算法：矩阵分解
gjinc的博客
08-14 578
矩阵分解的方法也分为很多种：SVD、LFM、BiasSVD和SVD++。
毕业设计 - 基于LFM矩阵分解CF算法购物网站商品（电影/音乐/图书）推荐系统（python，包含论文、演示视频、详细文档）
04-04
LFM也就是Funk SVD矩阵分解：用隐语义模型进行协同过滤的目标，揭示隐藏的特征，这些特征能够解释为什么给出对应的预测评分。这些特征可能是无法用语言描述的，事实上我们并不知道，”玄学“，我们可以认为，用户之...
svdpkg_SVD_
10-01
在实际应用中，往往采用改良版的SVD，如矩阵分解加正则化（Funk SVD）、交替最小二乘法（ALS）等方法，以解决上述挑战，并进一步提升推荐系统的性能。 **总结：** SVD作为推荐系统中的核心算法，通过分解用户-物品...
著名 SVD算法的python快速实现_推荐算法_python_代码_下载
06-07
总的来说，SVD在推荐系统中的应用展示了矩阵分解在处理大规模数据时的强大能力，而Python提供了丰富的库和工具，使得这种复杂的技术可以被高效地实现和应用。通过熟练掌握SVD算法及其Python实现，开发者可以在推荐...
《现代推荐算法》矩阵分解系列（SVD，FunkSVD，BiasSVD）原理
01-06
文章来源《现代推荐算法》矩阵分解系列（SVD，FunkSVD，BiasSVD）原理 . 奇异值分解(SVD) 奇异值分解(SVD)原理与主要应用在数据降维中，可以将这个用户物品对应的m×n矩阵M进行SVD分解，并通过选择部分较大的一些奇异值来同时进行降维，也就是说矩阵M此时分解为： Mm×n=Um×kTDk×kVk×nM_{m \times n} = U_{m \times k}^{T}D_{k \times k}V_{k
funk-svd:Netflix奖期间Simon Funk推广的著名SVD算法的python快速实现
05-01
:high_voltage: 放克 funk-svd是一个Python 3库，实现了著名的SVD算法的快速版本，该算法在竞赛中由Simon Funk。 用于加速算法，使我们的运行速度比的Cython实现（参考）快10倍以上。 电影镜头20M RMSE MAE 时间 惊喜 0.88 0.68 10分40秒 放克-svd 0.88 0.68 42秒 安装 在终端中运行pip install git+https://github.com/gbolmier/funk-svd 。 贡献 欢迎所有贡献，错误报告，错误修复，增强功能和想法。 有关如何贡献的详细概述，请参见。 快速示例 ： >> > from funk_svd . dataset import fetch_ml_ratings >> > from funk_svd import SVD >> > from sklearn . metri
SVD++三篇相关论文
12-23
阅读这些论文，可以有效帮助理解SVD++，实现SVD++程序
SVD.rar_SVD_decomposition_svd java_svd...java
09-24
5. 机器学习：SVD在机器学习领域也有广泛应用，如主题模型（Latent Dirichlet Allocation, LDA）和矩阵分解方法（如 Funk SVD）等。 总结，SVD作为一种强大的矩阵分解技术，在数据科学和工程中有着广泛的应用。Java...
基于矩阵分解的协同过滤算法实现：FunkSVD（LFM）
あずにゃん梓喵的博客
07-06 1272
日萌社 人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新） 基于矩阵分解的CF算法实现（一）：LFM LFM也就是前面提到的Funk SVD矩阵分解 LFM原理解析 LFM(latent factor model)隐语义模型核心思想是通过隐含特征联系用户和物品，如下图： P矩阵是User-LF矩阵，即用户和隐含特征矩阵。LF有三个，表示共总有三个隐含特征。 Q矩阵是LF-Item矩阵，即隐含特征和物品的矩阵.
《推荐系统笔记（六）》svd在推荐系统中的应用推广（FunkSVD，BiasSVD以及SVD++）及简单实战（surprise库）
qq_30841655的博客
07-29 1823
前言 奇异值分解（SVD）可以将任意矩阵分解成两个方阵和一个对角矩阵的乘积。借助于SVD，我们可以将推荐系统中的用户-评分矩阵进行分解，通过推广的SVD方法（FunkSVD，BiasSVD和SVD++），我们还可以进一步做评分矩阵的补全。根据补全的评分矩阵，我们将可以给用户推荐他没有购买过的产品。因此，SVD方法在推荐系统中具有重要的应用价值。 下面，我们将逐个介绍 原始SVD，FunkSVD，BiasSVD以及SVD++。介绍完这些算法之后，我们将在movielens数据集上，用第三方库surprise进
推荐系统 ---- SVD矩阵分解
weixin_41521681的博客
01-18 3991
目录 目录 SVD  转载      推荐算法之 Slope One 算法 转载 矩阵分解在协同过滤推荐算法中的应用 1. 矩阵分解用于推荐算法要解决的问题 2. 传统的奇异值分解SVD用于推荐 3. FunkSVD算法用于推荐 4. BiasSVD算法用于推荐 5. SVD++算法用于推荐 6. 矩阵分解推荐...
FunkSVD、biasSVD、SVD++对MovieLens数据集进行评分预测
qq_27328197的博客
03-05 2255
文章目录前言FunkSVD原理与应用举例biasSVD原理与应用举例SVD++原理与应用举例总结 前言 传统SVD在使用上的局限： SVD分解要求矩阵是稠密的 => 矩阵中的元素不能有缺失；所以，类似于数据清洗，我们需要先对矩阵中的缺失元素进行补全； 先有鸡，还是先有蛋。实际上传统SVD更适合做降维。 存在的问题：矩阵往往是稀疏的，大量缺失值 => 计算量大；填充方式简单粗暴 => 噪音大。 在SVD的基础上，提出了改进的算法FunkSVD、biasSVD、SVD++，原理和举例见下文。
写一个基于矩阵分解funksvd的改进算法，以movielens-small数据集为例，评判预测效果
04-04
改进算法： 传统的FunkSVD算法中，用户矩阵和物品矩阵的维度相同，但在实际应用中，用户数量往往远大于物品数量，因此用户矩阵的维度往往较大。为了解决这个问题，我们可以将用户矩阵分解为两个较小的矩阵，而不是一个大矩阵。具体地，设用户矩阵为 $U$，则可以将其分解为两个矩阵 $P$ 和 $Q$，其中 $P$ 的维度为 $m\times k$，$Q$ 的维度为 $k\times n$，$k$ 为一个较小的数。矩阵 $P$ 表示用户的特征，矩阵 $Q$ 表示物品的特征。 则预测评分可以表示为： $$ \hat{r}_{ui} = \sum_{f=1}^{k} p_{uf}q_{if} $$ 模型的损失函数可以表示为： $$ \min_{P,Q} \sum_{(u,i)} (r_{ui}-\hat{r}_{ui})^2 + \lambda_P\|P\|^2 + \lambda_Q\|Q\|^2 $$ 其中 $\lambda_P$ 和 $\lambda_Q$ 是正则化参数。 优化方法可以采用随机梯度下降法，更新规则如下： $$ p_{uf} \leftarrow p_{uf} + \alpha(e_{ui}q_{if} - \lambda_Pp_{uf})\\ q_{if} \leftarrow q_{if} + \alpha(e_{ui}p_{uf} - \lambda_Qq_{if}) $$ 其中 $\alpha$ 是学习率，$e_{ui}$ 表示预测评分和真实评分之差。 评估方法可以采用均方根误差（RMSE）和平均绝对误差（MAE）。 使用movielens-small数据集进行测试，代码如下： ```python import numpy as np import pandas as pd from sklearn.model_selection import train_test_split class FunkSVD: def __init__(self, n_factors=10, learning_rate=0.01, reg_P=0.01, reg_Q=0.01, n_epochs=10): self.n_factors = n_factors self.learning_rate = learning_rate self.reg_P = reg_P self.reg_Q = reg_Q self.n_epochs = n_epochs def fit(self, X): self.n_users = X.user_id.nunique() self.n_items = X.item_id.nunique() self.mean_rating = X.rating.mean() # 将用户矩阵分解为两个矩阵，分别表示用户的特征和物品的特征 self.P = np.random.normal(scale=1/self.n_factors, size=(self.n_users, self.n_factors)) self.Q = np.random.normal(scale=1/self.n_factors, size=(self.n_factors, self.n_items)) for epoch in range(self.n_epochs): for u, i, r in X.values: # 计算预测评分 pred = self.P[u] @ self.Q[:, i] + self.mean_rating # 计算误差 e = r - pred # 更新参数 self.P[u] += self.learning_rate * (e * self.Q[:, i] - self.reg_P * self.P[u]) self.Q[:, i] += self.learning_rate * (e * self.P[u] - self.reg_Q * self.Q[:, i]) def predict(self, X): y_pred = [] for u, i in X.values: pred = self.P[u] @ self.Q[:, i] + self.mean_rating y_pred.append(pred) return np.array(y_pred) def evaluate(self, X_test): y_true = X_test.rating.values y_pred = self.predict(X_test[['user_id', 'item_id']]) rmse = np.sqrt(np.mean((y_true - y_pred) ** 2)) mae = np.mean(np.abs(y_true - y_pred)) return {'RMSE': rmse, 'MAE': mae} # 加载数据 df = pd.read_csv('ratings.csv') df_small = df.sample(frac=0.1, random_state=42) # 划分训练集和测试集 X_train, X_test = train_test_split(df_small, test_size=0.2, random_state=42) # 训练模型 model = FunkSVD(n_factors=10, learning_rate=0.01, reg_P=0.01, reg_Q=0.01, n_epochs=10) model.fit(X_train) # 评估模型 print(model.evaluate(X_test)) ``` 运行结果： ``` {'RMSE': 1.0203227739623778, 'MAE': 0.8095047804550533} ``` 可以看到，使用改进后的FunkSVD算法在movielens-small数据集上的预测效果还是比较不错的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值