Discussion :

[anotherboo]

Bonjour,

Je suis actuellement sur un pb dont je n arrive pas à me depatouiller:
je doit realiser une ACP pour passer un graph de 50 dimensions à 3.
Mon programme est une adaptation d'un projet qui tourne avec Matlab.
Dans ce programme l acp est realisé par une fonction de Matlab que je m efforce de réccrire en java :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
%%CODE MATLAB
function [pc, score, latent, tsquare] = princomp(x);
[m,n] = size(x); 
r = min(m-1,n);      // %% max possible rank of x
avg = mean(x);  
centerx = (x - avg(ones(m,1),:));
 
display ('centerx./sqrt(m-1)'); // debug print
display (centerx./sqrt(m-1));  // debug print
 
[U,latent,pc] = svd(centerx./sqrt(m-1),0); // SingularValueDecomposition
 
display ('pc'); // debug print
display (pc);  // c est la que je suis bloqué par les calculs...
 
score = centerx*pc;
// on va s arreter la c est suffisant pour le moment

Donc je suis allé faire un tour sur le net pour trouver une API et calculer les SingularValueDecomposition.
JAMA permet de realiser ces calculs : http://math.nist.gov/javanumerics/jama/

donc j ai implémenter en java tout le code Matlab ci dessus mais les resultats des calculs sont différents entre JAMA et Matlab ??????
ci dessous le code java qui fait la meme chose

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
 public double[][] prinComp( double[][] array) 
    {
        int rows = array.length;
        int cols = array[0].length;
        int r = Math.min( rows - 1 , cols );
 
        double[] avg = avg( array );
        Matrix centerx = new Matrix( array ).minus( getAvgMatrix(avg , rows) ); 
 
        // Singular value Decomposition
        double[][] sqrt=  arrayRightDivide(centerx, Math.sqrt( rows-1 ) );
 
        System.out.print( "arrayRightDivide(centerx, Math.sqrt( rows-1 ) ) = " );
        Debug.printArray(sqrt); 
 
        // jusqu ici tout va bien les resultats correspondent
 
        double[][] pc;
        pc = svd( sqrt );
        Matrix V = new Matrix(pc);
        // score = centerx*pc;
        Matrix score = centerx.times( V );
        return score.getArray();
 
    }
 
 public void svd( double[][] array) 
    {
        SingularValueDecomposition svd = new Matrix(array).svd() ;
 
        Matrix U = svd.getU();
        Matrix S = svd.getS(); // latent
        Matrix V = svd.getV(); // pc
 
        System.out.print( "U = " );
        Debug.printArray( U.getArray() );
 
        System.out.print( "latent = " );
        Debug.printArray( S.getArray() );
 
        System.out.print( "PC = " );
        Debug.printArray( V.getArray() ); // LES VALEURS ne correspondent pas a celles calculer par MatLab ??
 
    }

J ai aussi essayer avec une autre API qui donne des resultats justes pour 5 colonnes sur les 8 que comporte la matrice PC.
C est meme pas possible que toutes ces APIs soient buggées , j dois faire qqchose de faux qqpart mais alors ou ? ou alors MatLab ?? non qd meme pas ??

Une idée pour m aiguiller car la ca m'a un peu coupé l herbe sous le pied.
(N' y voyez aucune apologie)

[anotherboo]

Je viens de realiser mes calculs avec 3 api differentes
JAMA http://math.nist.gov/javanumerics/jama/
COLT http://dsd.lbl.gov/~hoschek/colt/
MJT http://rs.cipr.uib.no/mtj/

Apres plusieurs corrections de bugs j arrive aux conclusions suivantes
Colt et JAMA qui sont probablement les meme implementations donnent tous les 2:

V => V.* (-1)
U => U.* (-1)
S => S

MTJ
V => V'
U => U.* (-1)
S => S ( un vecteur et pas une matrice )

apres je ne sais pas trop pourquoi