svd推荐算法
❶ 请问有没有基于SVD算法的遗传优化计算谢谢，，，急用
211 SVD算法
SVD算法是用于求解最线性最小二乘问题SVD算法是基于分解定理：
用于任何矩阵上午×n个，当它等于行数m大于列数n，可以分解为正交矩阵庵×n的非负对角矩阵的乘积
Wn的×n个与Vn×n的正交矩阵的转置，即
上午× N =庵×N·[诊断（WJ
）] n×n的·VT
n×n的，（2）
其中WJ≥0（1≤≤N），U， V分别是
6
I = 1
uijuikδ= JK，6
I = 1
vijvik =δJK（1≤J，K≤n）时，（3）当M <N时，SVD可以执行，在这种情况下，奇异值WJ = 0（M + 1≤≤n），并在相应的U该
列是零，则（3）只，真正≤M K表。因此，无论矩阵A是单数，（2）总可以分解成
行，这意味着，几乎是唯一的分解，分解，形成鞋底：矩阵U，W
第五列元素，做同样的列置换，或矩阵的任一列U和线性组合V，W中的相应元素还是刚刚结束
相同。
显式构造矩阵零空间和正交标准化团体的范围SVD分解。特别是，在U列中，如果它的
相同标签的非零元素WJ，其范围为正交基向量标准化，V的列中，如果其具有相同的
WJ标签是零，则零作为正交空归组。以下多指数衰减T2模式
型，
= M·F，（4）
其中y =（Y1，Y2，...，YN）
自旋回波衰减测量信号，M = [MIJ] N * M = [EXP（ - TI /
T2
）] N * M，F =（F 1，F 2对应于各点的弛豫时间T2的第j，...，FM）
振幅值，T2
（J = 1，2，...，m）为一个一系列的预分配
规定时间T2，通常在模拟（T2min，T2max）选择范围的m个点的数量均匀，我们称为松弛
时间分布，也可以用指数分布2线性均匀分布，等等。定义条件的矩阵数为最大特征值矩的比值
阵列与最小特征值。几个条件，如果矩阵是无穷大，则该矩阵是奇异的;？？如果件数的矩阵
太多，这超出了机器的浮点精确度的倒数，称为矩阵病态矩阵如直接使用AUSS点
求解上述方程。 ，几乎是不可能的，因为矩阵M是一个大数目的条件下，例如：如果该回波间隔τ= 1 2×10 - 3
秒，T2在0 1×10 - 3
。 >10000×10 - 3
服用50点均匀国情总数，矩阵M是高达1016
大小的数量，很明显，矩阵的高度M是病态的。使用SVD分解的方法来解决上述公式中，系数矩阵的Mn×M =
元×m的·[诊断（WJ
）] M×M·VT
M×M，其中U ，V是正交矩阵，诊断（WJ
）是一个对角矩阵，其行
列降序对角线，那么我们就可以很容易地得到最小二乘意义上
^ F = V·诊断 BR /> 1
1
，...，
W1
，0， ...，0·（UT
·Y）。 （5）
其中矩阵的条件数给定的SNR小于约避免不稳定性限制。 （ - ·M·^ F R = y）的标准偏差，其中SNR是从测量数据
估计的信噪比定义为回波振幅的值是由误差向量r分
❷ SVD分解为什么是最好的QR分解和SVD比较LU呢SVD并行算法可行么
基于双边Jacobi旋转的奇异值分解算法
V是A的右奇异向量，也是的特征向量;
U是A的左奇异向量，也是的特征向量。
特别地，当A是对称矩阵的时候，=，即U=V，U的列向量不仅是的特征向量，也是A的特征向量。这一点在主成分分析中会用到。
对于正定的对称矩阵，奇异值等于特征值，奇异向量等于特征向量。
U、V都是正交矩阵，满足矩阵的转置即为矩阵的逆。
双边Jacobi方法本来是用来求解对称矩阵的特征值和特征向量的，由于就是对称矩阵，求出的特征向量就求出了A的右奇异值，的特征值开方后就是A的奇异值。
一个Jacobi旋转矩阵J形如：
它就是在一个单位矩阵的基础上改变p行q行p列q列四个交点上的值，J矩阵是一个标准正交矩阵。
当我们要对H和p列和q列进行正交变换时，就对H施行：
在一次迭代过程当中需要对A的任意两列进行一次正交变换，迭代多次等效于施行
迭代的终止条件是为对角矩阵，即原矩阵H进过多次的双边Jacobi旋转后非对角线元素全部变成了0（实现计算当中不可能真的变为0，只要小于一个很小的数就可以认为是0了）。
每一个J都是标准正交阵，所以也是标准正交阵，记为V，则是，则。从此式也可以看出对称矩阵的左奇异向量和右奇异向量是相等的。V也是H的特征向量。
当特征值是0时，对应的Ui和Vi不用求，我们只需要U和V的前r列就可以恢复矩阵A了（r是非0奇异值的个数），这也正是奇异值分解可以进行数据压缩的原因。
+ View Code
基于单边Jacobi旋转的SVD算法
相对于双边，单边的计算量小，并且容易并行实现。
单边Jacobi方法直接对原矩阵A进行单边正交旋转，A可以是任意矩阵。
同样每一轮的迭代都要使A的任意两列都正交一次，迭代退出的条件是B的任意两列都正交。
单边Jacobi旋转有这么一个性质：旋转前若，则旋转后依然是；反之亦然。
把矩阵B每列的模长提取出来，，把记为V，则。
❸ Matlab 的 svd 是怎么实现的
在MATLAB里打开svd的源码可以看到只有一堆注释，最后写的是该函数为built-in function。事实上，MATLAB的矩阵计算使用的是Intel的MKL库（见之前我写的一个答案如何写出比 MATLAB 更快的矩阵运算程序？ - 过拟合的回答），这个库基本是现有BLAS/LAPACK实现中最快的了。svd是LAPACK中的标准运算，因此MATLAB实际是使用的MKL库来做svd。
MKL作为一个商业库，其算法细节和代码是不公开的，而且业界对于这种基本算法必然会有非常独到的优化，涉及到大量细节（算法本身的细节，以及代码层次的细节）。svd的经典算法有Golub-Kahan算法、分治法、Jacobi法几种，我推测MKL具体实现的是分治法。
❹ K-SVD的基本介绍
K-SVD算法 是2006年由以色列理工学院的Michal Aharon、Michael Elad等人提出来，是一种非常经典的字典训练算法，并且达到了很好的训练效果。其目的是解决下列矩阵等式的解：
其中是要训练的字典，是要训练的、对应字典的稀疏系数矩阵。当矩阵的维数很高时，即使使用计算机软件（如matlab）也很难求解矩阵方程，而该算法正是解决了高维矩阵求解的问题。
❺ 推荐算法有哪些
推荐算法大致可以分为三类：基于内容的推荐算法、协同过滤推荐算法和基于知识的推荐算法。 基于内容的推荐算法，原理是用户喜欢和自己关注过的Item在内容上类似的Item，比如你看了哈利波特I，基于内容的推荐算法发现哈利波特II-VI，与你以前观看的在内容上面（共有很多关键词）有很大关联性，就把后者推荐给你，这种方法可以避免Item的冷启动问题（冷启动：如果一个Item从没有被关注过，其他推荐算法则很少会去推荐，但是基于内容的推荐算法可以分析Item之间的关系，实现推荐），弊端在于推荐的Item可能会重复，典型的就是新闻推荐，如果你看了一则关于MH370的新闻，很可能推荐的新闻和你浏览过的，内容一致；另外一个弊端则是对于一些多媒体的推荐（比如音乐、电影、图片等)由于很难提内容特征，则很难进行推荐，一种解决方式则是人工给这些Item打标签。 协同过滤算法，原理是用户喜欢那些具有相似兴趣的用户喜欢过的商品，比如你的朋友喜欢电影哈利波特I，那么就会推荐给你，这是最简单的基于用户的协同过滤算法（user-based collaboratIve filtering），还有一种是基于Item的协同过滤算法（item-based collaborative filtering），这两种方法都是将用户的所有数据读入到内存中进行运算的，因此成为Memory-based Collaborative Filtering，另一种则是Model-based collaborative filtering，包括Aspect Model，pLSA，LDA，聚类，SVD，Matrix Factorization等，这种方法训练过程比较长，但是训练完成后，推荐过程比较快。 最后一种方法是基于知识的推荐算法，也有人将这种方法归为基于内容的推荐，这种方法比较典型的是构建领域本体，或者是建立一定的规则，进行推荐。 混合推荐算法，则会融合以上方法，以加权或者串联、并联等方式尽心融合。 当然，推荐系统还包括很多方法，其实机器学习或者数据挖掘里面的方法，很多都可以应用在推荐系统中，比如说LR、GBDT、RF（这三种方法在一些电商推荐里面经常用到），社交网络里面的图结构等，都可以说是推荐方法。
❻ SVD算法能不能对一个1*M的矩阵使用
把M*N的矩阵拆分成M*k和k*N的矩阵的乘积往往是为了给出比较节省存贮量和运算量的满秩分解，k肯定不会超过min{M,N}，而且在k<<min{M,N}时比较有价值。SVD是实现满秩分解的一种比较贵的途径，往往在有其它需求（比如低秩逼近）的时候会用到。
你说的情况k>min{1,M}，肯定是吃亏的，属于把简单问题复杂化，实际上没有特殊需求绝对不会这样做。
另外，1*M的矩阵本身可以认为已经处于SVD分解完成的状态，再调用SVD的算法也只不过是归一化，没有别的用。
❼ 怎么理解SVD算法急用
211 SVD算法
SVD算法可用来求解大多数的线性最小二乘法问题. SVD 算法基于如下分解定理:对任
意的矩阵 Am ×n ,当其行数 m 大于等于列数 n 时,可以分解为正交矩阵 Um ×n , 非负对角矩阵
Wn×n以及正交矩阵Vn×n的转置的乘积,即
Am×n = Um×n ·[diag( wj
) ] n×n ·V T
n×n , (2)
其中 wj ≥ 0 (1 ≤j ≤n) ; U , V 为正交矩阵,即满足
6
m
i =1
uijuik = δ jk ,
6
n
i =1
vijvik = δ jk
(1 ≤j , k ≤n) , (3)当 m < n 时,SVD也可以执行,在这种情况下,奇异值 wj = 0 ( m + 1 ≤j ≤n) ,并且 U 中相应的
列都是零,这时(3)式仅对 j , k ≤m 时成立. 故不管矩阵 A 是否是奇异, (2)式的分解总可以进
行,而且这个分解几乎是惟一的. 也就是说,其分解形式惟一到:对矩阵 U 的列、 W 的元素和
V 的列能做相同的置换,或者矩阵 U 和V 的任意列的线性组合,在 W 中对应的元素仍恰好完
全相同.
SVD分解明确地构造了矩阵零空间和值域的正交标准化基. 特别地,对 U 的列,若与其
标号相同的元素 wj 为非零元,则其列为值域的一个正交标准化的基础矢量;对 V 的列,若与
其标号相同的 wj 为零,则其列为零空间的一个正交标准化基. 对于如下的多指数衰减 T2 模
型, 有
y = M ·f , (4)
其中 y = ( y1 , y2 , …, yn )
T
为测量的自旋回波衰减信号, M = [ mij ] n ×m = [ exp ( - ti/
T2 j
) ] n ×m ; f = ( f 1 , f 2 , …, f m)
T
为弛豫时间 T2 j对应的各点的幅度值, T2 j
( j = 1 ,2 , …, m)为预先
指定的 T2 时间分布系列,典型的取法为在( T2min , T2max)区间内对数均匀地选取 m 个点,我们
称为弛豫时间布点,也可采用2的幂指数布点、 线性均匀布点等方式. 矩阵条件数的定义为矩
阵的最大特征值与最小特征值的比值. 若矩阵的条件数为无穷大,则该矩阵奇异;若矩阵的条
件数太大,即其倒数超出了机器的浮点精度,则称该矩阵为病态的矩阵. 若直接采用 G auss分
解求上式,几乎是不可能的,原因是矩阵 M 的条件数相当大,例如:若回波间隔τ= 1. 2 ×10 - 3
s , T2 在0. 1 × 10 - 3
～10000 ×10 - 3
s内对数均匀地取50 个点,则矩阵 M 的条件数可达1016
数
量级,很明显,矩阵 M 是高度病态的. 采用 SVD 分解法来求解上式,系数矩阵 Mn×m =
Un×m ·[diag( wj
) ] m×m · VT
m×m , 这里 U , V 为正交矩阵,diag( wj
)为对角矩阵,其对角元递减排
列,则我们就可以很容易地求得最小二乘意义下的解为
^ f = V · diag
1
w1
,
1
w2
, …,
SNR
w1
, 0 , …,0 ·( UT
·y) . (5)
这里给出了矩阵条件数小于等于SNR的限制,避免了解的不稳定性. 其中 SNR为从测量数据
中估计出的信噪比. SNR定义为第1个回波的幅度值除以误差矢量 r ( r = y - M· ^ f )的标准差
❽ 推荐算法中哪个算法用的比较多些
这是要根据推荐结果微调的，一般用牛顿迭代法很快就能找到最佳值
❾ 求SVD算法的C++实现代码
/** C++ function for SVD
函数原型:
bool svd(vector<vector<double> > A, int K, std::vector<std::vector<double> > &U, std::vector<double> &S, std::vector<std::vector<double> > &V);
其中
A是输入矩阵，假设A的维数是m*n，那么本函数将A分解为U diag(S) V'
其中U是m*K的列正交的矩阵. V是n*K的列正交矩阵，S是K维向量。K由第二个参数指定。
U的第i列是A的第i大奇异值对应的左歧义向量,S[i]=A的第 i大奇异值,V的第i列是A的第i大奇异值对应的右歧义响亮.
K是需要分解的rank，0<K<=min(m,n)
本程序采用的是最基本幂迭代算法，在linux g++下编译通过
**/
#include <cmath>
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <vector>
using namespace std;
const int MAX_ITER=100000;
const double eps=0.0000001;
double get_norm(double *x, int n){
double r=0;
for(int i=0;i<n;i++)
r+=x[i]*x[i];
return sqrt(r);
}
double normalize(double *x, int n){
double r=get_norm(x,n);
if(r<eps)
return 0;
for(int i=0;i<n;i++)
x[i]/=r;
return r;
}
inline double proct(double*a, double *b,int n){
double r=0;
for(int i=0;i<n;i++)
r+=a[i]*b[i];
return r;
}
void orth(double *a, double *b, int n){//|a|=1
double r=proct(a,b,n);
for(int i=0;i<n;i++)
b[i]-=r*a[i];
}
bool svd(vector<vector<double> > A, int K, std::vector<std::vector<double> > &U, std::vector<double> &S, std::vector<std::vector<double> > &V){
int M=A.size();
int N=A[0].size();
U.clear();
V.clear();
S.clear();
S.resize(K,0);
U.resize(K);
for(int i=0;i<K;i++)
U[i].resize(M,0);
V.resize(K);
for(int i=0;i<K;i++)
V[i].resize(N,0);
srand(time(0));
double *left_vector=new double[M];
double *next_left_vector=new double[M];
double *right_vector=new double[N];
double *next_right_vector=new double[N];
while(1){
for(int i=0;i<M;i++)
left_vector[i]= (float)rand() / RAND_MAX;
if(normalize(left_vector, M)>eps)
break;
}
int col=0;
for(int col=0;col<K;col++){
double diff=1;
double r=-1;
for(int iter=0;diff>=eps && iter<MAX_ITER;iter++){
memset(next_left_vector,0,sizeof(double)*M);
memset(next_right_vector,0,sizeof(double)*N);
for(int i=0;i<M;i++)
for(int j=0;j<N;j++)
next_right_vector[j]+=left_vector[i]*A[i][j];
r=normalize(next_right_vector,N);
if(r<eps) break;
for(int i=0;i<col;i++)
orth(&V[i][0],next_right_vector,N);
normalize(next_right_vector,N);
for(int i=0;i<M;i++)
for(int j=0;j<N;j++)
next_left_vector[i]+=next_right_vector[j]*A[i][j];
r=normalize(next_left_vector,M);
if(r<eps) break;
for(int i=0;i<col;i++)
orth(&U[i][0],next_left_vector,M);
normalize(next_left_vector,M);
diff=0;
for(int i=0;i<M;i++){
double d=next_left_vector[i]-left_vector[i];
diff+=d*d;
}
memcpy(left_vector,next_left_vector,sizeof(double)*M);
memcpy(right_vector,next_right_vector,sizeof(double)*N);
}
if(r>=eps){
S[col]=r;
memcpy((char *)&U[col][0],left_vector,sizeof(double)*M);
memcpy((char *)&V[col][0],right_vector,sizeof(double)*N);
}else
break;
}
delete [] next_left_vector;
delete [] next_right_vector;
delete [] left_vector;
delete [] right_vector;
return true;
}
void print(vector<vector<double> > &A){
for(int i=0;i<A.size();i++){
for(int j=0;j<A[i].size();j++){
cout<<setprecision(3)<<A[i][j]<<' ';
}
cout<<endl;
}
}
int main(){
int m=10;
int n=5;
srand(time(0));
vector<vector<double> > A;
A.resize(m);
for(int i=0;i<m;i++){
A[i].resize(n);
for(int j=0;j<n;j++)
A[i][j]=(float)rand()/RAND_MAX;
}
print(A);
cout<<endl;
vector<vector<double> > U;
vector<double> S;
vector<vector<double> > V;
svd(A,2,U,S,V);
cout<<"U="<<endl;
print(U);
cout<<endl;
cout<<"S="<<endl;
for(int i=0;i<S.size();i++){
cout<<S[i]<<' ';
}
cout<<endl;
cout<<"V="<<endl;
print(V);
return 0;
}