# Matrix Kurtosis berechnen



## poulin80 (9. Jan 2012)

Hallo an alle!

Ich bin zum ersten Mal in einem Forum. Ich arbeite gerade daran, die Kurtosis einer Matrix zeilenweise auszurechnen. Dann die Zeile mit der max. Kurtosis in eine neue Matrix als Spalte zu speichern und die dim. der Matrix verringern und wieder die max. Kurtosis finden usw. bis die gesamte Matrix abgearbeitet ist. Ich habe es schon probiert, die ganze Matrix als Array einzulesen und die Zeilen als Teilarrays abzuarbeiten. Leider scheitere ich immer daran, die Dimension zu verringern, d.h. eine Zeile zu löschen. Die Matrix als Array List zu definieren habe ich nicht hinbekommen, da es sich um double Werte handelt. Hätte vielleicht jemand eine Idee, die zur Lösung beiträgt??? Brauche das schon bis morgen und bin super gestresst deshalb....

Vielen Dank für Eure Mühe schonmal im Voraus.


----------



## Marco13 (9. Jan 2012)

Im Zweifelsfall einen neuen Array erstellen, und mit zwei verschachtelten for-Schelifen die alte Matrix (außer der weggelassenen Zeile) in die neue kopieren. Nicht schön, nicht effizient, aber einfach...


----------



## poulin80 (9. Jan 2012)

Vielen Dank für Deine schnelle Antwort.

Leider habe ich gerade einen Fehler in der Berechnung der Kurtosis bemerkt, aber ich finde ihn nicht. Also es wird eine Zeile der Matrix eingegeben und die Kurtosis berechnet. Irgendwie macht es aber eine Schleife, sodass ich ständig das gleiche Ergebnis bekomme...


```
public  double kurtosis(double[] teilarray) {
	int n = N;
	 double erwartungswert = 0;
	    erwartungswert = mean(teilarray);

	    double var = 1;
	   
	    double standardabweichung =0;
	    double abweichung = 0;
		double  p_var =0;
		double p_var2[]= new double [teilarray.length];
	    double curt_relative=0;
	    
	for (int i=0; i < n; ++i) {
		
	abweichung = teilarray[i] - erwartungswert;

	standardabweichung += abweichung;
	
	p_var =abweichung*abweichung ;
	p_var2[i]=standardabweichung*standardabweichung ;
	 var += p_var;
	double erwartungswert2= mean(p_var2);
	double erwartungswert2_quadriert = erwartungswert2 * erwartungswert2;
	//System.out.println("erwartungswert2_quadriert:");
	//System.out.println(erwartungswert2_quadriert);
	
	
	 //curt_relative = p_var*p_var-3*(erwartungswert2_quadriert)/(erwartungswert2_quadriert);
	 curt_relative =( 1-3*(erwartungswert2_quadriert))/(erwartungswert2_quadriert);
	 curt_relative = curt_relative/n;
	 
	 
	}
	
curt_relative = Math.abs( curt_relative);
	//System.out.println("curt_relative:");
	//System.out.println(curt_relative);
	
	return curt_relative;
	
	}
```

Vielleicht kann mir jemand weiterhelfen?? Ich hoffe, ich habe das mit dem Quellcode einfügen richtig gemacht??


----------



## Marco13 (9. Jan 2012)

Ich weiß zwar nicht, was die "Kurtosis" ist, aber... wie wird die methode denn aufgerufen? Wird explizit ein neuer Array für die Zeile erstellt?


----------



## poulin80 (9. Jan 2012)

Hallo,

also hier ist der Aufruf der Methode:


```
for(int t = 0; t < Z.length; t++){
		    	
				for(int u= 0; u <N; u=u+N){
		
					double []teilarray =Arrays.copyOfRange(result,u,u+N);

					
					
					kurtosisarray[t]=kurtosis(teilarray);
					
			}
				
		  }
```

Z ist eine Matrix, die zeilenweise an die Methode übergeben wird. Das Ergebnis wird in kurtosisarray gespeichert, sodass am Ende für jede Matrixzeile 1 Kurtosiswert in dem Array steht.

Vielen Dank und LG


----------



## Marco13 (9. Jan 2012)

Hmja... da wird vermutlich jedes Element des Arrays das Ergebnis der letzten Zeile der Matrix sein, wegen der inneren Schleife. Das sollte wohl eher sowas sein wie

```
for(int t = 0; t < Z.length; t++){
    double []teilarray =Arrays.copyOfRange(result,t*N,t*N+N);
    kurtosisarray[t]=kurtosis(teilarray);
}
```


----------



## poulin80 (9. Jan 2012)

Hallo,

ja super, das sieht ganz gut aus. 

Vielen Dank. 

Wahrscheinlich kommt gleich die nächste Frage. Ich muß jetzt das max in dem kurtosisarray finden und die dazugehörige Zeile der Matrix als erste Spalte einer neuen Matrix nehmen. Die alte Zeile entfernen und wieder die max. Kurtosis bestimmen usw. stöhn....   

