L’analyse en composantes principales et la décomposition en valeurs singulières font partie des deux concepts courants de l’algèbre linéaire dans l’apprentissage automatique. Après avoir collecté des données brutes, est-il possible d’en découvrir la structure ? Par exemple, si l’on considère les taux d’intérêt de la semaine précédente, est-il possible de déterminer les tendances du marché ?
Ces questions se compliquent lorsque nous disposons de grandes quantités de données. Trouver la réponse à ces questions revient à chercher une aiguille dans une botte de foin. Nous utilisons donc la décomposition en valeur singulière pour démêler et extraire les informations complexes. Cet article vous aidera à comprendre en détail le concept de décomposition en valeur singulière.

Décomposition en valeur singulière

Cette technique statistique multivariée permet de résoudre des problèmes complexes dans le domaine des sciences atmosphériques. L’analyse des fonctions orthogonales empiriques et l’analyse en composantes principales sont des ensembles de procédures similaires pour la même technique introduite en 1956 par Edward Lorenz.
La décomposition en valeurs singulières permet de réduire les ensembles de données contenant un grand nombre de valeurs. En outre, cette méthode est également utile pour générer des solutions significatives pour un nombre réduit de valeurs. Cependant, ces valeurs moins nombreuses comprennent également une immense variabilité disponible dans les données d’origine.
Les données révèlent de grandes corrélations spatiales dans les sciences géophysiques et atmosphériques. Une analyse de décomposition en valeurs singulières soutient et donne des résultats pour une démonstration plus compacte de ces corrélations. En utilisant des ensembles de données multivariées, vous pouvez obtenir des informations sur les variations temporelles et spatiales. Ces variations présentent des données après l’analyse.
Même si cette technique présente moins de limites, vous devez les comprendre avant de calculer la décomposition en valeurs singulières des ensembles de données. Tout d’abord, il doit y avoir des anomalies dans les données que la première structure va capturer. Si vous analysez les données pour trouver des corrélations spatiales indépendantes des tendances, vous devez dé-tendre les données avant de les appliquer à l’analyse.

Vecteurs singuliers et valeurs singulières

La matrice AAᵀ et AᵀA en algèbre linéaire sont très particulières. En multipliant l’Aᵀ avec la matrice après avoir considéré eux × n matrice A, nous pouvons former AAᵀ et AᵀA individuellement. Les matrices comprennent :
– Carrées
– Symétriques
– Les matrices identiques avec les deux valeurs propres positives.
– Demi-définies positives, et
– Même r que A avec les deux rangs
L’une des principales propriétés des matrices symétriques est qu’elles sont symétriques et que les vecteurs propres sont orthonormés. Nous utilisons beaucoup ces matrices de covariance en apprentissage automatique.

Exemple de décomposition en valeurs singulières

Pour comprendre le concept, supposons que la matrice m × n, A, rassemble l’ensemble des données de formation. Ces ensembles de données occuperont la ligne de chaque vecteur d’apprentissage. Ici, N indique que la dimension de chaque vecteur sera très grande.

En introduisant la matrice A dans un algorithme de clustering, vous générerez un nombre fixe de centres de cluster en sortie. Comme ‘n’ est assez grand, l’algorithme sera instable ou prendra trop de temps. Nous utiliserons donc la décomposition en valeurs singulières pour réduire le nombre de variables. Nous utiliserons une méthode transparente pour le calcul, étant donné que nous résolvons toujours le problème avec des coordonnées non transformées.

Étape 1 : Lecture des données

Nous pouvons commencer à lire les données en remplissant A. Commençons donc le tutoriel en langage C :
//en-tête de sous-routine pour effectuer l’analyse de cluster :
#include “cluster.h”//nombre maximal de clusters :
#define MAX_CLUSTER 10int main(intargc, char **argv) {
char *infile ; //fichier d’entrée
char *outfile ; //fichier de sortie
FILE *fs ; //pointeur de fichier
double **a ; //matrice des données d’apprentissage/U
int m ; //nombre de lignes de la matrice
int n ; //nombre de colonnes dans la matrice
intnsv ; //nombre de valeurs singulières if (argc!=4) {
printf(“syntaxe : cluster_svdnsv train centers\n”) ;
printf(” où:\n”) ;
printf(“nsv = nombre de valeurs singulières (0 = utiliser des données non transformées)\n”) ;
printf(“infile = fichier d’entrée ASCII contenant les données d’apprentissage \n”) ;
printf(“output = fichier de sortie ASCII contenant les centres de clusters\n”) ;
printf(“\n”) ;
printf(“format du fichier:\n”) ;
printf(“- en-tête d’une ligne contenant le nombre de lignes et le nombre de colonnes\n”) ;
printf(“- liste des principales lignes de chaque élément de la matrice\n”) ;
exit(1) ;
} if (sscanf(argv[1], “%d”, &nsv)!=1) {
fprintf(stderr, “Error parsing first command line argument\n”) ;
exit(1) ;
}
infile=argv[2] ;
outfile=argv[3] ; fs=fopen(infile, “r”) ;
si (fs==NULL) {
fprintf(stderr, “Error opening input file, %s\n”, infile) ;
exit(1) ;
} si (fscanf(fs, “%d %d”, &m, &n)!=2) {
fprintf(stderr, “Erreur de format dans le fichier d’entrée : %s line 0”, infile) ;
exit(1) ;
}
if (nsv>n) {
fprintf(stderr, “Command line parameter nsv=%d out of range”, nsv) ;
exit(1) ;
} a=nouveau double *[m] ;
a[0]=nouveau 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, “Format error in input file, %s, line %d\n”, infile, i) ;
exit(1) ;
}
}
} fclose(fs) ;

