martes, junio 25, 2024
No menu items!
InicioBlogsPCA vs ICA: ¿Diferencia?

PCA vs ICA: ¿Diferencia?

Aquí encontrará todo sobre la diferencia entre PCA e ICA:

PCA intenta encontrar componentes mutuamente ortogonales, mientras que en ICA los componentes pueden no ser ortogonales.

ICA busca componentes mutuamente independientes. PCA intenta maximizar la variación de la señal de entrada junto con los componentes principales, mientras que ICA minimiza la información mutua en los componentes encontrados.

Entonces, si desea aprender todo sobre en qué se diferencian exactamente PCA e ICA, entonces está en el lugar correcto.

¡Vamos a sumergirnos de lleno!

PCA vs ICA: ¿Diferencia?  (Ejemplos de codificación)

¿Cuáles son los conceptos básicos de PCA e ICA?

PCA (Análisis de componentes principales) e ICA (Análisis de componentes individuales) se basan en principios similares, pero aún así son diferentes.

No es fácil comprender de inmediato todas las fórmulas que se dan al describir los métodos PCA e ICA.

Las matemáticas son una ciencia hermosa, pero es necesario ir paso a paso para comprender esta belleza; es casi imposible saltar varios pasos a la vez.

A menudo es necesario investigar primero un método concreto con un ejemplo sencillo para poder formarse una imagen en la cabeza, que se puede ampliar a casos más complejos.

Esto es especialmente cierto en el caso de espacios multidimensionales como los conceptos de PCA e ICA.

El cerebro humano no puede imaginar un espacio n-dimensional para n > 3.

Veremos ejemplos simples de aplicaciones PCA e ICA e intentaremos comprender los principios básicos detrás de estos métodos.

Comencemos planteando un problema para la PCA:

¿Qué es PCA y cómo implementarlo en Python?

Mujer escribiendo en su cuaderno mientras mira la pantalla del portátil.

Si hablamos de análisis de datos, lo más probable es que utilice matrices de características multidimensionales.

Estas matrices, por cierto, se denominan tensores.

A menudo sucede que la dimensión de estos datos es redundante. Por ejemplo, una cantidad puede depender directamente de otra.

Digamos que puedes calcular los metros cuadrados de un apartamento a partir de los metros cuadrados de un apartamento.

Esto significa que no necesitamos utilizar ambos valores en el análisis; puede descartar uno de los valores (pies cuadrados o metros cuadrados) en su análisis.

En este caso, la correlación entre los valores es igual a uno; eso significa que están estrictamente relacionados.

Pero puede haber conexiones más débiles: por ejemplo, el tiempo de aceleración de un automóvil de 0 a 100 mph depende del tamaño del motor, pero no lo determina directamente.

También hay otros factores, como el peso y la aerodinámica del vehículo, el diseño del motor y más.

Si conocemos las fórmulas exactas para las dependencias, entonces podemos reducir la cantidad de factores estimados y fusionarlos en uno solo.

Pero, por supuesto, la mayoría de las veces estas dependencias no son tan evidentes ni difíciles de encontrar.

Sin embargo, algunos métodos pueden reducir la dimensión del conjunto de características para el análisis.

Uno de estos métodos es PCA.

Le permite seleccionar componentes de una variedad de características y evaluar cómo este o aquel componente afecta en qué medida los objetos reales descritos por las características estudiadas se diferenciarán entre sí.

Consideremos un ejemplo sintético que mostrará cómo funciona PCA.

Puede haber muchas implementaciones de PCA diferentes.

Modelaremos el más simple.

Para empezar, tomemos dos valores, dependerán uno del otro linealmente, pero además introduciremos un pequeño ruido aleatorio.

Estandaricemos también los valores.

Reste el valor esperado de cada valor y divídalo por la desviación estándar:

ica-vs-pca-20

%matplotlib importación en línea matplotlib.pyplot como plt importar sklearn.decomposition como deco plt.style.use(&39;seaborn-whitegrid&39;) importar numpy como np x = np.linspace(1, 30, 100) y = x + np.random .randn(100) xnorm = (x np.mean(x)) / np.std(x) ynorm = (y np.mean(y)) / np.std(y) X = np.vstack(( xnorma, ynorma))

