A análise de componentes principais e a decomposição de valores singulares estão entre os dois conceitos comuns de álgebra linear na aprendizagem de máquinas. Após a recolha de dados brutos, é possível descobrir a estrutura? Por exemplo, quando consideramos as taxas de juro da semana anterior, existe alguma forma de descobrir as tendências do mercado?
Estas questões complicam-se cada vez mais quando temos grandes quantidades de dados. Encontrar a resposta a estas perguntas é semelhante à procura de uma agulha no palheiro. Assim, utilizamos a decomposição do valor singular para desembaraçar e extrair a informação complicada. Este artigo irá ajudá-lo a compreender o conceito de decomposição do valor singular em detalhe.

Decomposição de Valor Singular

Esta técnica estatística multivariada ajuda a resolver problemas complexos nas ciências atmosféricas. A análise empírica da função ortogonal e a análise dos componentes principais são conjuntos de procedimentos semelhantes para a mesma técnica introduzida em 1956 por Edward Lorenz.
A decomposição de valores singulares ajuda a reduzir conjuntos de dados contendo um grande número de valores. Além disso, este método também é útil para gerar soluções significativas para menos valores. No entanto, estes menos valores compreendem também uma imensa variabilidade disponível nos dados originais.
Os dados revelam grandes correlações espaciais nas ciências geofísicas e atmosféricas. Uma análise de Decomposição de Valores Singulares apoia e produz resultados para uma demonstração mais compacta destas correlações. Ao utilizar conjuntos de dados multivariados, é possível produzir conhecimentos sobre variações temporais e espaciais. Estas variações exibem dados após a análise.
Embora haja menos limitações à técnica, deve compreendê-las antes de calcular a Decomposição de Valor Singular dos conjuntos de dados. Primeiro, devem existir anomalias nos dados que a primeira estrutura irá captar. Se estiver a analisar os dados para encontrar correlações espaciais independentes das tendências, deve desdobrar os dados antes de os aplicar à análise.

Vectores individuais & Valores individuais

A matriz AAᵀ e AᵀA em álgebra linear são muito especiais. Multiplicando o Aᵀ com a matriz após considerá-los × n matriz A, podemos formar AAᵀ e AᵀA individualmente. As matrizes incluem:
– Quadrado
– Simétrico
– As mesmas matrizes com ambos os valores próprios positivos
– Positivo semidefinido, e
– O mesmo r que A com ambas as classificações
Uma grande propriedade das matrizes simétricas é que elas são simétricas, e nós escolhemos os vectores próprios para serem orto-normais. Utilizamos muito estas matrizes de covariância na aprendizagem de máquinas.

Exemplo de Decomposição de Valor Singular

Para compreender o conceito, vamos supor que a matriz m × n, A, recolhe o conjunto de dados de formação. Estes conjuntos de dados tomarão a linha para cada vector de treino. Aqui, N indica que a dimensão de cada vector será muito grande.

Ao alimentar o A num algoritmo de agrupamento, gerará um número fixo de centros de agrupamento como saída. Uma vez que ‘n’ é bastante grande, o algoritmo será instável ou demorará demasiado tempo. Assim, iremos utilizar a decomposição de valores singulares para reduzir o número de variáveis. Utilizaremos um método transparente de cálculo, considerando que ainda estamos a resolver o problema com coordenadas não transformadas.

Passo 1: Leitura nos dados

