El análisis de componentes principales y la descomposición del valor singular son dos conceptos habituales del álgebra lineal en el aprendizaje automático. Después de recoger los datos en bruto, ¿es posible descubrir la estructura? Por ejemplo, si consideramos los tipos de interés de la semana anterior, ¿hay alguna forma de averiguar las tendencias del mercado?
Estas preguntas se complican cuando tenemos grandes cantidades de datos. Encontrar la respuesta a estas preguntas es similar a buscar una aguja en el pajar. Por ello, utilizamos la descomposición del valor singular para desenredar y extraer la información complicada. Este artículo le ayudará a entender el concepto de descomposición del valor singular en detalle.

Descomposición del valor singular

Esta técnica estadística multivariante ayuda a resolver problemas complejos en las ciencias atmosféricas. El análisis de funciones ortogonales empíricas y el análisis de componentes principales son conjuntos de procedimientos similares para la misma técnica introducida en 1956 por Edward Lorenz.
La descomposición del valor singular ayuda a reducir los conjuntos de datos que contienen un gran número de valores. Además, este método también es útil para generar soluciones significativas para menos valores. Sin embargo, este menor número de valores también comprende la inmensa variabilidad disponible en los datos originales.
Los datos revelan grandes correlaciones espaciales en las ciencias geofísicas y atmosféricas. Un análisis de Descomposición de Valores Singulares apoya y arroja resultados para una demostración más compacta de estas correlaciones. El uso de conjuntos de datos multivariados permite obtener información sobre las variaciones temporales y espaciales. Estas variaciones exhiben los datos después del análisis.
Aunque la técnica tiene menos limitaciones, debe comprenderlas antes de calcular la descomposición del valor singular de los conjuntos de datos. En primer lugar, debe haber anomalías en los datos que la primera estructura capturará. Si está analizando los datos para encontrar correlaciones espaciales independientes de las tendencias, debería eliminar las tendencias de los datos antes de aplicarlas al análisis.

Vectores singulares y valores singulares

Las matrices Aᵀ y AᵀA en álgebra lineal son muy especiales. Al multiplicar la Aᵀ con la matriz después de considerarlas × n matriz A, podemos formar AAᵀ y AᵀA individualmente. Las matrices incluyen:
– Cuadradas
– Simétricas
– Matrices iguales con ambos valores propios positivos
– Semidefinidas positivas, y
– Misma r que A con ambos rangos
Una propiedad importante de las matrices simétricas es que son simétricas, y elegimos que los vectores propios sean ortonormales. Utilizamos mucho estas matrices de covarianza en el aprendizaje automático.

Ejemplo de descomposición del valor singular

Para entender el concepto, supongamos que la matriz m × n, A, recoge el conjunto de datos de entrenamiento. Estos conjuntos de datos tomarán la fila de cada vector de entrenamiento. Aquí, N indica que la dimensión de cada vector será muy grande.

Al alimentar el A en un algoritmo de clustering, se generará un número fijo de centros de cluster como salida. Como ‘n’ es bastante grande, el algoritmo será inestable o tardará demasiado. Por lo tanto, utilizaremos la descomposición del valor singular para reducir el número de variables. Utilizaremos un método transparente para el cálculo, teniendo en cuenta que todavía estamos resolviendo el problema con coordenadas no transformadas.

Paso 1: Lectura de los datos

Podemos empezar a leer los datos rellenando A. Así que vamos a empezar el tutorial en lenguaje C:
/cabecera de la subrutina para realizar el análisis de cluster:
#include “cluster.h”//número máximo de clusters:
#define MAX_CLUSTER 10int main(intargc, char **argv) {
char *infile; //archivo de entrada
char *outfile; //fichero de salida
FILE *fs; //puntero al fichero
double **a; //matriz de datos de entrenamiento/U
int m; //número de filas de la matriz
int n; //número de columnas de la matriz
intnsv; //número de valores singulares if (argc!=4) {
printf(“sintaxis: cluster_svdnsv entrenar centros\n”);
printf(” donde:\n”);
printf(“nsv = número de valores singulares (0 = usar datos no transformados)\n”);
printf(“infile = archivo de entrada ASCII que contiene los datos de entrenamiento\n”);
printf(“output = archivo de salida ASCII que contiene los centros de cluster\n”);
printf(“\n”);
printf(“formato del archivo:\n”);
printf(“- cabecera de una línea que contiene el número de filas y el número de columnas\n”);
printf(“- lista mayor de filas de cada elemento de la matriz\n”);
exit(1);
} si (sscanf(argv[1], “%d”, &nsv)!=1)
fprintf(stderr, “Error al analizar el primer argumento de la línea de comandos\n”);
exit(1);
}
infile=argv[2];
outfile=argv[3]; fs=fopen(infile, “r”);
if (fs==NULL) {
fprintf(stderr, “Error al abrir el archivo de entrada, %s\n”, infile);
exit(1);
} if (fscanf(fs, “%d %d”, &m, &n)!=2) {
fprintf(stderr, “Error de formato en el archivo de entrada: %s línea 0”, infile);
exit(1);
}
if (nsv>n) {
fprintf(stderr, “Parámetro de línea de comando nsv=%d fuera de rango\n”, nsv);
exit(1);
} a=nuevo double *[m];
a[0]=nuevo 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, “Error de formato en el archivo de entrada, %s, línea %d\n”, infile, i);
exit(1);
}
}
} fclose(fs);

