Hauptkomponentenanalyse und Singulärwertzerlegung gehören zu den beiden gängigen Konzepten der linearen Algebra im maschinellen Lernen. Ist es nach dem Sammeln von Rohdaten möglich, die Struktur zu entdecken? Wenn wir zum Beispiel die Zinssätze der letzten Woche betrachten, gibt es dann eine Möglichkeit, Trends im Markt herauszufinden?
Diese Fragen werden immer komplizierter, wenn wir große Datenmengen haben. Die Antwort auf diese Fragen zu finden, gleicht der Suche nach einer Nadel im Heuhaufen. Daher verwenden wir die Singular Value Decomposition, um die komplizierten Informationen zu entwirren und zu extrahieren. Dieser Artikel wird Ihnen helfen, das Konzept der Singulärwertzerlegung im Detail zu verstehen.

Singulärwert-Zerlegung

Diese multivariate statistische Technik hilft bei der Lösung komplexer Probleme in den atmosphärischen Wissenschaften. Die empirische orthogonale Funktionsanalyse und die Hauptkomponentenanalyse sind ähnliche Verfahren für dieselbe Technik, die 1956 von Edward Lorenz eingeführt wurde.
Die Singulärwertzerlegung hilft bei der Reduzierung von Datensätzen, die eine große Anzahl von Werten enthalten. Darüber hinaus ist diese Methode auch hilfreich, um signifikante Lösungen für weniger Werte zu generieren. Diese wenigen Werte umfassen jedoch auch eine immense Variabilität, die in den ursprünglichen Daten vorhanden ist.
In den geophysikalischen und atmosphärischen Wissenschaften zeigen die Daten große räumliche Korrelationen. Eine Singular Value Decomposition Analyse unterstützt und liefert Ergebnisse für eine kompaktere Darstellung dieser Korrelationen. Durch die Verwendung multivariater Datensätze lassen sich Erkenntnisse über zeitliche und räumliche Variationen gewinnen. Diese Variationen weisen die Daten nach der Analyse auf.
Auch wenn es weniger Einschränkungen bei dieser Technik gibt, sollten Sie diese verstehen, bevor Sie die Singulärwertzerlegung der Datensätze berechnen. Erstens sollte es Anomalien in den Daten geben, die die erste Struktur erfassen wird. Wenn Sie die Daten analysieren, um räumliche Korrelationen unabhängig von Trends zu finden, sollten Sie die Daten enttrenden, bevor Sie sie für die Analyse verwenden.

Singuläre Vektoren & Singulärwerte

Die Matrix AAᵀ und AᵀA in der linearen Algebra sind sehr speziell. Durch Multiplikation der Aᵀ mit der Matrix nach der Betrachtung der them × n-Matrix A können wir AAᵀ und AᵀA einzeln bilden. Zu den Matrizen gehören:
– Quadratisch
– Symmetrisch
– Gleiche Matrizen mit beiden positiven Eigenwerten
– Positiv semidefinit, und
– Gleiche r wie A mit beiden Rängen
Eine wichtige Eigenschaft symmetrischer Matrizen ist, dass sie symmetrisch sind, und wir wählen Eigenvektoren, die orthonormal sind. Wir verwenden diese Kovarianzmatrizen häufig beim maschinellen Lernen.

Beispiel für die Singulärwert-Zerlegung

Um das Konzept zu verstehen, nehmen wir an, die Matrix m × n, A, sammelt den Trainingsdatensatz. Diese Datensätze nehmen die Zeile für jeden Trainingsvektor ein. Hier zeigt N an, dass die Dimension jedes Vektors sehr groß sein wird.

Wenn Sie A in einen Clustering-Algorithmus einspeisen, erhalten Sie eine feste Anzahl von Clusterzentren als Ausgabe. Da ‘n’ sehr groß ist, wird der Algorithmus instabil oder braucht zu lange. Daher werden wir die Singulärwertzerlegung verwenden, um die Anzahl der Variablen zu reduzieren. Wir werden eine transparente Methode zur Berechnung verwenden, da wir das Problem immer noch mit untransformierten Koordinaten lösen.

Schritt 1: Einlesen der Daten