Transfiramos los puntos al gráfico:

plt.plot(X[0]X[1]o)

ica-vs-pca-1

El gráfico muestra claramente exactamente lo que ponemos en la estructura de los datos, la dependencia del parámetro y de x:

🔥 Leer:  ¿Podemos esperar que The Last of Us Part 3 se lance: posible fecha de lanzamiento?

plt.plot(X[0]X[1]o) plt.plot([-2,2], [-2,2])

ica-vs-pca-2

Con la ayuda de PCA, podemos encontrar un nuevo rasgo que será una combinación de los dos.

Naturalmente, al reemplazar dos funciones por una, se perderá parte de la información.

La tarea del algoritmo es minimizar estas pérdidas.

En este caso, obviamente puedes utilizar la proyección de puntos sobre la recta x1 = x2.

Es en esta línea donde la difusión de datos es máxima.

Usamos una matriz de covarianza para estimar la dependencia de dos vectores.

La covarianza se define generalmente como una medida de la dependencia de dos variables aleatorias:

ica-vs-pca-21

Donde E es el operador de expectativa. Entonces, centramos los vectores: restamos la expectativa matemática del vector de cada valor y luego encontramos su producto interno.

El producto escalar en el espacio euclidiano se define como el producto de las longitudes de los vectores por el coseno del ángulo entre ellos.

Si los vectores son ortogonales, entonces el coseno del ángulo será 0.

En consecuencia, al calcular el producto escalar, buscamos en qué medida los vectores no coinciden en dirección.

Las varianzas de los valores correspondientes se ubican a lo largo del eje principal de la matriz de covarianza. Es fácil encontrar la matriz de covarianza en Python.

Para las señales, será así:

covarianza = np.cov(X) print(covarianza)
[[1.01010101 1.00366207]
[1.00366207 1.01010101]]

¿Cómo será la matriz de covarianza?

Se verá diagonal.

Aparte de la diagonal principal, el resto de valores serán cero.

Simplemente estamos tratando de encontrar esa base, es decir, necesitamos diagonalizar la matriz de covarianza.

Esto es fácil de hacer con descomposición propia.

Podemos representar cualquier matriz cuadrada de filas linealmente independientes como:

ica-vs-pca-22

Dónde q es una matriz que consta de vectores propios, y Λ es una matriz diagonal, cuyos elementos a lo largo de la diagonal principal son iguales a los valores propios de la matriz Ay los demás elementos son iguales a .

Por lo tanto, para encontrar una nueva base (vectores a lo largo de los cuales la dependencia será mínima), debemos encontrar los vectores propios de la matriz de covarianza.

Y eso también es fácil de hacer con el módulo NumPy:

valores propios, vectores propios = np.linalg.eigh(covarianza) print(vectores propios) print(valores propios)
[[-0.70710678 0.70710678]
[ 0.70710678 0.70710678]]imprimir (valores propios)
[0.00642988 2.01377214]

Los propios vectores están ubicados en las columnas de la matriz resultante. Seleccionemos el primer y segundo vector propio para la matriz de covarianza:

ev1 = vectores propios[:, 0]
ev2 = vectores propios[:, 1]

Podemos comprobar que efectivamente son vectores propios por definición.

El producto de una matriz por un vector propio debe ser igual al producto de un valor propio por el mismo vector:

print(covarianza @ ev1) print(valores propios[0] *ev1)
[-0.00455302 0.00455302]
[-0.00455302 0.00455302]

print(covarianza @ ev2) print(valores propios[1] *ev2)
[1.42394553 1.42394553]
[1.42394553 1.42394553]

Como puedes ver, el resultado es idéntico.

Intentemos trazar los vectores junto con el conjunto de datos para asegurarnos de que realmente encontramos las direcciones correctas:

plt.plot(X[0]X[1]o) plt.flecha(0, 0, ev1[0] * valores propios[0] * 10, ev1[1] * valores propios[0] * 10, color = r, ancho = 0.01) plt.arrow(0, 0, ev2[0] * valores propios[1]ev2[1] * valores propios[1]color = b, ancho = 0.01) plt.show()

ica-vs-pca-3

Dibujamos los vectores no a escala porque los valores propios en el ejemplo difieren en 4 órdenes de magnitud.

Pero vemos que tenemos dos vectores ortogonales, uno de los cuales está dirigido hacia la máxima dependencia y el otro es perpendicular a ella.

Para obtener los nuevos valores de coordenadas, sólo tenemos que multiplicar la matriz de vectores propios por la matriz de características original:

X_nuevo = vectores propios @ X

Ahora encontremos la desviación estándar de las dos nuevas características:

imprimir(np.std(X_nuevo[0])) imprimir(np.std(X_nuevo[1])) 0,07984079617577441 1,4119580189460372

La desviación estándar a lo largo del eje del vector rojo es 17 veces menor que a lo largo del azul. Podemos descartar toda la columna y usar solo una. X_nuevo [1] en lugar de dos características x1 y x2.

De hecho, resulta que estamos reemplazando los puntos azules por puntos verdes:

🔥 Leer:  CSM frente a UEFI: ¿cuál es la diferencia?

plt.plot(X[0]X[1]o) plt.plot([-2,2], [-2,2]) plt.plot(X_nuevo[1] /np.sqrt(2), X_nuevo[1] /np.sqrt(2), o)

ica-vs-pca-4

Por supuesto, hay pérdidas, pero en muchos casos pueden pasarse por alto.

Es posible calcular la pérdida de información evaluando la relación entre los valores propios que quedan y los que descartamos.

En general, PCA le permite transformar n funciones en metrodónde metro << norte.

Para tareas prácticas, es más conveniente utilizar implementaciones ya preparadas.

Por ejemplo, podemos tomar el modelo PCA del módulo sklearn.decomposition:

de sklearn.decomposition importar PCA incremental X = np.stack((xnorm, ynorm), eje = 1) pca = deco.PCA(1) xt = pca.fit_transform(X) print(xt.shape) (100, 1)

Pasamos un parámetro al deco.PCA función-metrola nueva cantidad de funciones que queremos conservar.

Como resultado, obtenemos una serie de funciones nuevas, algunas de las cuales se descartan automáticamente de acuerdo con el parámetro especificado.

Podemos comparar las características calculadas por el método y la función terminada de aprender:

printzip(* (xt.reshape(100), X_nuevo[1])) (-2.378511170140015, -2.3785111701400123) (-2.4911929631729186, -2.4911929631729177) (-2.172690411576331, -2.1726904115763306 ) (-2.321844756744973, -2.3218447567449725) ( -2.213965105057678, -2.213965105057677) (-2.0648350319020237, -2.0648350319020228)

La salida se trunca a los primeros 6 pares de números. Como puede ver, coinciden con el error de redondeo.

¿Qué es ICA y cómo implementarlo en Python?

Se puede oír hablar de ICA con mayor frecuencia como una forma de resolver el problema de la separación de fuentes ciegas.

Este problema también se denomina problema del cóctel.

Imagina que estás en una fiesta donde se desarrollan varios diálogos al mismo tiempo.

Hay bastante ruido a tu alrededor, pero aún puedes comunicarte con el interlocutor, el oído y el cerebro humanos resuelven con éxito este problema y aíslan la señal significativa del ruido general.

La solución a este problema no es tan sencilla matemáticamente:

Imaginemos que tenemos 3 fuentes de señal y varios micrófonos que graban una combinación lineal de señales.

El número de micrófonos no debe ser menor que el número de fuentes de señal. De lo contrario, la tarea quedará indefinida.

Además, para que la tarea tenga sentido, las señales deben cumplir dos requisitos:

  • Las fuentes de señal son independientes entre sí;
  • Los valores de cada una de las fuentes tienen una distribución no gaussiana.