Paso 2: Realización de la SVD

Ahora utilizaremos la rutina de descomposición artificial del valor singular que contiene el fichero de cabecera, svd.h:
#ifndef SVD_H
#define SVD_H//subrutina para la descomposición del valor singular:
int //devuelve un código de error (0 para el éxito)
svd (double **a, //matriz de entrada–reemplazada por U en la salida
int m, //número de filas
int n, //número de columnas
double *s, /valores singulares
double **vt); //V–vectores singulares derechos#endif
Las rutinas de descomposición de valores singulares son complejas en cuanto al tipo de matriz y vector utilizados. Sin embargo, se puede resumir fácilmente la codificación completa a través de la función wrapper. La rutina será igualmente sencilla cuando se apoye en una rutina de descomposición de valor singular. Añadiremos los siguientes códigos después de la sección anterior:
double *ave;
double *s; /valores singulares
double **vt; //vectores singulares derechos //primero calculamos y eliminamos las medias aritméticas:
ave=nuevo 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) {
//hacer espacio para los valores singulares:
s=nuevo double[n]; //hacer espacio para los vectores singulares derechos:
vt=nuevo double[n];
vt[0]=nuevo double[n*n];
for (inti=1; i<n; i++) vt[i]=vt[0]+i*n; //realizar la descomposición:
int err=svd(a, m, n, s, vt);
si (err!=0) {
fprintf(stderr, “Error en la subrutina svd\n”);
exit(err);
}
}

Paso 3: Ejecución del análisis de cluster

El proceso del algoritmo de clustering generará un conjunto de centros de cluster usando {ᵢ ; i ∈ [1, c]}:
#ifndef CLUSTER_H
#define CLUSTER_Hint //devuelve el número de centros de cluster
cluster (double ** x, //vectores de entrenamiento
int m, //número de vectores de entrenamiento
int n, //dimensión de cada vector
intmax_nc, //número máximo de centros de cluster
double **mu); //centros de cluster devueltos#endif
Continuaremos desde la sección anterior y generaremos los centros de los clusters:
double **mu_p; //matriz de centros de cluster
intnc; //número de centros de cluster //hacer espacio para los centros de cluster:
mu_p=nuevo doble *[MAX_CLUSTER];
mu_p[0]=nuevo double[MAX_CLUSTER*n];
for (inti=1; i<MAX_CLUSTER; i++) mu_p[i]=mu_p[0]+i*n; if (nsv>0) {
//hacer espacio para los centros de los clusters:
nc=cluster(a, m, nsv, MAX_CLUSTER, mu_p);
} else {
//hacer espacio para los centros de los clusters:
nc=cluster(a, m, n, MAX_CLUSTER, mu_p);
} if (nc<= 0) {
fprintf(stderr, “Cluster algorithm failed”);
exit(-1);
}
Como usaremos los datos de entrenamiento transformados para el algoritmo de clustering, el sistema transformado incluirá los centros de cluster.

Paso 4: Almacenamiento de los resultados

Ahora puede almacenar los centros de cluster usando la siguiente ecuación en el sistema de coordenadas no transformado.

P en esta ecuación significa el número de coordenadas.
double **mu; //centros de cluster en coordenadas no transformadas //asignar espacio para los centros de cluster no transformados:
mu=nuevo double *[nc];
mu[0]=nuevo double[nc*n];
for (inti=1; i<nc; i++) mu[i]=mu[0]+i*n; //realizar la transformación de coordenadas:
for (inti=0; i<nc; i++) {
for (int j=0; j<n; j++) {
mu[i][j]=ave[j];
si (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];
}
}
} //escribir los resultados en un archivo:
fs=fopen(outfile, “w”);
si (fs==NULL) {
fprintf(stderr, “Error al abrir el archivo de salida, %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); //limpiar:
borrar [] mu[0];
borrar [] mu; borrar [] mu_p[0];
delete [] mu_p; delete [] ave;
borrar [] a[0];
borrar [] a;
si (nsv>0) {
borrar [] s;
borrar [] vt[0];
delete [] vt;
} return 0;
}

Conclusión

En este artículo hemos explicado la definición de la descomposición de valores singulares y te hemos ayudado a entender la construcción del modelo en lenguaje C. Puedes utilizar este método para recuperar las variables atmosféricas según las mediciones de los satélites. También puede utilizar esta técnica para interpolar mediciones dispersas o para un algoritmo de aprendizaje automático. Esta técnica ayuda a la regresión y clasificación del conjunto de datos.