Mal schauen, wie weit ich komme.

LG


----------



## poulin80 (10. Jan 2012)

Hallo,

ich habe schon wieder ein Problem. meine Schleife ist jetzt fertig, sodass zeilenweise die Matrix abgearbeitet wird jedes mal die max. Kurtosis berechnet wird, die Zeile mit  der max. kurtosis wird auf 0 gesetzt und die Zeilennr. in ein Array kopiert werden kann. Allerdings läuft die Schleife, aber es wird immer nur der  Wert der max. Kurtosis vom 1. Durchlauf in das Array geschrieben und das für jede Matrixzeile. Eigentlich sollte aber immer eine neue Zeile gefunden werden mit max. Kurtosis?

Vielleicht hat jemand eine Idee?? Ich wäre super dankbar, da ich den Fehler irgendwie nicht finden kann.
Vielen Dank und LG

Hier der Code:

```
for(int q = 0; q < Z.length; q++){			    
   for(int r = 0; r < kurtosisarray.length; r++){		   
      for(int s = 0; s < kurtosisarray.length; s++){
		 for(int t = 0; t < Z.length; t++){
	
			teilarray =Arrays.copyOfRange(result,t*N,t*N+N);		
			// teilarray =Arrays.copyOfRange(result,u,u+N);

					kurtosisarray[t]=kurtosis(teilarray);

			 }
		 
		 max_curt_temp[s]= zeile_mit_max_curt(kurtosisarray);
		 
		  }
   
             double m= max_curt_temp[0];
             System.out.println("m:"); 
             System.out.println(m); 
             max_curt[r++]= m;
             
                  for (int j=0; j<Z[1].length; j++){
	                 Z[(int) m][j]=0;
                       }
                }

}
```


----------



## Marco13 (10. Jan 2012)

Poste mehr Code und klare Aussagen, aber vorher... q,r,s,t, mieserabel eingerückt, ... räum' das mal auf. 

```
private static float[] computeKurtosisArray(float input[], int inputSize) { ... }

private static void doit()
{
    ...
    float kurtosis[] = computeKurtosisArray(input, size); 

    // So, jetzt der nächste Schritt:
...
}
```


----------



## poulin80 (10. Jan 2012)

Hallo,

habe versucht es anders einzurücken:

Also hier ist fast der ganze Code:



