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;
}