Wir können mit dem Einlesen der Daten beginnen, indem wir A ausfüllen. Beginnen wir also mit dem Tutorial in der Sprache C:
//subroutine header for performing cluster analysis:
#include “cluster.h”//maximale Anzahl von Clustern:
#define MAX_CLUSTER 10int main(intargc, char **argv) {
char *infile; //Eingabedatei
char *outfile; //Ausgabedatei
FILE *fs; //Dateizeiger
double **a; //Matrix der Trainingsdaten/U
int m; //Anzahl der Zeilen in der Matrix
int n; //Anzahl der Spalten in der Matrix
intnsv; //Anzahl der Singulärwerte if (argc!=4) {
printf(“syntax: cluster_svdnsv train centers\n”);
printf(” where:\n”);
printf(“nsv = Anzahl der singulären Werte (0 = untransformierte Daten verwenden)\n”);
printf(“infile = ASCII-Eingabedatei mit Trainingsdaten\n”);
printf(“output = ASCII-Ausgabedatei, die Clusterzentren\n”);
printf(“\n”);
printf(“Dateiformat:\n”);
printf(“- einzeiliger Header mit Anzahl der Zeilen und Anzahl der Spalten\n”);
printf(“- zeilenweise Hauptliste der einzelnen Matrixelemente\n”);
exit(1);
} if (sscanf(argv[1], “%d”, &nsv)!=1) {
fprintf(stderr, “Fehler beim Parsen des ersten Befehlszeilenarguments\n”);
exit(1);
}
infile=argv[2];
outfile=argv[3]; fs=fopen(infile, “r”);
if (fs==NULL) {
fprintf(stderr, “Fehler beim Öffnen der Eingabedatei, %s\n”, infile);
exit(1);
} if (fscanf(fs, “%d %d”, &m, &n)!=2) {
fprintf(stderr, “Formatfehler in Eingabedatei: %s Zeile 0”, infile);
exit(1);
}
if (nsv>n) {
fprintf(stderr, “Befehlszeilenparameter nsv=%d außerhalb des Bereichs\n”, nsv);
exit(1);
} a=new double *[m];
a[0]=new double[m*n];
for (inti=1; i<m; i++) a[i]=a[0]+i*n;
for (inti=0; i<m; i++) {
for (int j=0; j<n; j++) {
if (fscanf(fs, “%lg”, a[i]+j)!=1) {
fprintf(stderr, “Formatfehler in Eingabedatei, %s, Zeile %d\n”, infile, i);
exit(1);
}
}
} fclose(fs);

Schritt 2: Durchführen der SVD

Nun werden wir die künstliche Singulärwertzerlegung verwenden, die in der Header-Datei svd.h enthalten ist:
#ifndef SVD_H
#define SVD_H//Subroutine für die Singulärwertzerlegung:
int //liefert einen Fehlercode zurück (0 für Erfolg)
svd (double **a, //Eingangsmatrix – wird bei Ausgabe durch U ersetzt
int m, //Anzahl der Zeilen
int n, //Anzahl der Spalten
double *s, //singuläre Werte
double **vt); //V–rechte Singulärvektoren#endif
Die Routinen zur Singulärwertzerlegung sind komplex in Bezug auf den Typ der verwendeten Matrix und des Vektors. Sie können jedoch die komplette Kodierung durch eine Wrapper-Funktion leicht zusammenfassen. Die Routine wird ebenso einfach, wenn Sie auf eine Singulärwertzerlegungsroutine zurückgreifen. Wir werden die folgenden Codes nach dem vorherigen Abschnitt einfügen:
double *ave;
double *s; //Singulärwerte
double **vt; //rechte Singulärvektoren //zuerst berechnen und entfernen wir das arithmetische Mittel:
ave=new double[n];
for (inti=0; i<n; i++) ave[i]=0;
for (inti=0; i<m; i++) {
for (int j=0; j<n; j++) {
ave[j]+=a[i][j];
}
}
for (inti=0; i<n; i++) ave[i]/=m;
for (inti=0; i<m; i++) {
for (int j=0; j<n; j++) {
a[i][j]-=ave[j];
}
} if (nsv>0) {
//Platz für singuläre Werte schaffen:
s=new double[n]; //Platz für rechte Singulärvektoren schaffen:
vt=new double *[n];
vt[0]=new double[n*n];
for (inti=1; i<n; i++) vt[i]=vt[0]+i*n; //Durchführen der Zerlegung:
int err=svd(a, m, n, s, vt);
if (err!=0) {
fprintf(stderr, “Fehler im Unterprogramm svd\n”);
exit(err);
}
}