```
package ica;

import data.Data;
import histogram.Histogram;

import java.text.DecimalFormat;
import java.util.*;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.Object.*;

import org.jfree.util.ArrayUtilities;


import normaldistribution.NormalDistribution;
import pca.PCA;
import statistic.Statistic;
import pca2.PCA2;
import diagram.Diagram;
import Jama.LUDecomposition; 
import Jama.Matrix; 



public class ICA {
	
	//private static final double relative_curt = 0;
	//private static double curt_relative = 0;
	//int P= data.Data.datalenght;
	//int N = data.Data.datalenght;
	
	public static int P;
	public static int N;
	
	double[][] b;
	double[]c;
 
public double[] curt; 
public double[][] zufallsmatrix;
public static double[][] neue_zufallsmatrix;
public static double[][] Z;
public static double[][] cov_z;
double[][]eingabematrix;
double[][] zufallsmatrix_invers;
double[][] einheitsmatrix_inv;

public double[][] zeile0_geglaettet;
private double kurtosisarray[];

private double a;

private double zeile;
private double[][] mul_matrix;
private double[][] Zwischenergebnis;
private double[] teilarray;

	public ICA(double[] fitted, int seqLenght) throws Exception {
		
		double[][]eingabematrix= PCA2.center2(PCA2.valuesToMatrix(fitted, seqLenght));
		
		
	        int zeilen =  eingabematrix.length;
			int spalten =  eingabematrix[1].length;
			P= zeilen;
			N=spalten;
			 System.out.println("eingabematrix Zeilenanzahl:");
			 System.out.println(P);
			 System.out.println("eingabematrix Spaltenanzahl:");
			 System.out.println(N);
			 
			 System.out.println("eingabematrix:");
			 
			 for (int i=0; i<P; i++){
				 for (int j=0; j<N; j++){
					  
					  eingabematrix[i][j]= ((Math.rint((eingabematrix[i][j])*1000000))/1000000);
					 }
			      }
			 
		double[][] zufallsmatrix = new double[N][P];
		
	        System.out.println("Zufallsmatrix:"); 
	        for (int i = 0; i < N; i++){
	            for (int j = 0; j < P; j++){
	                    zufallsmatrix[i][j] =  (int)(Math.random() * 10);

	                  // System.out.print(zufallsmatrix[i][j] + "\t");    
	        }
	           
	      // System.out.println();
	    }
	
	       System.out.println("Matrix-Ende");

	       
	       
	       //neue_zufallsmatrix= new double [N][N];
	       
	      //neue_zufallsmatrix=  matrixmultiplication(eingabematrix, zufallsmatrix);
	       neue_zufallsmatrix=  matrixmultiplication(zufallsmatrix, eingabematrix);
	      
	      System.out.println("neue Zufallsmatrix:");
	      System.out.println("neue_zufallsmatrix.length:");
	      System.out.println(neue_zufallsmatrix.length);
	      System.out.println("neue_zufallsmatrix[1].length:");
	      System.out.println(neue_zufallsmatrix[1].length);
	      
	      
	      for(int i=0; i<neue_zufallsmatrix.length; i++){
	    	  for(int j=0; j<neue_zufallsmatrix[1].length; j++){
	    		  
	    		  neue_zufallsmatrix[i][j]=((Math.rint(( neue_zufallsmatrix[i][j])*1000000))/1000000);
	    		  
	    		  //System.out.print(neue_zufallsmatrix[i][j] + "\t");
	    		  
	    	  }
	    	  //System.out.println();
	      }
	        
	        PCA2 pca2 = new PCA2(neue_zufallsmatrix, seqLenght);
	        
	        
	    
	       
			b=pca2.get_eigenvektoren();
			System.out.println("b.length:");
			System.out.println(b.length);
			
			System.out.println("b[1].length:");
			System.out.println(b[1].length);
			
			c=pca2.get_eigenwerte();
			//System.out.println("c.length:");
			//System.out.println(c.length);
			//System.out.println("c[i]:");
			//System.out.println(c[1]);
		
			double[][] diagonalmatrix = new double[c.length][c.length];
	        System.out.println("diagonalmatrix:"); 
	        for (int i = 0; i < c.length; i++){
	            for (int j = 0; j < c.length; j++){
	            	
	            	if (i == j){
	            		
	            		diagonalmatrix[i][j]= (1/Math.sqrt(c[i]));
	            		
	            	}	
	            	else
	                    diagonalmatrix[i][j] =  0;
	                  // System.out.print(diagonalmatrix[i][j] + "\t");
	        }
	       // System.out.println();
	    }
	        System.out.println("diagonalmatrix-Ende");

	        System.out.println("eigenvektormatrix:");
	        
	        for (int i = 0; i < b.length; i++){
	            for (int j = 0; j < b[i].length; j++){
	            	
	            		           
	                   //System.out.print(b[i][j] + "\t");
	        }
	        
	        //System.out.println();
	    }
	        System.out.println("eigenvektormatrix-Ende"); 
	        
  System.out.println("transponierte eigenvektormatrix:");
  
 
int i = 0;
double[][] t_b= new double [b[i].length][b.length];

	        
	        for (int m = 0; m < b.length; m++){
	            for (int n = 0; n < b[m].length; n++){
 	
	            	
	      	            	t_b[m][n] = b[n][m];
	      	            }          		      	
	        }
    	            	for (int u=0; u<t_b.length; u++) {
    	            		 for (int v=0; v<t_b[1].length; v++) {
    	            			//System.out.print(t_b[u][v] + "\t");	            			 
    	            		 }
	        //System.out.println();
	    }
	        System.out.println("transponierte eigenvektormatrix-Ende"); 
	        
	        System.out.println("zwischenergebnis:");
	        
            System.out.println("t_b.length:"); 
	        System.out.println(t_b.length);
	        System.out.println("t_b.length[1]:"); 
	        System.out.println(t_b[1].length);
	        
	        System.out.println("neue_zufallsmatrix.length:"); 
	        System.out.println(neue_zufallsmatrix.length);
	        System.out.println("neue_zufallsmatrix[1].length:"); 
	        System.out.println(neue_zufallsmatrix[1].length);
	        
	        
	        
	       // double [][] Zwischenergebnis = new double [t_b.length][neue_zufallsmatrix[1].length];
	        
	        Zwischenergebnis=  matrixmultiplication(t_b, neue_zufallsmatrix);
	      
	   for (int r = 0; r < t_b.length; r++){
	           for (int j = 0; j < neue_zufallsmatrix[1].length; j++){
    		           
          // System.out.print(Zwischenergebnis[r][j] + "\t");
}

 //System.out.println();
 
	   }

	    System.out.println("zwischenergebnis-ende:"); 
	      
	    System.out.println("z:");

	    double [][] Z = new double [Zwischenergebnis[1].length][diagonalmatrix.length];
	    Z=  matrixmultiplication(Zwischenergebnis,diagonalmatrix);
	      
	      //for (int p = 0; p <diagonalmatrix.length; p++){
	          // for (int q = 0; q <Zwischenergebnis[1].length;q++){
	    
	  for (int p = 0; p <Zwischenergebnis.length; p++){
         for (int q = 0; q <diagonalmatrix[1].length;q++){
   		           
         // System.out.print(Z[p][q] + "\t");
}

//System.out.println();
}
	
	      System.out.println("Kurtosis beginnt:"); 
	
	double [] result = new double[N*N];
	      result= convertArrayTo1D(Z);
	
		    double[] teilarray = new double[Z[1].length];
		    double[] kurtosisarray = new double[Z.length];
		    double max_curt_temp[]= new double[kurtosisarray.length];
		    double max_curt[]= new double[kurtosisarray.length];
		    
		    
		for (int q = 0; q < Z.length; q++)
		{
			for (int r = 0; r < kurtosisarray.length; r++)
			{
				for (int s = 0; s < kurtosisarray.length; s++) 
				{
					for (int t = 0; t < Z.length; t++)              
					{
						teilarray = Arrays.copyOfRange(result, t * N, t * N + N); // TEILARRAY  ERZEUGEN
						
						kurtosisarray[t] = kurtosis(teilarray);
					 }

					 max_curt_temp[s] = zeile_mit_max_curt(kurtosisarray);

					// System.out.println("max_curt_temp[0]:");
					// System.out.println(max_curt_temp[0]);
			     }

				double m = max_curt_temp[0];

				max_curt[r] = m;

				    for (int j = 0; j < Z[1].length; j++) {
					Z[(int) m][j] = 0;
				    }
		     }
         }
      

   
   
   
System.out.println("zeile_mit_max_curt array:"); 
System.out.println(max_curt[0]); 

System.out.println("zeile_mit_max_curt null gesetzt:"); 
System.out.println(Z[(int) max_curt[0]][100]); 
System.out.println(Z[2][100]); 

System.out.println("max_curt komplett:");
for (int p=0; p<max_curt.length; p++){
	
	System.out.println(max_curt[p]);
}
```