Las fuentes de señal son independientes, pero sus mezclas, por supuesto, no lo son, ya que cada una de las mezclas depende de todas las fuentes.

Pero cuantas más fuentes tengamos, más cercana será la distribución de cada señal mixta a la gaussiana.

Aquí es donde se basa la separación; Intentaremos aislar la mayoría de los componentes no gaussianos de las señales mixtas.

En cualquier implementación del algoritmo ICA, podemos distinguir tres etapas:

  • Centrar (restando la media y creando una media cero para la señal)
  • Eliminación de la correlación (generalmente utilizando la descomposición espectral de la matriz)
  • Reducir la dimensión para simplificar el problema.

Si intentamos comparar PCA e ICA usando el ejemplo anterior, obtenemos algo como esto. Tomemos una señal mixta:

ica-vs-pca-5

PCA encontrará el vector en cuya dirección la varianza es máxima.

ica-vs-pca-6

ICA encontrará vectores correspondientes a las señales mixtas.

Este ejemplo es sintético.

Debe comprender que la limitación de ICA es que no puede restaurar el orden de las señales originales, así como su amplitud real.

Pero esto no supone un problema para tareas como dividir señales de audio, por ejemplo.

Intentemos mezclar y dividir dos imágenes de desempaquetar:

desde matplotlib importar imagen s1 = image.imread(s1.jpg) s2 = image.imread(s2.jpg) plt.imshow(s1)

ica-vs-pca-7

plt.imshow(s2)

ica-vs-pca-8

Cree imágenes combinadas y normalícelas para que los valores de brillo permanezcan dentro del rango 0…255:

m1 = 0,6 * s1 + 0,4 * s2 m2 = 0,3 * s1 + 0,7 * s2 norma = lambda x: (x * 255 / np.max(x)).astype(np.uint8) m1 = norma(m1) m2 = norma(m2) plt.imshow(m1)

ica-vs-pca-9

plt.imshow(m2)

ica-vs-pca-10

Como puede ver, estas imágenes combinadas son similares a si estuviera mirando algo a través del cristal y viera en parte la imagen detrás del cristal y en parte la imagen reflejada.

Nuestra tarea ahora es encontrar la matriz W. De modo que multiplicar esta matriz por la matriz de entrada de señales mixtas nos dará aproximadamente la matriz de las señales independientes originales:

🔥 Leer:  Los teléfonos heredados con Nokia 7.2, 6.2 y más se lanzarán oficialmente antes de IFA 2019
ica-vs-pca-23

Podemos resolver este problema a través de SVD (Valor singular de descomposición). Representamos la matriz deseada como:

ica-vs-pca-24

Dónde Σ es una matriz diagonal, que se puede representar como una matriz de estiramiento (escalado), y la Ud. y V las matrices son matrices de rotación.

Puedes escribir una matriz de rotación de esta manera: esta matriz rotará un vector durante un ángulo θ al multiplicar:

ica-vs-pca-25

Así, podemos representar la multiplicación por la matriz W en 3 etapas:

ica-vs-pca-26

Ahora implementémoslo en Python. La derivación de fórmulas no se describe en detalle. Puedes verlos en el fuente.

Encontrar θ y ver su valor en grados:

theta0 = 0.5 * np.arctan(-2 * np.sum(m1 * m2) / np.sum(m1 ** 2 m2 **2)) theta0 * 180 / np.pi -31.781133720821153

Encontrar más matriz transpuesta Ud.:

Nosotros = np.matriz([ [np.cos(theta0), np.sin(theta0)], [-np.sin(theta0), np.cos(theta0)] ]) Nosotros matriz([[ 0.85006616, -0.52667592],
[ 0.52667592, 0.85006616]])

y la matriz Σ:

sigma1 = np.sum( (m1 * np.cos(theta0) + m2 * np.sin(theta0) ) ** 2) sigma2 = np.sum( (m1 * np.cos(theta0 np.pi / 2) + m2 * np.sin(theta0 np.pi/2) ) ** 2) Sigma = np.array([ [1/np.sqrt(sigma1), 0], [0, 1/np.sqrt(sigma2)] ]) Matriz sigma([[9.39029733e-06, 0.00000000e+00],
[0.00000000e+00, 2.15484602e-06]])

