Python与C ++。 差异结果

Question

I have a python code from http://www.albertauyeung.com/mf.php , but I dont know anything about Python programming to improve and change this code. By anyway, I start write it again in C++ with Qt, but my result is so different. The Python code:

import numpy

def matrix_factorisation(R, P, Q, K, steps=5000, alpha=0.0002, beta=0.02):
Q = Q.T
for step in xrange(steps):
    for i in xrange(len(R)):
        for j in xrange(len(R[i])):
            if R[i][j] > 0:
                eij = R[i][j] - numpy.dot(P[i,:],Q[:,j])
                for k in xrange(K):
                    P[i][k] = P[i][k] + alpha * (2 * eij * Q[k][j] - beta * P[i][k])
                    Q[k][j] = Q[k][j] + alpha * (2 * eij * P[i][k] - beta * Q[k][j])
    eR = numpy.dot(P,Q)
    e = 0
    for i in xrange(len(R)):
        for j in xrange(len(R[i])):
            if R[i][j] > 0:
                e = e + pow(R[i][j] - numpy.dot(P[i,:],Q[:,j]), 2)
                for k in xrange(K):
                    e = e + (beta/2) * (pow(P[i][k],2) + pow(Q[k][j],2))
    if e < 0.001:
        break
return P, Q.T

if __name__ == "__main__":
R = [
 [5,3,0,1],
 [4,0,0,1],
 [1,1,0,5],
 [1,0,0,4],
 [0,1,5,4],
]

R = numpy.array(R)

N = len(R)
M = len(R[0])
K = 2

P = numpy.random.rand(N,K)
Q = numpy.random.rand(M,K)

nP, nQ = matrix_factorisation(R, P, Q, K)
nR = numpy.dot(nP, nQ.T)

================================================================================= and C++ code:

int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);

//=============preliminary=================
long double R[5][4]={5,3,0,1,
                4,0,0,1,
                1,1,0,5,
                1,0,0,4,
                0,1,5,4},newR[5][4]={0};
int n=5, m=4,k=2;
long double Q[2][4],P[5][2];

for (int i=0;i<k;i++){
    for (int j=0;j<n;j++){
        P[j][i]=random2(0,1);
    }
    for(int l=0;l<m;l++){
        Q[i][l]=random2(0,1);
    }
}



//  =============  MatrixFactorization(R,P,Q,k)=======================
long double eij=0,sigmaPQ=0;
long double e;
long double alpha=0.0002, beta=0.02;
int t;
for(long  step=0;step <5000;step++){
    t=step;
    for (int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            if(R[i][j]>0){
                sigmaPQ=0;
                for (int z=0;z<k;z++){
                    sigmaPQ += P[i][z]*Q[z][j];
                }
                eij=R[i][j]-sigmaPQ;

                for (int z=0;z<k;z++){
                    P[i][z] += alpha*(2*eij*Q[z][j]-beta*P[i][z]);
                    Q[z][j] += alpha*(2*eij*P[i][z]-beta*Q[z][j]);
                }
            }
        }
    }
    e=0;
    for (int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            if(R[i][j]>0){
                sigmaPQ=0;
                for (int z=0;z<k;z++){
                    sigmaPQ += P[i][z]*Q[z][j];
                }                   
                for (int z=0;z<k;z++){
                    e+=(beta/2)*(qPow( P[i][z],2)+qPow(Q[z][j],2));                        
                }
                e=qSqrt(e);
            }                
        }
    }       
    if(e<0.001)
        break;

}    
//=========== calculate approximate R =============
long double temp;
for (int i=0;i<n;i++){
    for(int j=0;j<m;j++){
        temp=0;
        for(int z=0;z<k;z++){
            temp+=P[i][z]*Q[z][j];
        }
        newR[i][j]=temp;
    }
}
}

the Python code is correct answer. what i should to do, to fix this C++ code?

Answer 1

Break it down into steps and check outputs at each step. print and printf are your friend. :) Or perhaps learn enough of Python to create a pseudo code version which can be translated to C++.

Often times when debugging large code segments I just monitor the data at each logical step in the process. Python makes it easy by inserting print statements at key locations.