Gire os componentes do PCA para equalizar a variação em cada componente

Estou tentando reduzir a dimensionalidade e o ruído de um conjunto de dados executando o PCA no conjunto de dados e jogando fora os últimos PCs. Depois disso, quero usar alguns algoritmos de aprendizado de máquina nos PCs restantes e, portanto, quero normalizar os dados equalizando a variação dos PCs para fazer com que os algoritmos funcionem melhor.

Uma maneira simples é simplesmente normalizar a variação para os valores unitários. No entanto, o primeiro PC contém mais variação do conjunto de dados original do que os seguintes, e ainda quero dar mais "peso" a ele. Por isso, fiquei pensando: existe uma maneira simples de dividir sua variação e compartilhá-la com os PCs com menos variações?

Outra maneira é mapear os PCs de volta ao espaço original, mas nesse caso a dimensionalidade também aumentaria para o valor original.

Eu acho que é melhor manter as colunas resultantes ortogonais, mas não é necessário neste momento.

Não está totalmente claro para mim que o que você está perguntando é o que realmente precisa: uma etapa comum de pré-processamento no aprendizado de máquina é redução de dimensionalidade + clareamento, o que significa fazer PCA e padronizar os componentes, nada mais. No entanto, vou me concentrar na sua pergunta conforme ela é formulada, porque é mais interessante.

---

Seja a matriz de dados centralizada com pontos de dados em linhas e variáveis ​​em colunas. O PCA equivale a decomposição de valor singular onde executar a redução de dimensionalidade mantemos apenas componentes. Uma "rotação fatorial" ortogonal desses componentes implica escolher uma matriz ortogonal e conectá-lo à decomposição:$\mathbf X$$n\times d$

$$\mathbf X = \mathbf{USV}^\top \approx \mathbf U_k \mathbf S_k \mathbf V_k^\top,$$ $k$$k \times k$$\mathbf R$ $$\mathbf X \approx \mathbf U_k \mathbf S_k \mathbf V_k^\top = \mathbf U_k \mathbf {RR}^\top \mathbf S_k \mathbf V_k^\top = \underbrace{\sqrt{n-1}\mathbf U_k^\phantom\top \mathbf {R}}_{\substack{\text{Rotated}\\\text{standardized scores}}} \cdot \underbrace{\mathbf R^\top \mathbf S_k \mathbf V_k^\top/\sqrt{n-1}}_{\text{Rotated loadings}^\top}.$$ Aqui são componentes padronizados rotacionados e o segundo termo representa cargas rotacionadas transpostas. A variação de cada componente após a rotação é dada pela soma dos quadrados do vetor de carregamento correspondente; antes da rotação é simplesmente . Após a rotação, é outra coisa.$\sqrt{n-1}\mathbf U_k \mathbf R$$s_i^2/(n-1)$

Agora, estamos prontos para formular o problema em termos matemáticos: considerando cargas não rotacionadas , encontre a matriz de rotação modo que as cargas rotadas, , possui soma igual de quadrados em cada coluna.$\mathbf L = \mathbf V_k \mathbf S_k / \sqrt{n-1}$$\mathbf R$$\mathbf L \mathbf R$

Vamos resolver isso. As somas de quadrados da coluna após a rotação são iguais aos elementos diagonais de Isso faz sentido: a rotação simplesmente redistribui as variações dos componentes, que são originalmente fornecidos por , entre eles, de acordo com esta fórmula. Precisamos redistribuí-los para que todos se tornem iguais ao seu valor médio .

$$(\mathbf {LR})^\top \mathbf{LR} = \mathbf R^\top \frac{\mathbf S^2}{n-1} \mathbf R.$$ $s_i^2/(n-1)$$\mu$

Não acho que exista uma solução de formulário fechado para isso e, de fato, existem muitas soluções diferentes. Mas uma solução pode ser facilmente criada de maneira sequencial:

1. Pegue o primeiro componente e o ésimo componente. O primeiro possui a variação e o último possui a variação .$k$$\sigma_\text{max}>\mu$$\sigma_\text{min}<\mu$
2. Gire apenas esses dois para que a variação do primeiro se torne igual a . A matriz de rotação em 2D depende apenas de um parâmetro e é fácil escrever a equação e calcular o necessário . De fato, e após a transformação, o primeiro PC terá variação do qual obtemos imediatamente$\mu$$\theta$$\theta$ $$\mathbf R_\text{2D} = \left(\begin{array}{cc}\cos \theta & \sin \theta \\ -\sin\theta & \cos \theta\end{array}\right)$$ $$\cos^2\theta \cdot \sigma_\text{max} + \sin^2\theta \cdot \sigma_\text{min} = \cos^2\theta \cdot \sigma_\text{max} + (1-\cos^2\theta)\cdot \sigma_\text{min} =\mu,$$ $$\cos^2\theta = \frac{\mu-\sigma_\text{min}}{\sigma_\text{max}-\sigma_\text{min}}.$$
3. O primeiro componente está pronto, possui variação .$\mu$
4. Prossiga para o próximo par, levando o componente com a maior variação e o componente com a menor variação. Vá para o 2.