Étape 2 : Exécution de l’UDS

Nous allons maintenant utiliser la routine de décomposition de la valeur singulière artificielle que contient le fichier d’en-tête, svd.h :
#ifndef SVD_H
#define SVD_H//sous-routine de décomposition de la valeur singulière :
int //renvoie un code d’erreur (0 pour le succès)
svd (double **a, //matrice d’entrée–remplacée par U en sortie
int m, //nombre de lignes
int n, //nombre de colonnes
double *s, //valeurs singulières
double **vt) ; //V–vecteurs singuliers de droite#endif
Les routines de décomposition de la valeur singulière sont complexes en ce qui concerne le type de matrice et de vecteur utilisés. Cependant, vous pouvez facilement résumer le codage complet grâce à la fonction wrapper. La routine sera tout aussi simple si vous vous appuyez sur une routine de décomposition de la valeur singulière. Nous ajouterons les codes suivants après la section précédente :
double *ave ;
double *s ; //valeurs singulières
double **vt ; //vecteurs singuliers de droite //en premier lieu, nous calculons et supprimons les moyennes arithmétiques :
ave=new double[n] ;
for (inti=0 ; i<n ; i++) ave[i]=0 ;
for (inti=0 ; i<m ; i++) {
pour (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++) {
pour (int j=0 ; j<n ; j++) {
a[i][j]-=ave[j] ;
}
} if (nsv>0) {
//mettez de la place pour les valeurs singulières :
s=nouveau double[n] ; //mettre de l’espace pour les vecteurs singuliers de droite :
vt=nouveau double *[n] ;
vt[0]=nouveau double[n*n] ;
for (inti=1 ; i<n ; i++) vt[i]=vt[0]+i*n ; //réalise la décomposition :
int err=svd(a, m, n, s, vt) ;
if (err!=0) {
fprintf(stderr, “Error in svd subroutine\n”) ;
exit(err) ;
}
}

Étape 3 : Exécution de l’analyse de cluster

Le processus de l’algorithme de clustering va générer un ensemble de c centres de cluster en utilisant {ᵢ ; i ∈ [1, c]} :
#ifndef CLUSTER_H
#define CLUSTER_Hint //renvoie le nombre de centres de clusters
cluster (double ** x, //vecteurs d’apprentissage
int m, //nombre de vecteurs d’apprentissage
int n, //dimension de chaque vecteur
intmax_nc, //nombre maximal de centres de clusters
double **mu) ; //centres de cluster retournés#endif
Nous allons continuer à partir de la section précédente et générer les centres de clusters :
double **mu_p ; //matrice de centres de clusters
intnc ; //nombre de centres de clusters //mettre de la place pour les centres de clusters :
mu_p=nouveau double *[MAX_CLUSTER] ;
mu_p[0]=nouveau double[MAX_CLUSTER*n] ;
for (inti=1 ; i<MAX_CLUSTER ; i++) mu_p[i]=mu_p[0]+i*n ; if (nsv>0) {
//faire de la place pour les centres des clusters :
nc=cluster(a, m, nsv, MAX_CLUSTER, mu_p) ;
} else {
//construire un espace pour les centres de clusters :
nc=cluster(a, m, n, MAX_CLUSTER, mu_p) ;
} if (nc<= 0) {
fprintf(stderr, “Cluster algorithm failed”) ;
exit(-1) ;
}
Comme nous allons utiliser les données d’entraînement transformées pour l’algorithme de clustering, le système transformé inclura les centres de cluster.

Étape 4 : Stockage des résultats

Vous pouvez maintenant stocker les centres de cluster en utilisant l’équation suivante dans le système de coordonnées non transformé.

P dans cette équation signifie le nombre de coordonnées.
double **mu ; //centres des clusters dans les coordonnées non transformées //allocation d’espace pour les centres des clusters non transformés :
mu=nouveau double *[nc] ;
mu[0]=nouveau double[nc*n] ;
for (inti=1 ; i<nc ; i++) mu[i]=mu[0]+i*n ; //réalise la transformation des coordonnées :
for (inti=0 ; i<nc ; i++) {
pour (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] ;
} else {
mu[i][j]+=mu_p[i][j];
}
}
} //écrit les résultats dans un fichier :
fs=fopen(outfile, “w”) ;
if (fs==NULL) {
fprintf(stderr, “Error opening output file, %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) ; //Nettoyage :
supprimer [] mu[0] ;
supprimer [] mu ; supprimer [] mu_p[0] ;
supprime [] mu_p ; supprime [] ave ;
supprimer [] a[0] ;
supprime [] a ;
if (nsv>0) {
supprime [] s ;
supprime [] vt[0] ;
supprime [] vt ;
} return 0 ;
}

Conclusion

Dans cet article, nous avons expliqué la définition de la décomposition en valeurs singulières et nous vous avons aidé à comprendre la construction du modèle en langage C. Vous pouvez utiliser cette méthode pour récupérer les variables atmosphériques en fonction des mesures satellites. Vous pouvez également utiliser cette technique pour interpoler des mesures éparses ou pour un algorithme d’apprentissage automatique. Cette technique aide à la régression et à la classification du jeu de données.