Multipliquemos las señales mixtas por las matrices conocidas. Ud. y Σ y calcula el angulo φ:

x1bar = Sigma[0][0] * (A nosotros[0][0] * m1 + Nosotros[0][1] * m2) x2bar = Sigma[1][1] * (A nosotros[1][0] * m1 + Nosotros[1][1] * m2) suma1 = np.sum(2 * (x1bar ** 3) * x2bar 2 * (x2bar ** 3) * x1bar) suma2 = np.sum(3 * (x1bar ** 2)* (x2bar ** 2) 0,5* (x1bar ** 4) 0,5 * (x2bar ** 4)) tmp1 = -sum1 / sum2 phi0 = 0,25 * np.arctan(tmp1) phi0 * 180 / np.pi -1,7576366868809685

formar la matriz V:

V = np.matriz ([ [np.cos (phi0), np.sin (phi0)],
[-np.sin (phi0), np.cos (phi0)] ]) matriz V([[ 0.99952951, -0.03067174],
[ 0.03067174, 0.99952951]])

Calculemos los valores de la señal, normalicémoslos y visualicemos las imágenes en la pantalla:

s1sombrero = V[0][0] * x1bar + V[0][1] * x2bar s2sombrero = V[1][0] * x1bar + V[1][1] * x2bar s1hat = norma(s1hat).astype(np.uint8) s2hat = norma(s2hat).astype(np.uint8) plt.imshow(s1hat)

ica-vs-pca-11

plt.imshow(s2hat)

ica-vs-pca-12

Como puede ver, las imágenes se recuperaron bastante bien. Aunque no es perfecto, puedes ver el ruido y los contornos de imágenes pasadas.

¿Cuáles son las similitudes y diferencias entre PCA e ICA?

Hemos analizado las implementaciones de Python de PCA e ICA.

Ahora hablemos un poco de las similitudes y diferencias:

Similitudes:

  • Ambos métodos son transformaciones estadísticas.
  • Ambos se utilizan ampliamente en diversos problemas aplicados, a menudo incluso en los mismos.
  • Ambos métodos encuentran nuevas bases para representar datos de entrada.
  • En ambos casos, consideramos que las características observadas son una combinación lineal de ciertas características ocultas.
  • Ambos métodos suponen que los componentes son independientes y tienen una distribución no gaussiana.

Diferencias:

  • PCA intenta encontrar componentes mutuamente ortogonales; en ICA los componentes pueden no ser ortogonales. ICA busca componentes mutuamente independientes
  • PCA intenta maximizar la variación de la señal de entrada junto con los componentes principales, ICA minimiza la información mutua en los componentes encontrados.
  • Las características obtenidas en el PCA están en estricto orden de más a menos significativas. Por lo tanto, podemos descartar algunas de las características para reducir la dimensión. Los componentes obtenidos en ICA son fundamentalmente desordenados y equivalentes. No podemos ordenarlos.

¿Qué son las aplicaciones ICA y PCA?

Puede utilizar ICA para eliminar varios tipos de ruido.

Incluyendo ruido en la imagen, así como la eliminación de ciertos objetos del conjunto de datos de entrada.

Por ejemplo, puede eliminar el parpadeo de los datos del electroencefalograma. ICA también se utiliza para el análisis de series de tiempo para identificar tendencias.

Esto se puede aplicar para predecir precios en el mercado de valores o analizar tendencias en publicaciones en redes sociales.

Los datos de reducción con PCA se pueden utilizar para visualizar datos.

No se pueden trazar puntos en un espacio de diez dimensiones en el plano bidimensional de la pantalla.

PCA también se puede utilizar para comprimir vídeos e imágenes.

Puede utilizar PCA para suprimir el ruido en las imágenes.

PCA también se usa ampliamente en:

  • Bioinformática
  • Quimiometría
  • Econometría
  • Psicodiagnóstico
Recomendamos

Populares