Und hier ist die Berechnung der Kurtosis:



```
public  double kurtosis(double[] teilarray) {
	int n = N;
	 double erwartungswert = 0;
	    erwartungswert = mean(teilarray);
	    

	    double var = 1;
	   
	    double standardabweichung =0;
	    double abweichung = 0;
		double  p_var =0;
		double p_var2[]= new double [teilarray.length];
	    double curt_relative=0;
	    
	for (int i=0; i < n; ++i) {
		
	abweichung = teilarray[i] - erwartungswert;

	standardabweichung += abweichung;
	
	p_var =abweichung*abweichung ;
	p_var2[i]=standardabweichung*standardabweichung ;
	 var += p_var;
	}
	double erwartungswert2= mean(p_var2);
	double erwartungswert2_quadriert = erwartungswert2 * erwartungswert2;
	//System.out.println("erwartungswert2_quadriert:");
	//System.out.println(erwartungswert2_quadriert);
	
	
	 curt_relative = p_var*p_var-3*(erwartungswert2_quadriert)/(erwartungswert2_quadriert);
	 //curt_relative =( 1-3*(erwartungswert2_quadriert))/(erwartungswert2_quadriert);
	 //curt_relative = curt_relative/n;
	 
	 
	
	
curt_relative = Math.abs( curt_relative);
	//System.out.println("curt_relative:");
	//System.out.println(curt_relative);
	
	return curt_relative;
	
	}
```

Ich hoffe, das war jetzt nicht irgendwie zu viel oder so. Vielen Dank schonmal für Deine Hilfe und LG


----------



## Marco13 (10. Jan 2012)

Zu viel ist es nicht, aber zu unübersichtlich (und testen kann man es ohnehin nicht). Ich meinte auch, dass du versuchen solltest, das, was dort gemacht wird, etwas zu strukturieren. Ein Detail: Macht so eine Methode mit so einem grausligen Namen wie "zeile_mit_max_curt" etwas anderes, als man bei sowas wie
int rowWithMaxCurtosis = computeIndexOfMaximum(curtosisArray);
erwarten würde?

Du hast also diese Kurtosis-Methode, die kriegt einen Array (eine Zeile einer Matrix) und spuckt ein double aus (die braucht man nicht mal zu implementieren, um sie verwenden zu können). Danach hat man also zwei Arrays: Die Matrix, und den Array mit den Kurtosis-Werten. Was soll dann damit gemacht werden? (Möglichst klar beschreiben, was das Ziel ist - nicht, was du implementiert hast - das kann was gaaanz anderes sein  ).


----------



## poulin80 (10. Jan 2012)

Hallo,

vielen Dank für Deine Antwort. Also ich suche aus der Matrix die Zeile mit der max. Kurtosis und verringere dann die Matrix um diese Zeile und suche wieder nach der max. Kurtosis und so weiter. Bis die gesamte Matrix abgearbeitet ist. (hier hatte ich leider keine andere Lösung gefunden, als die Zeile mit der max. Kurtosis mit null zu füllen). Nach jedem Durchlauf speicher ich die Zeilennr. mit der max. Kurtosis in einem Array. Dieses Array brauche ich dann, um eine neue Matrix aufzubauen und zwar nach der Reihenfolge aus dem Array. Letztendlich soll die Zeile mit der max. kurtosis die 1. Spalte in einer neuen Matrix sein. Der 2. Eintrag in dem Array wird die 2. Spalte in der Matrix und so weiter.
Ist diese Matrix erstellt, ist das Programm fertig. Das Array brauche ich also, um diese neue Matrix zu erstellen. 