Isso redistribuirá todas as variações igualmente por uma sequência de rotações 2D. A multiplicação de todas essas matrizes de rotação resultará no geral .$(k-1)$$\mathbf R$

---

Exemplo

Considere a seguinte matriz :A variação média é . Meu algoritmo continuará da seguinte maneira:$\mathbf S^2/(n-1)$

$$\left(\begin{array}{cccc}10&0&0&0\\0&6&0&0\\0&0&3&0\\0&0&0&1\end{array}\right).$$ $5$

1. Etapa 1: gire PC1 e PC4 para que PC1 obtenha variação . Como resultado, PC4 obtém a variação .$5$$1+(10-5)=6$

2. Etapa 2: gire PC2 (nova variação máxima) e PC3 para que PC2 obtenha a variação . Como resultado, PC3 obtém variação .$5$$3+(6-5)=4$

3. Etapa 3: gire PC4 (nova variação máxima) e PC3 para que o PC4 obtenha a variação . Como resultado, PC3 obtém variação .$5$$4+(6-1)=5$

4. Feito.

Eu escrevi o script Matlab que implementa esse algoritmo (veja abaixo). Para esta matriz de entrada, a sequência dos ângulos de rotação é:

48.1897   35.2644   45.0000

Desvios de componentes após cada etapa (em linhas):

10     6     3     1
 5     6     3     6
 5     5     4     6
 5     5     5     5

A matriz de rotação final (produto de três matrizes de rotação 2D):

 0.6667         0    0.5270    0.5270
      0    0.8165    0.4082   -0.4082
      0   -0.5774    0.5774   -0.5774
-0.7454         0    0.4714    0.4714

E a matriz final é:$(\mathbf{LR})^\top \mathbf{LR}$

5.0000         0    3.1623    3.1623
     0    5.0000    1.0000   -1.0000
3.1623    1.0000    5.0000    1.0000
3.1623   -1.0000    1.0000    5.0000

Aqui está o código:

S = diag([10 6 3 1]);
mu = mean(diag(S));
R = eye(size(S));

vars(1,:) = diag(S);
Supdated = S;

for i = 1:size(S,1)-1
    [~, maxV] = max(diag(Supdated));
    [~, minV] = min(diag(Supdated));

    w = (mu-Supdated(minV,minV))/(Supdated(maxV,maxV)-Supdated(minV,minV));
    cosTheta = sqrt(w);
    sinTheta = sqrt(1-w);

    R2d = eye(size(S));
    R2d([maxV minV], [maxV minV]) = [cosTheta sinTheta; -sinTheta cosTheta];
    R = R * R2d;

    Supdated = transpose(R2d) * Supdated * R2d;    

    vars(i+1,:) = diag(Supdated);
    angles(i) = acosd(cosTheta);
end

angles                %// sequence of 2d rotation angles
round(vars)           %// component variances on each step
R                     %// final rotation matrix
transpose(R)*S*R      %// final S matrix

Aqui está o código em Python fornecido pelo @feilong:

def amoeba_rotation(s2):
    """
    Parameters
    ----------
    s2 : array
        The diagonal of the matrix S^2.

    Returns
    -------
    R : array
        The rotation matrix R.

    Examples
    --------
    >>> amoeba_rotation(np.array([10, 6, 3, 1]))
    [[ 0.66666667  0.          0.52704628  0.52704628]
     [ 0.          0.81649658  0.40824829 -0.40824829]
     [ 0.         -0.57735027  0.57735027 -0.57735027]
     [-0.74535599  0.          0.47140452  0.47140452]]

    http://stats.stackexchange.com/a/177555/87414
    """
    n = len(s2)
    mu = s2.mean()
    R = np.eye(n)
    for i in range(n-1):
        max_v, min_v = np.argmax(s2), np.argmin(s2)
        w = (mu - s2[min_v]) / (s2[max_v] - s2[min_v])
        cos_theta, sin_theta = np.sqrt(w), np.sqrt(1-w)
        R[:, [max_v, min_v]] = np.dot(
            R[:, [max_v, min_v]],
            np.array([[cos_theta, sin_theta], [-sin_theta, cos_theta]]))
        s2[[max_v, min_v]] = [mu, s2[max_v] + s2[min_v] - mu]
    return R

