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.

variance pca factor-rotation Feilong
fuente

No ... varimax maximiza la suma de las desviaciones cuadradas de las cargas, por lo que intenta hacerlas lo más desiguales posible. Además, ¿por qué quieres ecualizar los componentes? El objetivo es capturar tanta variación como sea posible en la menor cantidad de componentes posible.

¿Simplemente no le conviene estandarizar las puntuaciones de los componentes a las variaciones de unidades? ¿Porqué entonces? ¿Qué tipo de resultado desea? ¿Deberían las columnas resultantes no estar correlacionadas además de las variaciones iguales?

ttnphns

A partir de su descripción, se parece mucho a que quiere simplemente "esferas" de los datos (de dimensionalidad reducida). Con frecuencia se realiza como un paso de preprocesamiento en el aprendizaje automático. Para lograrlo, simplemente realiza PCA, elige algunos componentes y los estandariza. Supongo que es posible encontrar una rotación ortogonal (como varimax) que rote los componentes estandarizados de manera que no estén correlacionados pero expliquen exactamente la misma cantidad de varianza; esa es una pregunta interesante, tengo que pensarlo. Pero nunca he visto esto hecho, definitivamente no en el aprendizaje automático.

ameba

Por cierto, ¿cuáles son "algunos algoritmos de aprendizaje automático" que desea aplicar después de PCA? Esto puede ser relevante.

ameba

Tenga en cuenta que si gira sus PC estandarizadas, ¡las distancias no cambiarán en absoluto! Por lo tanto, realmente no debería importar ningún algoritmo posterior basado en la distancia.

ameba

Respuestas:

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 centrada con puntos de datos en filas y variables en columnas. PCA equivale a la descomposición de valores singulares donde para realizar la reducción de dimensionalidad solo conservamos componentes. Un "factor de rotación" ortogonal de estos componentes implica elegir una matriz ortogonal y conectarla a la descomposición: $\mathbf X$ $n\times d$

X = {U S V}^{⊤} \approx U_{k} S_{k} V_{k}^{⊤},

$\mathbf X = \mathbf{USV}^\top \approx \mathbf U_k \mathbf S_k \mathbf V_k^\top,$

k

$k$

k \times k

$k \times k$

R

$\mathbf R$

Aquí

X \approx U_{k} S_{k} V_{k}^{⊤} = U_{k} {R R}^{⊤} S_{k} V_{k}^{⊤} = \underset{\begin{matrix} Rotado \\ puntajes estandarizados \end{matrix}}{\underset{⏟}{\sqrt{norte - 1} U_{k}^{} R}} \cdot \underset{{Cargas rotadas}^{⊤}}{\underset{⏟}{R^{⊤} S_{k} V_{k}^{⊤} / / \sqrt{norte - 1}}} .

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

. Después de la rotación es otra cosa.

\sqrt{n - 1} U_{k} R

$\sqrt{n-1}\mathbf U_k \mathbf R$

s_{i}^{2} / (n - 1)

$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óntal que las cargas rotadas,, 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 por, entre ellos, de acuerdo con esta fórmula. Necesitamos redistribuirlos para que todos sean iguales a su valor promedio.

(L R)^{⊤} L R = R^{⊤} \frac{S^{2}}{norte - 1} R .

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

Tome el primer componente y el componente -ésimo. El primero tiene la varianza y el último tiene la varianza . $k$ $\sigma_\text{max}>\mu$ $\sigma_\text{min}<\mu$
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, y después de la transformación, la primera PC obtendrá varianza $\mu$ $\theta$ $\theta$ $R_{2D} = (\begin{array}{cc} \cos θ & pecado θ \\ - pecado θ & \cos θ \end{array})$ $\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} θ \cdot σ_{max} + {pecado}^{2} θ \cdot σ_{min} = \cos^{2} θ \cdot σ_{max} + (1 - \cos^{2} θ) \cdot σ_{min} = μ,$ $\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} θ = \frac{μ - σ_{min}}{σ_{max} - σ_{min}} .$ $\cos^2\theta = \frac{\mu-\sigma_\text{min}}{\sigma_\text{max}-\sigma_\text{min}}.$
El primer componente ya está hecho, tiene una varianza . $\mu$
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 general . $(k-1)$ $\mathbf R$