Ich hoffe, das war halbwegs verständlich...

LG


----------



## Marco13 (10. Jan 2012)

OK... glaube das, jetzt so halbwegs(!) verstanden zu haben... der Teil mit 
_"verringere dann die Matrix um diese Zeile"_
ist aber noch nicht ganz klar: Die Zeile auf 0 zu setzen bewirkt, dass danach die kurtosis für diese Zeile 0 wird, richtig? Falls dem so ist: Wäre das Ergebnis von dem, was du beschrieben hast, etwas anderes, als wenn man die Zeilen der Matrix absteigend nach ihren (am Anfang EINmal berechneten) Kurtosis-Werten sortieren würde?


----------



## poulin80 (10. Jan 2012)

Hallo,


also, das mit dem Nullsetzen war auch nur so eine Notlösung, aber ich denke, das das in etwa dem gleich kommt, als wenn ich die Zeile aus der Matrix lösche. Ich berechne die Kurtosis, schreibe die Zeilennr. mit der max. Kurtosis in das Array und lösche diese Zeile bzw. setze sie auf Null. Dann berechne ich die Kurtosis erneut von der ganzen Matrix (ohne diese Zeile) und suche das neue maximum. Also ich lasse nach jedem Durchlauf das max. neu bestimmen und berechne die Kurtosis wieder von den restlichen Zeilen. Es ist nicht so, dass die Kurtosis nur einmal gestartet wird und die Kurtosen einfach nach dem max. sortiert werden. Die Kurtosis wird immer wieder über die (immer kleiner werdende Matrix) gejagt, bis alle Zeilen "weg sind".


----------



## Marco13 (10. Jan 2012)

Ja, aber warum? Wenn die Kurtosis NUR auf Basis EINER Zeile berechnet wird, kann man doch am Anfang einmal alle Kurtosisss..sissen..si.. ausrechnen, und die Information dann verwenden, um die Matrix passend zu sortieren. Warum sollte man sie mehrmals ausrechnen, wenn sowieso immer das gleiche (für jede Zeile) rauskommt?


----------



## poulin80 (10. Jan 2012)

Ja, irgendwie hast Du da recht. Da muss ich jetz nochmal nachschauen, denn ich bin mir sicher, dass es so funktioniert. Da muss ich wohl die ganze Matrix einbeziehen. Die Kurtosis brauche ich für das Finden der unabhängigen komponenten bei der Unabhängigkeitsanalyse.

Vielen Dank, sonst wäre mir das wohl gar nicht aufgefallen!!!

Falls Du noch ne Idee hast, wo der Fehler liegen könnte, wäre super, wenn Du mir bescheid geben könntest. 

LG


----------



## poulin80 (10. Jan 2012)

Hallo,


also ich denke, man rechnet in der Kurtosismethode mit dem Erwartungswert der gesamten Matrix Z. das  macht Sinn, oder? hierbei muss auch die kurtosis immer wieder neu berechnet werden, da dieser sich ja durch das "weglassen" 1 Zeile bei jedem Durchgang ändert.

Wäre super, wenn du mir noch weiter helfen würdest. Vielen vielen Dank.

lg


----------



## GUI-Programmer (10. Jan 2012)

Bin mir jetzt nicht ganz sicher, ob es was bringt, aber wie wärs ein paar Matrizen zu Listen zu machen. Dann kannst du auch nach Belieben Elemente löschen. (Z.B. mit ArrayList<Double>)


----------



## poulin80 (11. Jan 2012)

So ein Mist. ich hab das völlig falsch verstanden und bin jetzt super unter Zeitdruck... 
ES geht um die Unabhängigkeitsanalyse (ICA) durch Extremwerte der Kurtosis. Die Iterationsvorschrift habe ich angehängt.
beim Fixpunktalgorithmus der ICA  wird die Kurtosis nicht berechnet, sondern die Ableitung davon,
dann hoch drei und davon den Erwartungswert



Es wird also Erwart.wert(Skalar mal Vektor v) minus 3xVektor w gebildet. Und
dann w normiert.
Bei dem zweiten w (zweiten Zeile) muss von v jeweils die Komponenten bezüglich
w1 abgezogen werden wie bei der PCA, bei der dritten Zeile die bezüglich der
zweiten usw

Vielleicht kann mir von Euch DRINGEND jemand helfen??

Vielen Dank und LG


----------



## poulin80 (11. Jan 2012)

OK ich muss dringend einen ICA Fixpunktalgorithmus programmieren, der die unabhängigen Komponenten findet. Ich weiß gar nicht wie ich anfangen soll.??

Hat jemand eine Idee???


----------



## Marco13 (11. Jan 2012)