Podemos começar a ler os dados preenchendo A. Assim, vamos começar o tutorial em língua C:
//cabeçalho de subrotina para realizar a análise de agrupamento:
#incluir “cluster.h”// número máximo de clusters:
#define MAX_CLUSTER 10int main(intargc, char **argv) {
char *infile; //input file
char *outfile; //ficheiro de saída
FILE *fs; // apontador de ficheiros
duplo **a; //matriz de dados de formação/U
int m; //número de filas na matriz
int n; //número de colunas na matriz
intnsv; //número de valores singulares se (argc!=4) {
printf(“syntax: cluster_svdnsv train centers\n”);
printf(” onde:\n”);
printf(“nsv = número de valores singulares (0 = utilizar dados não transformados)\n”));
printf(“infile = ficheiro de entrada ASCII contendo dados de formação\n”);
printf(“output = ficheiro de saída em ASCII contendo centros de agrupamento\n”);
printf(“\n”);
printf(“file format:\n”);
printf(“- cabeçalho de uma linha contendo número de linhas e número de colunas\n”);
printf(“- lista principal de linhas de cada elemento da matriz\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”);
if (fs==NULL) {
fprintf(stderr, “Error opening input file, %s\n”, infile);
exit(1);
} if (fscanf(fs, “%d %d”, &m, &n)!=2) {
fprintf(stderr, “Formatar erro no ficheiro de entrada: %s linha 0”, infile);
exit(1);
}
se (nsv>n) {
fprintf(stderr, “Parâmetro da linha de comando nsv=%d fora do intervalo\n”, nsv);
exit(1);
a=novo duplo *[m];
a[0]=novo duplo[m*n];
para (inti=1; i<m; i++) a[i]=a[0]+i*n;
para (inti=0; i<m; i++) {
para (int j=0; j<n; j++) {
se (fscanf(fs, “%lg”, a[i]+j)!=1) {
fprintf(stderr, “Formatar erro no ficheiro de entrada, %s, linha %d\n”, infile, i);
exit(1);
}
}
} fclose(fs);

Passo 2: Realizar SVD

Agora vamos utilizar a rotina de decomposição artificial de valores singulares que o ficheiro de cabeçalho, svd.h contém:
#ifndef SVD_H
#define SVD_H//subroutine para decomposição de valor singular:
int // devolve um código de erro (0 para sucesso)
svd (duplo **a, //input matrix– substituído por U na saída
int m, //número de filas
int n, //número de colunas
valores duplos *s, //singulares
duplo **vt); //V– vectores singulares#endif
As rotinas de decomposição de valores individuais são complexas em relação ao tipo de matriz e vector utilizados. No entanto, é possível resumir facilmente a codificação completa através da função de invólucro. A rotina será igualmente simples quando se contar com uma rotina de decomposição de valores singulares. Acrescentaremos os seguintes códigos após a secção anterior:
duplo *ave;
duplo *s; //valores singulares
duplo **vt; // direito vectores singulares //first calculamos e removemos os meios aritméticos:
ave=novo duplo[n];
para (inti=0; i<n; i++) ave[i]=0;
para (inti=0; i<m; i++) {
para (int j=0; j<n; j++) {
ave[j]+=a[i][j];
}
}
para (inti=0; i<n; i++) ave[i]/=m;
for (inti=0; i<m; i++) {
para (int j=0; j<n; j++) {
a[i][j]-=ave[j];
}
} if (nsv>0) {
// criar espaço para valores singulares:
s=novo duplo[n]; // criar espaço para os vectores do singular direito:
vt=novo duplo *[n];
vt[0]=novo duplo[n*n];
para (inti=1; i<n; i++) vt[i]=vt[0]+i*n; //performar a decomposição:
int err=svd(a, m, n, s, vt);
se (err!=0) {
fprintf(stderr, “Error in svd subroutine\n”));
exit(err);
}
}

Passo 3: Execução da Análise de Agrupamento

O processo do algoritmo de agrupamento irá gerar um conjunto de centros de agrupamento c usando {ᵢ ; i ∈ [1, c]}:
#ifndef CLUSTER_H
#define CLUSTER_Hint //restitui o número de centros de agrupamento
cluster (duplo ** x, //vectores de treino
int m, //número de vectores de formação
int n, //dimensão de cada vector
intmax_nc, // número máximo de centros de agrupamento
duplo **mu); // centros de agrupamento retornados#endif
Vamos continuar a partir da secção acima e gerar os centros de agrupamento:
duplo **mu_p; //matriz de centros de aglomeração
intnc; //número de centros de agrupamento // espaço para centros de agrupamento:
mu_p=novo duplo *[MAX_CLUSTER];
mu_p[0]=novo duplo [MAX_CLUSTER*n];
para (inti=1; i<MAX_CLUSTER; i++) mu_p[i]=mu_p[0]+i*n; se (nsv>0) {
// criar espaço para centros de agrupamento:
nc=cluster(a, m, nsv, MAX_CLUSTER, mu_p);
} else {
// criar espaço para centros de agrupamento:
nc=cluster(a, m, n, MAX_CLUSTER, mu_p);
} if (nc<= 0) {
fprintf(stderr, “Algoritmo de cluster falhou”);
exit(-1);
}
Como utilizaremos os dados de formação transformados para o algoritmo de clustering, o sistema transformado incluirá os centros de clustering.

Passo 4: Armazenamento dos resultados

Agora pode armazenar os centros de agrupamento utilizando a seguinte equação no sistema de coordenadas não transformado.

P nesta equação significa o número de coordenadas.
duplo **mu; // centros de agrupamento em coordenadas não transferidas //alocar espaço para os centros de agrupamento não transformados:
mu=novo duplo *[nc];
mu[0]=novo duplo[nc*n];
para (inti=1; i<nc; i++) mu[i]=mu[0]+i*n; //performar a transformação de coordenadas:
for (inti=0; i<nc; i++) {
para (int j=0; j<n; j++) {
mu[i][j]=ave[j];
se (nsv>0) {
para (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];
}
}
} //escrever os resultados num ficheiro:
fs=fopen(outfile, “w”);
se (fs==NULL) {
fprintf(stderr, “Error opening output file, %s\n”, outfile);
saída(1);
fprintf(fs, “%d %d\n”, nc, n);
for (inti=0; i<nc; i++) {
para (int j=0; j<n; j++) fprintf(fs, “%16,8lg”, mu[i][j]));
fprintf(fs, “\n”);
fclose(fs); //clean up:
apagar [] mu[0];
apagar [] mu; apagar [] mu_p[0];
apagar [] mu_p; apagar [] ave;
apagar [] a[0];
apagar [] a;
se (nsv>0) {
apagar [] s;
apagar [] vt[0];
apagar [] vt;
devolver 0;
}

Conclusão

Neste artigo, explicamos a definição da decomposição do valor singular e ajudamos a compreender a construção do modelo na língua C. Pode utilizar este método para recuperar as variáveis atmosféricas de acordo com as medições de satélite. Também pode utilizar esta técnica para interpolar medições esparsas ou para um algoritmo de aprendizagem de máquinas. Esta técnica ajuda na regressão e classificação do conjunto de dados.