Principale componentenanalyse en singuliere waardedecompositie behoren tot de twee gangbare concepten van lineaire algebra in machinaal leren. Is het mogelijk om na het verzamelen van ruwe gegevens de structuur te ontdekken? Als we bijvoorbeeld kijken naar de rentetarieven van de afgelopen week, is er dan een manier om trends in de markt te achterhalen?
Deze vragen worden ingewikkelder wanneer we over grote hoeveelheden gegevens beschikken. Het vinden van het antwoord op deze vragen is vergelijkbaar met het zoeken naar een naald in een hooiberg. Daarom gebruiken we de singuliere waarde decompositie om de ingewikkelde informatie te ontwarren en te extraheren. Dit artikel zal u helpen het concept van singuliere waardedecompositie in detail te begrijpen.

Enkelvoudige Waarde Decompositie

Deze multivariate statistische techniek helpt bij het oplossen van complexe problemen in de atmosfeerwetenschappen. Empirische orthogonale functieanalyse en principale componentenanalyse zijn gelijksoortige reeksen procedures voor dezelfde techniek die in 1956 door Edward Lorenz werd geïntroduceerd.
De singuliere waarde-ontleding helpt bij het verkleinen van datasets die een groot aantal waarden bevatten. Bovendien is deze methode ook nuttig om significante oplossingen te genereren voor minder waarden. Deze geringere waarden omvatten echter ook de immense variabiliteit die in de oorspronkelijke gegevens aanwezig is.
De gegevens onthullen grote ruimtelijke correlaties in de geofysische en atmosferische wetenschappen. Een Singular Value Decomposition-analyse ondersteunt en levert resultaten op voor een compactere weergave van deze correlaties. Door gebruik te maken van multivariate datasets kunt u inzicht verkrijgen in temporele en ruimtelijke variaties. Deze variaties vertonen gegevens na de analyse.
Ook al zijn er minder beperkingen aan de techniek, toch moet u deze begrijpen alvorens de Singular Value Decomposition van de datasets te berekenen. Ten eerste moeten er anomalieën in de gegevens zitten die de eerste structuur zal vastleggen. Als u de gegevens analyseert om ruimtelijke correlaties te vinden die onafhankelijk zijn van trends, moet u de gegevens ont-trendelen alvorens ze in de analyse te gebruiken.

Singuliere vectoren & singuliere waarden

De matrix AAᵀ en AᵀA in lineaire algebra zijn zeer speciaal. Door de Aᵀ te vermenigvuldigen met de matrix na ze × n matrix A te beschouwen, kunnen we AAᵀ en AᵀA afzonderlijk vormen. De matrices zijn onder meer:
– Vierkant
– Symmetrisch
– Dezelfde matrices met beide positieve eigenwaarden
– Positief semidefiniet, en
– Dezelfde r als A met beide rangen
Een belangrijke eigenschap van symmetrische matrices is dat ze symmetrisch zijn, en we kiezen eigenvectoren die orthonormaal zijn. We gebruiken deze covariantiematrices veel bij machinaal leren.

Voorbeeld van Singular Value Decomposition

Om het concept te begrijpen, veronderstellen we dat de matrix m × n, A, de trainingsgegevensverzameling verzamelt. Deze gegevensverzamelingen nemen de rij voor elke opleidingsvector. Hier geeft N aan dat de dimensie van elke vector zeer groot zal zijn.

Door de A in een clusteralgoritme te voeren, genereer je een vast aantal clustercentra als output. Aangezien ‘n’ vrij groot is, zal het algoritme onstabiel zijn of te lang duren. Daarom maken we gebruik van singuliere waarde-afbraak om het aantal variabelen te verminderen. We zullen een transparante methode gebruiken voor de berekening, aangezien we het probleem nog steeds oplossen met niet-getransformeerde coördinaten.

Stap 1: Inlezen van de gegevens

We kunnen beginnen met het inlezen van de gegevens door A in te vullen. Laten we dus beginnen met de tutorial in C taal:
//subroutine header voor het uitvoeren van clusteranalyse:
#include “cluster.h”//maximum aantal clusters:
#define MAX_CLUSTER 10int main(intargc, char **argv) {
char *infile; //invoerbestand
char *outfile; //uitvoerbestand
FILE *fs; //bestandspointer
dubbel **a; //matrix van trainingsgegevens/U
int m; //aantal rijen in matrix
int n; //aantal kolommen in matrix
intnsv; //aantal singuliere waarden if (argc!=4) {
printf(“syntax: cluster_svdnsv train centers\n”);
printf(” waar:\n”);
printf(“nsv = aantal singuliere waarden (0 = gebruik niet-getransformeerde gegevens)\n”);
printf(“infile = ASCII-invoerbestand met trainingsgegevens”);
printf(“output = ASCII-uitvoerbestand met clustercentra”);
printf(“\n”);
printf(“bestandsformaat:\n”);
printf(“- één regel koptekst met aantal rijen en aantal kolommen;)
printf(“- rij-majoor-lijst van elk matrixelement;)
exit(1);
} if (sscanf(argv[1], “%d”, &nsv)!=1) {
fprintf(stderr, “Fout bij het parseren van het eerste commandoregelargument”);
exit(1);
}
infile=argv[2];
outfile=argv[3]; fs=fopen(infile, “r”);
als (fs==NULL) {
fprintf(stderr, “Fout bij openen invoerbestand, %s”, infile);
exit(1);
} if (fscanf(fs, “%d %d”, &m, &n)!=2) {
fprintf(stderr, “Formatteringsfout in invoerbestand: %s regel 0”, infile);
exit(1);
}
if (nsv>n) {
fprintf(stderr, “Opdrachtregelparameter nsv=%d buiten bereik”, nsv);
exit(1);
} a=nieuwe dubbel *[m];
a[0]=nieuwe dubbel[m*n];
for (inti=1; i<m; i++) a[i]=a[0]+i*n;
for (inti=0; i<m; i++) {
voor (int j=0; j<n; j++) {
als (fscanf(fs, “%lg”, a[i]+j)!=1) {
fprintf(stderr, “Formatteringsfout in invoerbestand, %s, regel %dXXn”, infile, i);
exit(1);
}
}
} fclose(fs);