Wie "DRINGEND"? Das jetzt nebenbei ("in der Mittagspause") nachzuvollziehen und den Fehler zu finden (bzw. die Lösung, da (mir) nicht klar ist, inwieweit das bisherige überhaupt einen Lösungs_ansatz_ darstellt)) könnte schwierig werden. Was sind denn v und w bzw. w0 ? Was ist die Matrix, wo kommt die her, was ist die Aufgabe?


----------



## poulin80 (11. Jan 2012)

Möchte Dich jetzt auch nicht nerven in Deiner Mittagspause....

Aufgabe ist der Fixpunktalgorithmus in der ICA, um unabhängige Komponenten zu finden. Meine Matrix, die auch richtig ist, hat als Zeilen die Eingabevektoren v. w0 wird anscheinend gewählt und von da aus iteriert.Tatsächlich soll die Kurtosis maximiert werden, das geschieht aber über deren Ableitung.

Ich hab mal versucht eine Datei anzuhängen, da ist es etwas erklärt.
Ich brauche es ganz dringend am besten heute,da ich es noch dokumentieren muss.

Vielen vielenDank


----------



## poulin80 (11. Jan 2012)

Hallo,

ich habe hier noch eine beschreibung des Fixpunkt Algorithmus  für die ICA. Ab punkt 8 muss ich also ansetzen.

Vielen Dank für Deine Hilfe. Das ist mir nämlich wirklich super wichtig....

LG


----------



## Marco13 (11. Jan 2012)

Wenn es mich nervt, antworte ich einfach nicht mehr :bahnhof: 

Vermutlich wäre "gestern" noch besser als "heute"... aber... seit wann hast du die Aufgabe? Zumindest sehe ich jetzt nicht, wo da noch eine "Kurtosis" drin vorkommt, aber... das musst du wissen. 

Wie auch immer. Das "in der Mittagspause" sollte allgemein bedeuten: "In einem kurzen Zeitraum, ohne sich vorher mit dem Problem vertraut zu machen, und ohne mögliche Implementierungen durchzudenken, auszuführen und zu überprüfen". 

Der Algorithmus, der dort jetzt beschrieben ist, sieht auf dem Aufgabenblatt recht überhschaubar aus, zumindest FALLS es nur um den Teil ab Schritt 5 geht. Wenn man das pragmatisch und ohne viel nachdenken runterschreibt (ohne irgendeine Garantie) könnte es etwa so aussehen

```
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;


public class KurtosisTest
{
    private static final Random random = new Random(0);
    
    public static void main(String[] args)
    {
        int n = 10;
        int m = 3;
        int size = 4;
        
        double X[][] = new double[m][size];
        double wi[] = new double[size];
        double a[];
        double b[];
        List<double[]> W = new ArrayList<double[]>();
        W.add(new double[size]);
        
        for (int i=0; i<n; i++)
        {
            wi = W.get(i);
            
            // 6
            initRandom(wi);
            System.out.println("Iteration "+i+" wi="+Arrays.toString(wi));
            
            // 7
            wi = multiply(wi, 1/twoNorm(wi));

            boolean converged = false;
            while (!converged)
            {
                // 8
                double sum[] = new double[size];
                for (int j=0; j<m; j++)
                {
                    double xj[] = X[j];
                    double wx = dot(wi, xj);
                    a = multiply(xj, wx*wx*wx);
                    sum = add(sum, a);
                }
                a = multiply(sum, 1.0/m);
                b = multiply(wi, -3);
                wi = add(a, b);
                
                // 9
                sum = new double[size];
                for (int j=0; j<i-1; i++)
                {
                    double wj[] = W.get(j);
                    double dot = dot(wj, wi);
                    a = multiply(wj, dot);
                    sum = add(sum, a);
                }
                wi = add(wi, multiply(sum,  -1));
                
                // 10
                wi = multiply(wi, 1/twoNorm(wi));
                W.set(i, wi);
                
                System.out.println("Iteration "+i+" check for convergence of wi="+Arrays.toString(wi));
                converged = false; // TODO: Check convergence
            }
        }
        
    }
    
    
    private static void initRandom(double a[])
    {
        for (int i=0; i<a.length; i++)
        {
            a[i] = random.nextDouble();
        }
    }
    
    private static double twoNorm(double a[])
    {
        return Math.sqrt(dot(a,a));
    }
    
    private static double dot(double a[], double b[])
    {
        double dot = 0;
        for (int i=0; i<a.length; i++)
        {
            dot += a[i] * b[i];
        }
        return dot;
    }
    
    private static double[] multiply(double a[], double factor)
    {
        double result[] = a.clone();
        for (int i=0; i<result.length; i++)
        {
            result[i] *= factor;
        }
        return result;
    }

    private static double[] add(double a[], double addend[])
    {
        double result[] = a.clone();
        for (int i=0; i<result.length; i++)
        {
            result[i] += addend[i];
        }
        return result;
    }
    
}
```
aber... jetzt geh' ich erstmal essen


----------



## poulin80 (11. Jan 2012)

Hallo,

also das war echt nett von Dir. Wie kann noch die Konvergenz checken? Irgendwie zaehlt die Iteration bei mir nicht weiter? Da steht immer Iteration 0??

