Gire los componentes de PCA para igualar la varianza en cada componente

Estoy tratando de reducir la dimensionalidad y el ruido de un conjunto de datos al realizar PCA en el conjunto de datos y descartar las últimas PC. Después de eso, quiero usar algunos algoritmos de aprendizaje automático en las PC restantes y, por lo tanto, quiero normalizar los datos igualando la varianza de las PC para que los algoritmos funcionen mejor.

Una forma simple es simplemente normalizar la varianza a los valores unitarios. Sin embargo, la primera PC contiene más variaciones del conjunto de datos original que las siguientes, y todavía quiero darle más "peso". Por lo tanto, me preguntaba: ¿hay una manera simple de dividir su variación y compartirla con las PC con menos variaciones?

Otra forma es mapear las PC al espacio de características original, pero en ese caso la dimensionalidad también aumentaría al valor original.

Supongo que es mejor mantener las columnas resultantes ortogonales, pero no es necesario en este momento.

Para mí no está completamente claro que lo que está preguntando es lo que realmente necesita: un paso de preprocesamiento común en el aprendizaje automático es la reducción de dimensionalidad + blanqueamiento, lo que significa hacer PCA y estandarizar los componentes, nada más. Sin embargo, me centraré en su pregunta, ya que está formulada, porque es más interesante.

---

Sea la matriz de datos n × d centrada con puntos de datos en filas y variables en columnas. PCA equivale a la descomposición de valores singulares X = U S V ⊤ ≈ U k S k V ⊤ k , donde para realizar la reducción de dimensionalidad solo conservamos k componentes. Un "factor de rotación" ortogonal de estos componentes implica elegir una matriz ortogonal k × k R y conectarla a la descomposición: X ≈ U k S k $\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$Aquí $$\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}.$$ son componentes estandarizados rotados y el segundo término representa cargas rotadas transpuestas. La varianza de cada componente después de la rotación viene dada por la suma de cuadrados del vector de carga correspondiente; antes de la rotación es simplementes 2 i /(n-1). Después de la rotación es otra cosa.$\sqrt{n-1}\mathbf U_k \mathbf R$$s_i^2/(n-1)$

Ahora estamos listos para formular el problema en términos matemáticos: dadas cargas no rotadas , encuentre la matriz de rotaciónRtal que las cargas rotadas,LR, tengan la misma suma de cuadrados en cada columna.$\mathbf L = \mathbf V_k \mathbf S_k / \sqrt{n-1}$$\mathbf R$$\mathbf L \mathbf R$

Vamos a resolverlo Las sumas de cuadrados de la columna después de la rotación son iguales a los elementos diagonales de Esto tiene sentido: la rotación simplemente redistribuye las variaciones de los componentes, que originalmente se dan pors 2 i /(n-1), entre ellos, de acuerdo con esta fórmula. Necesitamos redistribuirlos para que todos sean iguales a su valor promedioμ.

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

No creo que haya una solución de forma cerrada para esto, y de hecho hay muchas soluciones diferentes. Pero una solución se puede construir fácilmente de manera secuencial:

1. Tome el primer componente y el componente -ésimo. El primero tiene la varianza σ max > μ y el último tiene la varianza σ min < μ .$k$$\sigma_\text{max}>\mu$$\sigma_\text{min}<\mu$
2. Gire solo estos dos de modo que la varianza del primero sea igual a . Matriz de rotación en 2D sólo depende de un parámetro θ y es fácil de escribir la ecuación y calcular la necesaria θ . De hecho, R 2D = ( cos θ sen θ - sin θ cos θ ) y después de la transformación, la primera PC obtendrá varianza cos 2 θ ⋅ σ max + sin 2 θ ⋅ σ min = cos 2 θ ⋅ $\mu$$\theta$$\theta$ $$\mathbf R_\text{2D} = \left(\begin{array}{cc}\cos \theta & \sin \theta \\ -\sin\theta & \cos \theta\end{array}\right)$$ de donde obtenemos inmediatamente cos 2 θ = μ - σ $$\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. El primer componente ya está hecho, tiene una varianza .$\mu$
4. Continúe con el siguiente par, tomando el componente con la varianza más grande y el que tiene la varianza más pequeña. Ir a # 2.

Esto redistribuirá todas las variaciones por igual por una secuencia de rotaciones 2D. Multiplicar todas estas matrices de rotación juntas producirá la R general .$(k-1)$$\mathbf R$

---

Ejemplo

Considere la siguiente matriz : ( 10 0 0 0 0 6 0 0 0 0 3 0 0 0 0 1 ) . La varianza media es 5 . Mi algoritmo procederá de la siguiente manera:$\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. $5$$1+(10-5)=6$

2. $5$$3+(6-5)=4$

3. $5$$4+(6-1)=5$

4. Hecho.

Escribí el script de Matlab que implementa este algoritmo (ver más abajo). Para esta matriz de entrada, la secuencia de ángulos de rotación es:

48.1897   35.2644   45.0000

Desviaciones de componentes después de cada paso (en filas):

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

La matriz de rotación final (producto de tres matrices de rotación 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

$(\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

Aquí está el 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

Aquí está el código en Python proporcionado por @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

---

$k$$\sigma_i^2$$k$

$X$$Y$$\sigma^2_{max}$$\sigma^2_{min}$$X$$\mu^2$$Y$$\sigma^2_{max}+\sigma^2_{min}-\mu^2$

$\cos\theta$

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

pero no ha demostrado de dónde viene esta ecuación; Probablemente pensando que es obvio sin explicación. Obvio o no, creo que vale la pena dilucidar, de alguna manera. Mi respuesta se presenta de una manera.

$X$$Y$$\theta$$X$$x$$x^*$

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

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

$\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})$$

$\cos\theta$

Si interpreto las cosas correctamente, quiere decir que el primer componente principal (valor propio) explica la mayor parte de la varianza en los datos. Esto puede suceder cuando su método de compresión es lineal. Sin embargo, puede haber dependencias no lineales en su espacio de características.

TL / DR: PCA es un método lineal. Use Autoencoders (pca no lineal) para la reducción de dimensionalidad. Si la parte de aprendizaje automático es aprendizaje supervisado, simplemente controle su función de pérdida mientras ajusta los parámetros (hiper) para el codificador automático. De esta manera, obtendrá una versión comprimida mucho mejor de sus datos originales.

Aquí hay un ejemplo de scikit donde hacen una búsqueda de cuadrícula para encontrar el número óptimo de componentes principales para mantener (hiperparámetro) usando PCA. Finalmente, aplican la Regresión logística en el espacio dimensional inferior: http://scikit-learn.org/stable/auto_examples/plot_digits_pipe.html#example-plot-digits-pipe-py

Protip: los codificadores automáticos no tienen una solución de forma cerrada (afaik), por lo que si su contexto está transmitiendo datos, esto significa que puede actualizar continuamente su codificador automático (representación comprimida) y, por lo tanto, puede compensar cosas como la deriva del concepto. Con pca, debe volver a entrenar el modo por lotes de vez en cuando a medida que ingresan nuevos datos.

En cuanto a dar algunas características más "peso", vea la regularización (comenzaría por las normas https://en.wikipedia.org/wiki/Norm_(mathematics) ). También te sorprenderá cuán similar es la regresión logística al perceptrón.