Stap 2: Uitvoeren van SVD

Nu zullen we de kunstmatige singular value decomposition routine gebruiken die het header bestand, svd.h bevat:
#ifndef SVD_H
#define SVD_H//subroutine voor singuliere waarde ontleding:
int //returns een foutcode (0 voor succes)
svd (dubbel **a, //input matrix–vervangen door U bij output
int m, //aantal rijen
int n, //aantal kolommen
dubbel *s, /singuliere waarden
dubbel **vt); //V-rechtse singuliere vectoren#endif
Singular value decomposition routines zijn complex wat betreft het type matrix en vector dat gebruikt wordt. Je kunt de volledige codering echter gemakkelijk samenvatten via wrapper-functies. De routine zal even eenvoudig zijn wanneer je vertrouwt op een singuliere waarde ontleding routine. We zullen de volgende codes toevoegen na de vorige sectie:
dubbel *ave;
double *s; /singuliere waarden
double **vt; //rechtse singuliere vectoren //eerst berekenen en verwijderen we de rekenkundige gemiddelden:
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) {
/maak ruimte voor singuliere waarden:
s=new double[n]; //make ruimte voor rechter singuliere vectoren:
vt=nieuwe dubbel *[n];
vt[0]=nieuwe dubbel[n*n];
for (inti=1; i<n; i++) vt[i]=vt[0]+i*n; //uitvoer de decompositie uit:
int err=svd(a, m, n, s, vt);
als (err!=0) {
fprintf(stderr, “Fout in svd-subroutine”);
exit(err);
}
}

Stap 3: Uitvoeren van de clusteranalyse

Het clusteralgoritme-proces zal een set van c cluster centra genereren met {ᵢ ; i ∈ [1, c]}:
#ifndef CLUSTER_H
#define CLUSTER_Hint //returns aantal clustercentra
cluster (dubbel ** x, //trainingsvectoren
int m, //aantal trainingsvectoren
int n, //afmeting van elke vector
intmax_nc, //maximum aantal clustermiddelen
dubbel **mu); //teruggegeven cluster centra#endif
We gaan verder met de bovenstaande sectie en genereren de cluster centra:
double **mu_p; //matrix van clustercentra
intnc; //aantal clustercentra //maken ruimte voor clustercentra:
mu_p=nieuwe dubbel *[MAX_CLUSTER];
mu_p[0]=nieuwe dubbel[MAX_CLUSTER*n];
for (inti=1; i<MAX_CLUSTER; i++) mu_p[i]=mu_p[0]+i*n; if (nsv>0) {
/maak ruimte voor cluster centra:
nc=cluster(a, m, nsv, MAX_CLUSTER, mu_p);
} anders {
/ maak ruimte voor cluster centra:
nc=cluster(a, m, n, MAX_CLUSTER, mu_p);
} if (nc<= 0) {
fprintf(stderr, “Cluster algoritme mislukt”);
exit(-1);
}
Aangezien we de getransformeerde trainingsdata zullen gebruiken voor het clustering algoritme, zal het getransformeerde systeem de cluster centra bevatten.

Stap 4: De resultaten opslaan

Nu kun je de cluster centra opslaan met behulp van de volgende vergelijking in het ongetransformeerde coördinaten systeem.

P in deze vergelijking betekent het aantal coördinaten.
double **mu; //clustercentra in niet-getransformeerde coördinaten //ruimte toewijzen voor de niet-getransformeerde clustercentra:
mu=new double *[nc];
mu[0]=nieuwe dubbel[nc*n];
for (inti=1; i<nc; i++) mu[i]=mu[0]+i*n; //uitvoeren van de coördinatentransformatie:
for (inti=0; i<nc; i++) {
voor (int j=0; j<n; j++) {
mu[i][j]=ave[j];
als (nsv>0) {
for (int k=0; k<nsv; k++) mu[i][j]+=vt[k][j]*s[k]*mu_p[i][k];
} anders {
mu[i][j]+=mu_p[i][j];
}
}
} /schrijf de resultaten naar een bestand:
fs=fopen(outfile, “w”);
als (fs==NULL) {
fprintf(stderr, “Fout bij het openen van uitvoerbestand, %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, “j”);
} fclose(fs); //opruimen:
verwijder [] mu[0];
verwijder [] mu; verwijder [] mu_p[0];
verwijder [] mu_p; verwijder [] ave;
verwijder [] a[0];
verwijder [] ave;
indien (nsv>0) {
verwijder [] s;
verwijder [] vt[0];
verwijder [] vt;
} return 0;
}

Conclusie

In dit artikel hebben we de definitie van de singuliere waarde decompositie uitgelegd en je geholpen om de constructie van het model in C-taal te begrijpen. Je kunt deze methode gebruiken om atmosferische variabelen te bepalen aan de hand van satelliet metingen. U kunt deze techniek ook gebruiken voor het interpoleren van schaarse metingen of voor een machine-learning algoritme. Deze techniek helpt bij regressie en classificatie van de dataset.