LG


----------



## Marco13 (11. Jan 2012)

Er hängt in der inneren Schleife, die nie Endet, weil keine Konvergenz festgestellt wird. Das müßte man mal testen, indem man X mit "echten" Daten füllt (idealerweise ein überschaubarer Test-Datensatz mit size < 10 und m < 10 oder so...). "Konvergenz" würde für mich spontan jetzt bedeuten, dass zwei aufeinanderfolgende "wi"s sich nur noch sehr wenig unterscheiden. Als test kann man auch mal die while-Schleife durch eine for (int c=0; c<100; c++) schleife ersetzen, und davon ausgehen, dass WENN es konvergiert, es nach 100 Durchläufen zumindest "weit genug" konvergiert ist, um zu sehen, ob es stimmt (nochmal: Die Formeln hatte ich nur schnell in der Pause "abgetippt", da können noch Fehler drin sein!)


----------



## poulin80 (11. Jan 2012)

Hallo,

ich würde dich gerne nochmal bemühen...

Also zwischen den Schritten 10 und 11 fehlt noch ein Schritt ist mir gerade aufgefallen. Der fehlt auf dem Blatt, was ich angehängt habe. Nach Schritt 10 muss die Raumrichtung wi aus den Daten entfernt werden. dann kommt schritt 11.

Wg. der KOnvergenz steht noch ein Hinweis auf dem Blatt mit dem Algo. Aber ich verstehe nicht, wie ich das abprüfen soll?

Hast Du vielleicht noch eine Idee?

Vielen Dank und LG


----------



## Marco13 (11. Jan 2012)

Wie dieses "Entfernen" dann ablaufen soll, ist mir nicht klar :bahnhof:

Das Konvergieren wäre dann wohl sowas wie
double delta = 1 - dot(wi, wi);
converged = (delta < 1e-4); 
falls ich das richtig verstanden habe.


----------



## poulin80 (11. Jan 2012)