Ejemplo

Considere la siguiente matriz : La varianza media es . Mi algoritmo procederá de la siguiente manera: $\mathbf S^2/(n-1)$

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

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

5

$5$

$5$ $1+(10-5)=6$
$5$ $3+(6-5)=4$
$5$ $4+(6-1)=5$
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$

ameba
fuente

Supongo que, para dos pares de componentes (sus puntajes), el ángulo de rotación sería de 45 grados, para igualar sus variaciones. Sin embargo, no puedo imaginar cómo hacer toda la tarea con más de 3 componentes emparejados sabiamente.

ttnphns

@feilong, creo que igualar la varianza de un par de componentes a la vez es un algoritmo muy subóptimo. Lo que sugerí es elegir las rotaciones de modo que la varianza de un componente se vuelva exactamente igual a la varianza media global. Entonces este componente está "listo", y uno puede ocuparse del resto. Esto garantiza igualar todas las variaciones en un número finito de pasos. Vea mi comentario anterior para un ejemplo.

ameba

@amoeba Tienes razón, esa es una mejor solución y debería terminar con n-1 pasos.

feilong

@amoeba He agregado mi implementación mínima usando Python. Modifiqué la parte multiplicando toda la matriz, ya que puede llevar mucho tiempo para matrices grandes.

feilong

@amoeba Específicamente para componentes principales, es posible ahorrar más tiempo al eliminar la pieza buscando el máximo y el mínimo. Simplemente podemos rotar los componentes primero y segundo (para hacer que el primer componente tenga una varianza promedio), y luego el segundo y el tercero, y así sucesivamente. Solo necesitamos asegurarnos de que la varianza total de cada par sea mayor que mu.

feilong

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

$\cos\theta$

μ^{2} = \cos^{2} θ (σ_{m a x}^{2}) + \sin^{2} θ (σ_{m i n}^{2})

$\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 θ - y pecado θ

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

$\mu^2$ $X^*$

μ^{2} = \sum X^{* 2} = \sum (X \cos θ - y pecado θ)^{2} = \sum (X^{2} \cos^{2} θ + y^{2} {pecado}^{2} θ - 2 X y \cos θ pecado θ) = \cos^{2} θ \sum X^{2} + {pecado}^{2} θ \sum y^{2} - \underset{= 0 (X e Y no están correlacionados)}{\underset{⏟}{2 \cos θ pecado θ \sum X y}} = \cos^{2} θ (σ_{metro una X}^{2}) + {pecado}^{2} θ (σ_{metro yo norte}^{2})

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

ttnphns
fuente

{(\begin{array}{cc} \cos θ & pecado θ \\ - pecado θ & \cos θ \end{array})}^{⊤} (\begin{array}{cc} σ_{max}^{2} & 0 0 \\ 0 0 & σ_{min}^{2} \end{array}) (\begin{array}{cc} \cos θ & pecado θ \\ - pecado θ & \cos θ \end{array}),

$\left(\begin{array}{cc}\cos \theta & \sin \theta \\ -\sin\theta & \cos \theta\end{array}\right)^\top \left(\begin{array}{cc} \sigma_\text{max}^2 & 0 \\ 0 & \sigma_\text{min}^2\end{array}\right) \left(\begin{array}{cc}\cos \theta & \sin \theta \\ -\sin\theta & \cos \theta\end{array}\right),$

ameba

Y creo que su explicación geométrica y el cálculo "directo" (sin matrices) es más fácil de entender y muy útil para desarrollar las intuiciones correctas.

ameba

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.

shuriken x azul
fuente

No veo cómo esto responde la pregunta del OP; su respuesta parece no estar relacionada con la pregunta.

ameba

Por lo tanto, me preguntaba: ¿hay una manera simple de dividir su variación y compartirla con las PC con menos variaciones? OP quiere hacer reducción de dimensionalidad. Ofrecí una alternativa para resolver su problema, ya que, en última instancia, lo que OP quiere no garantiza un mejor rendimiento a menos que se mida el rendimiento. Trabajar en espacios hilbert / espacios normados no garantiza mejores resultados. Medir el rendimiento conduce a mejores resultados.

shuriken x azul