Schritt 3: Ausführen der Clusteranalyse

Der Prozess des Clustering-Algorithmus erzeugt eine Menge von c Clusterzentren mit {ᵢ ; i ∈ [1, c]}:
#ifndef CLUSTER_H
#define CLUSTER_Hint //liefert Anzahl der Clusterzentren
cluster (double ** x, //Trainingsvektoren
int m, //Anzahl der Trainingsvektoren
int n, //Dimension der einzelnen Vektoren
intmax_nc, //maximale Anzahl der Clusterzentren
double **mu); //zurückgegebene Clusterzentren#endif
Wir fahren mit dem obigen Abschnitt fort und erzeugen die Clusterzentren:
double **mu_p; //Matrix der Clusterzentren
intnc; //Anzahl der Clusterzentren //Platz für Clusterzentren schaffen:
mu_p=new double *[MAX_CLUSTER];
mu_p[0]=new double[MAX_CLUSTER*n];
for (inti=1; i<MAX_CLUSTER; i++) mu_p[i]=mu_p[0]+i*n; if (nsv>0) {
//Platz für Clusterzentren schaffen:
nc=cluster(a, m, nsv, MAX_CLUSTER, mu_p);
} sonst {
//Platz für Clusterzentren schaffen:
nc=cluster(a, m, n, MAX_CLUSTER, mu_p);
} if (nc<= 0) {
fprintf(stderr, “Cluster-Algorithmus fehlgeschlagen”);
exit(-1);
}
Da wir die transformierten Trainingsdaten für den Clustering-Algorithmus verwenden werden, wird das transformierte System die Clusterzentren enthalten.

Schritt 4: Abspeichern der Ergebnisse

Nun können Sie die Clusterzentren mit Hilfe der folgenden Gleichung im untransformierten Koordinatensystem speichern.

P steht in dieser Gleichung für die Anzahl der Koordinaten.
double **mu; //Clusterzentren in untransformierten Koordinaten //Platz für die untransformierten Clusterzentren zuweisen:
mu=new double *[nc];
mu[0]=new double[nc*n];
for (inti=1; i<nc; i++) mu[i]=mu[0]+i*n; //Durchführen der Koordinatentransformation:
for (inti=0; i<nc; i++) {
for (int j=0; j<n; j++) {
mu[i][j]=ave[j];
if (nsv>0) {
for (int k=0; k<nsv; k++) mu[i][j]+=vt[k][j]*s[k]*mu_p[i][k];
} sonst {
mu[i][j]+=mu_p[i][j];
}
}
} //Schreiben Sie die Ergebnisse in eine Datei:
fs=fopen(outfile, “w”);
if (fs==NULL) {
fprintf(stderr, “Fehler beim Öffnen der Ausgabedatei, %s\n”, outfile);
exit(1);
} fprintf(fs, “%d %d\n”, nc, n);
for (inti=0; i<nc; i++) {
for (int j=0; j<n; j++) fprintf(fs, “%16.8lg”, mu[i][j]);
fprintf(fs, “\n”);
} fclose(fs); //Aufräumen:
delete [] mu[0];
delete [] mu; delete [] mu_p[0];
delete [] mu_p; delete [] ave;
delete [] a[0];
delete [] a;
if (nsv>0) {
delete [] s;
delete [] vt[0];
delete [] vt;
} return 0;
}

Fazit

In diesem Artikel haben wir die Definition der Singulärwertzerlegung erklärt und Ihnen geholfen, den Aufbau des Modells in C-Sprache zu verstehen. Sie können diese Methode für die Wiederherstellung von atmosphärischen Variablen nach Satellitenmessungen verwenden. Sie können diese Technik auch für die Interpolation von spärlichen Messungen oder für einen maschinellen Lernalgorithmus verwenden. Diese Technik hilft bei der Regression und Klassifizierung des Datensatzes.