---

Observe que esse problema é completamente equivalente ao seguinte: considerando variáveis ​​não correlacionadas com variâncias , encontre uma rotação (isto é, uma nova base ortogonal) que produzirá variáveis ​​com variâncias iguais (mas é claro que não estão mais correlacionadas).$k$$\sigma_i^2$$k$

Em sua resposta perspicaz e abrangente, @amoeba mostrou - como parte da resposta - como é possível girar duas variáveis ​​não correlacionadas (como componentes principais, por exemplo) para obter as variações desejadas para elas (embora às custas de perder a falta de correlação, é claro) . Permita que as variáveis ​​ortogonais e tenham variações (um maior) e (um menor), respectivamente. Gire-os para que obtenha uma variação arbitrária e reduzida (enquanto , consequentemente, se tornará na variação ).$X$$Y$$\sigma^2_{max}$$\sigma^2_{min}$$X$$\mu^2$$Y$$\sigma^2_{max}+\sigma^2_{min}-\mu^2$

@amoeba mostra a fórmula a partir da qual podemos calcular o ângulo dessa rotação, :$\cos\theta$

$$\mu^2 = \cos^2\theta (\sigma^2_{max}) + \sin^2\theta (\sigma^2_{min})$$

mas não demonstrou de onde vem essa equação; provavelmente pensando que é óbvio sem explicação. Óbvio ou não, acredito que vale a pena elucidar - de alguma forma. Minha resposta apresenta uma maneira.

E assim, temos um elipsoidais, dados a nuvem centrada no espaço de variáveis não correlacionadas e . Temos que girar os eixos em ângulo . Um ponto de dados na nuvem (como mostrado como ponto verde na imagem) com a coordenada terá essa coordenada como após a rotação.$X$$Y$$\theta$$X$$x$$x^*$

Observe que a projeção da coordenada entalhe no eixo rotacionado é dada por (cateto como hipotenusa e ângulo entre eles). Observe também que é menor que pelo corte do comprimento calculável a partir da coordenada : (outro cateto e hipotenusa). E entao,$x$ $X^*$$x'=x\cos\theta$$x^*$$x'$$x'-x^*$$y$$y\sin\theta$

$$x^* = x' - (x'-x^*) = x\cos\theta-y\sin\theta$$

Conhecemos (veja o início) as variações (ou soma de quadrados) das duas variáveis ​​e a variação (soma de quadrados) de . Então segue:$\mu^2$$X^*$

$$\mu^2=\sum x^{*2} = \sum(x\cos\theta-y\sin\theta)^2 = \sum(x^2\cos^2\theta+y^2\sin^2\theta-2xy\cos\theta\sin\theta) = \cos^2\theta\sum x^2 + \sin^2\theta\sum y^2 - \underbrace{ 2\cos\theta\sin\theta\sum xy}_{\text{=0 (X and Y are uncorrelated)}} = \cos^2\theta (\sigma^2_{max}) + \sin^2\theta (\sigma^2_{min})$$

A partir da qual você estima , como @amoeba mostrou, e executa a rotação.$\cos\theta$

Se eu interpreto as coisas corretamente, você quer dizer que o primeiro componente do princípio (valor próprio) explica a maior parte da variação nos dados. Isso pode acontecer quando seu método de compactação é linear. No entanto, pode haver dependências não lineares no espaço de recursos.

TL / DR: PCA é um método linear. Use Autoencoders (pca não linear) para redução de dimensionalidade. Se a parte do aprendizado de máquina for supervisionada, basta monitorar sua função de perda enquanto ajusta os (hiper) parâmetros para o autoencoder. Dessa forma, você terá uma versão compactada muito melhor dos seus dados originais.

Aqui está um exemplo de scikit em que eles pesquisam em grade para encontrar o número ideal de componentes principais a serem mantidos (hiperparâmetro) usando o PCA. Finalmente, eles aplicam a regressão logística no espaço dimensional inferior: http://scikit-learn.org/stable/auto_examples/plot_digits_pipe.html#example-plot-digits-pipe-py

Protip: os codificadores automáticos não têm uma solução de formulário fechado (afaik); portanto, se o seu contexto estiver transmitindo dados, isso significa que você pode atualizar continuamente seu codificador automático (representação compactada) e, assim, compensar itens como desvio de conceito. Com o pca, você precisa treinar novamente o modo em lote de vez em quando à medida que novos dados são recebidos.

Quanto a dar a alguns recursos mais "peso", consulte a regularização (eu começaria a partir das normas https://en.wikipedia.org/wiki/Norm_(mathematics) ). Você também pode se surpreender com a regressão logística semelhante ao perceptron.