vielen Dank für die Antwort. Aber wenn ich dot(wi,wi) berechne, dann habe ich zwar das aktuelle wi, aber das zweite soll das wi aus der vorigen Iteration sein. Also dot(wi, wi') oder so.... Stimmt das?


----------



## Marco13 (11. Jan 2012)

Wenn du nicht auf die Idee gekommen bist, sowas wie

```
if (i>1)
{
    double wp[] = W.get(i-1);
    double delta = 1 - dot(wi, wp);
    converged = (delta < 1e-4); 
}
```
daraus zu machen, kann sich das hier wohl noch eine Weile hinziehen.


----------



## poulin80 (12. Jan 2012)

Ja, das ist wohl so.

Ich habe das jetzt mal in mein programm integriert und an einer Stelle versteht ich die Fehlermeldung nicht bzg. des Datentyps:


```
// Berechnung des Fixpunktes
				for (int j = 0; j < Z[0].length; j++) {

					double bf1= dot(w_neu,Z[j]);
					bf1= bf1*bf1*bf1;
					double skew [][] = new double[Z.length][Z[0].length];
					for (int s = 0; s < Z.length; s++) {
					   for (int t = 0; t < Z[0].length; t++) {
					     skew[s][t]=  Z[t]*bf1;
					    }
					}
					w_neu =sub((mean_vec(skew)),multiply(w_neu,3));
					
					
					
					
					// Normierung
					 norm2 = dot(w_neu,w_neu); //w_neu quadriert
					for (int l = 0; l < w_neu.length; l++)
						w_neu[l] /= norm2;
					
					
				} //end for j
```

Also Zeile 9 zeigt immer eine Fehlermeldung, egal ob ich es so multipliziere, oder über die Methode multiply. ??
Vielleicht kannst Du nochmal kurz schauen, ob du den Fehler siehst? Ich kann keinen erkennen.


----------



## Marco13 (12. Jan 2012)

skew[t] ist ein double, 
Z[t] ist ein double-ARRAY (d.h. ein Vektor)
bf1 ist ein double.

Mit 
... = multiply(Z[t], bf1)
könnte man schon einen vektor mit einem double multiplizieren und einen vektor erhalten.... sowas wie

```
for (int s = 0; s < Z.length; s++) {
    skew[s] =  multiply(Z[t], bf1);
}
```
könnte funktionieren - ob es "richtig" ist, weiß ich nicht...


----------



## poulin80 (13. Jan 2012)

Hallo,

ich bekomme an folgendeer Stelle eine NullPointer Exception, weiß aber nicht warum:

Hier bekomme ich die Fehlermeldung:


```
for(int p = 0; p <= seqLenght; p++){
w_vektoren[p] = convergeICA2(Z,p);
				
} //end for
```
 

Und hier ist die Methode dafür:


```
private double[] convergeICA2(double[][] Z,int p) {
		
		// Erstellung des Gewichtsvektors, random und normiert
		double[] w=new double[Z.length];

		for (int k = 0; k < w.length; k++)
			w[k] =( Math.rint((Math.random() * 1)*1000000)/1000000);
		
		double norm2 = dot(w,w); //w_neu quadriert
		for (int i = 0; i < w.length; i++)
			w[i] /= norm2;

		// Multiplikation zur Berechnung des neuen Gewichtsvektors
		double [] summe = new double[w.length];

		// pro Quelle (Zeile)
		for (int i = 0; i < w.length; i++) {
			int loop = 2;
			while (loop > 0) {
				// Berechnung des Fixpunktes
				for (int j = 0; j < Z[0].length; j++) {
					double bf1= dot(w,Z[j]);
					bf1= bf1*bf1*bf1;
					double skew [][] = new double[Z.length][Z[0].length];
					for (int s = 0; s < Z.length; s++) {
					   for (int t = 0; t < Z[0].length; t++) {
					      skew[s]=  multiply(Z[t],bf1);
					    }// end for t
					}// end for s
					w =sub((mean_vec(skew)),multiply(w,3));
					for(int k=0; k<=p-1; k++){
				         summe=add(summe,(multiply(w_vektoren[k],(dot(w_vektoren[k],w)))));
					}
					w=sub(w,summe);
					
					// Normierung
					 norm2 = dot(w,w); //w_neu quadriert
					for (int l = 0; l < w.length; l++)
						w[l] /= norm2;
					
					
				} //end for j
 
				loop -= 1;
				
				System.out.println("LOOP ENDE");
			}//end while
			
		} //end for i
		return w;
```

Der Loop wird ein paar mal durchlaufen und dann kommt die Fehlermeldung....

LG


----------



## Marco13 (13. Jan 2012)

Kann eigentlich nicht sein. Stacktrace posten, BESSER noch Compilier- und Ausführbaren Code


----------



## poulin80 (13. Jan 2012)

Hallo,

ich versuche mal, dir die dateien anzuhängen...

Das sind die, die man braucht. es gibt noch mehr, hat aber damit jetzt nichts zu tun.

Vielen Dank!

LG


----------



## JohannisderKaeufer (13. Jan 2012)

> Das sind die, die man braucht. es gibt noch mehr, hat aber damit jetzt nichts zu tun.



ist hoffentlich nicht deine Antwort auf



> Kann eigentlich nicht sein. Stacktrace posten, BESSER noch Compilier- und Ausführbaren Code



Die Datei PCA2 ist noch ok.

Aber bei ICA sehen die imports so aus


```
import data.Data;

import histogram.Histogram;



import java.text.DecimalFormat;

import java.util.*;



import java.io.BufferedReader;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.PrintWriter;

import java.lang.Object.*;



import org.jfree.util.ArrayUtilities;




import normaldistribution.NormalDistribution;

import pca.PCA;

import statistic.Statistic;

import pca2.PCA2;

import diagram.Diagram;

import Jama.LUDecomposition; 

import Jama.Matrix;
```


----------



## poulin80 (14. Jan 2012)

hallo,

hoffe, dass es jetzt richtig ist??


----------



## poulin80 (14. Jan 2012)

hallo,

hier die anderen Dateien, sorry, aber ich bin so unter druck, ich bin völlig am ende mit meinen nerven....

vielen dank nochmals!


----------



## Marco13 (14. Jan 2012)

OK. 40 KB nicht-ausführbarer, weitgehend unkommentierter, grauslig benannter, unübersichtlicher und sich auf externe Bibliotheken beziehender Quellcode. Schön.

Was erwartest du jetzt? Sollen wir eventuelle Fehler darin finden, durch drüberschauen? Sagen, ob das Ergebnis "richtig" ist, ohne es testen zu können? :noe: 

Wenn eine NullPointerException kommt, heißt das, dass in der Zeile etwas 'null' ist, worauf zugegriffen wurde. Vermutlich würden noch mehr Leute hier versuchen zu helfen, aber es gibt keine verünftige _Möglichkeit_, das zu tun... :bahnhof:


----------



## poulin80 (14. Jan 2012)

Hallo,

kann ich absolut nachvollziehen. möchte mich aber bemühen, es auch hier in dem Forum richtig zu machen. D.h. was brauchst du? den ganzen Projektordner? Es geht vor allem um Ideen dazu, wie ich meine Fehler beheben kann. Momentan konvergiert es super lahm. Null Pointer Exception habe ich z.Zt. nicht mehr.

LG


----------



## Marco13 (14. Jan 2012)

Vielleicht konvergiert es eben langsam?  :bahnhof: (Nochmal: Ich weiß nicht, was die Kurtosis ist, und habe mich mit PCA & Co bisher noch nicht wirklich beschäftig). Natürlich wäre das Gesamtprojekt (mit externen JARs usw) zum testen praktisch, aber selbst dann muss man nicht davon ausgehen, dass jemand bereit ist, dir die Debugging-Arbeit abzunehmen. Was sind denn nun die Fehler, von denen du redest?


----------

