Un conjunto de datos de alta dimensión es un conjunto de datos que tiene una gran cantidad de columnas (o variables). Tal conjunto de datos presenta muchos desafíos Matemáticas o computadoras. El objetivo es reducir las dimensiones con técnicas de reducción de dimensiones.
La buena noticia es que las variables (o las denominadas características) suelen estar correlacionadas: los datos de gran dimensión están dominados "superficialmente" por un pequeño número de variables simples.
Podemos encontrar un subconjunto de variables para representar el mismo nivel de información en los datos o transformar las variables en un nuevo conjunto de variables sin perder mucha información. Aunque la computación de alta potencia puede manejar de alguna manera datos de alta dimensión, en muchas aplicaciones todavía existe la necesidad de reducir la dimensionalidad de los datos originales.
El análisis de componentes principales (PCA) es probablemente la técnica más popular cuando se piensa en la reducción de dimensiones. En este artículo, comenzaré con PCA y luego presentaré otras técnicas de reducción de dimensiones. El código de Python se incluirá en cada técnica.
Los científicos de datos pueden utilizar técnicas de reducción de dimensiones para identificar anomalías. ¿Por qué? ¿No queremos simplemente reducir la dimensionalidad? La intuición radica en los propios valores atípicos. DMHawkins dijo: “Un valor atípico es una observación que se desvía tanto de otras observaciones que genera sospechas de que fue generada por un mecanismo diferente. Una vez que las dimensiones se reducen a menos dimensiones principales, se identifican los patrones y luego se revelan los valores atípicos.
Análisis de componentes principales PCA
La idea del análisis de componentes principales (PCA) es reducir la dimensionalidad de un conjunto de datos que consta de una gran cantidad de variables relacionadas mientras se retiene la mayor variación posible en los datos. PCA encuentra un conjunto de nuevas variables cuyas variables originales son solo sus combinaciones lineales. Las nuevas variables se denominan componentes principales (PC). Estos componentes principales son ortogonales: en un caso 3D, los componentes principales son perpendiculares entre sí. X no puede ser representado por Y o Y no puede ser representado por Z.
La siguiente figura muestra la intuición de PCA: "rota" los ejes para alinearse mejor con sus datos. El primer componente principal capturará la mayor parte de la variación en los datos, seguido por el segundo, tercero y así sucesivamente. Por lo tanto, los nuevos datos tendrán menos dimensiones.
Usemos el conjunto de datos del iris para ilustrar PCA:
# Use el conjunto de datos del iris para ilustrar PCA:
importar pandas como pd
dirección URL = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
# carga el conjunto de datos en Pandas DataFrame
df = pd.read_csv(url, nombres=['longitud del sépalo','ancho del sépalo','longitud del pétalo','ancho del pétalo','objetivo'])
df.cabeza()
Tenga en cuenta que este conjunto de datos de IRIS viene con la variable objetivo. En PCA, solo transforma las variables X sin la variable Y de destino.
Todas las variables deben estar en la misma escala antes de aplicar PCA, de lo contrario, una característica con valores grandes dominará el resultado.
A continuación, estoy usando StandardScaler en scikit-learn para estandarizar las características del conjunto de datos en la escala de la unidad (media = 0 y varianza = 1).
de sklearn.preprocessing importar StandardScaler
variables = ['longitud del sépalo', 'ancho del sépalo', 'longitud del pétalo', 'ancho del pétalo']
x = df.loc[:, variables].valores
y = df.loc[:,['objetivo']].valores
x = escalador estándar().fit_transform(x)
x = pd.DataFrame(x)
Hay cuatro características en los datos originales. Por lo tanto, PCA suministrará el mismo número de componentes principales.
de sklearn.descomposición importar PCA
pca = pca()
x_pca = pca.fit_transform(x)
x_pca = pd.DataFrame(x_pca)
x_pca.cabeza()
¿Cuáles son las varianzas explicadas por cada uno de los componentes principales? Utilice pca.explained_variance_ratio_ para devolver un vector de la varianza:
varianza_explicada = pca.ratio_varianza_explicada_
varianza_explicadamatriz ([0.72770452, 0.23030523, 0.03683832, 0.00515193])
Se muestra que el primer componente principal representa una varianza de 72.22 %, el segundo, tercero y cuarto representan una varianza de 23.9 %, 3.68 % y 0.51 % respectivamente. Podemos decir que 72.22 + 23.9 = 96.21% de información es capturada por el primer y segundo componente principal.
A menudo queremos mantener solo las características significativas y eliminar las insignificantes. Una regla general es mantener los principales componentes principales que capturan una gran varianza e ignorar los pequeños.
Podemos graficar los resultados usando los dos primeros componentes. Agreguemos la variable de destino y a los nuevos datos de x_pca:
x_pca['objetivo']=y
x_pca.columns = ['PC1','PC2','PC3','PC4','objetivo']
x_pca.cabeza()
El resultado muestra que los datos son separables en el nuevo espacio.
importar matplotlib.pyplot como plt
higo = plt. figura()
hacha = fig.add_subplot(1,1,1)
ax.set_xlabel('Componente principal 1')
ax.set_ylabel('Componente principal 2')
ax.set_title('PCA de 2 componentes')
objetivos = ['Iris-setosa', 'Iris-versicolor', 'Iris-virginica']
colores = ['r', 'g', 'b']
para objetivo, color en zip (objetivos, colores):
índicesParaMantener = x_pca['objetivo'] == objetivo
ax.dispersión(x_pca.loc[índicesParaMantener, 'PC1']
, x_pca.loc[índicesParaMantener, 'PC2']
, c = color
, s = 50)
hacha.leyenda(objetivos)
hacha.grid()
¿Cómo usamos PCA para detectar valores atípicos? Déjame darte la intuición. Después de la transformación, los puntos de datos "normales" se alinearán a lo largo de los vectores propios (nuevos ejes) con valores propios pequeños. Los valores atípicos están lejos de ser vectores propios con valores propios grandes. Por lo tanto, las distancias entre cada punto de datos y los vectores propios se convierten en una medida del valor atípico. Una gran distancia indica una anomalía.
Núcleo ACP (KPCA)
PCA aplica la transformación lineal, que es solo su limitación. KACP extiende PCA a la no linealidad. Primero mapea los datos originales en un espacio de características no lineales (generalmente de mayor dimensión) y luego aplica PCA para extraer los componentes principales de ese espacio. Esto se puede entender por la figura (B). El gráfico de la izquierda muestra que los puntos azul y rojo no se pueden separar mediante una transformación lineal. Pero si todos los puntos se proyectan en el espacio 3D, ¡el resultado se vuelve linealmente separable! Luego aplicamos PCA para separar los componentes.
¿De dónde viene la intuición? ¿Por qué la separación de componentes se vuelve más fácil en un espacio dimensional superior? Esto debe remontarse a la teoría de Vapnik-Chervonenkis (VC). Él dice que el mapeo en un espacio de dimensiones superiores a menudo proporciona un mayor poder de clasificación.
El siguiente código de Python crea una ruta circular que consta de puntos rojos y azules. Obviamente no hay forma de separar los puntos rojos y azules con una línea (separación lineal).
imprimir (__doc__)
importar numpy como np
importar matplotlib.pyplot como plt
de sklearn.decomposition importar PCA, KernelPCA
desde sklearn.datasets importar make_circlesnp.random.seed(0)
x, y = hacer_círculos(n_muestras=400, factor=.3, ruido=.05)plt.figure(figsize=(10,10))
plt.subplot(2, 2, 1, aspecto='igual')
plt.title("Espacio original")
rojos = y == 0
azules = y == 1plt.scatter(X[rojos, 0], X[rojos, 1], c="rojo",s=20, edgecolor='k')
plt.dispersión(X[azules, 0], X[azules, 1], c="azul",s=20, edgecolor='k')
plt.xlabel("$x_1$")
plt.ylabel("$x_2$")
Sin embargo, cuando proyectamos el círculo en un espacio dimensional superior y lo separamos usando PCA, ¡las observaciones de datos con respecto al primer y segundo componente principal son separables! A continuación se muestra el resultado de que los puntos se trazan contra los componentes principales primero y segundo. Dibujo una línea para separar los puntos rojos y azules.
En KernelPCA, especificamos kernel='rbf', que es la función de base radial o distancia euclidiana. Los RBF se usan comúnmente como el núcleo de las técnicas de aprendizaje automático, como la máquina de vectores de soporte (SVM).
kpca = KernelPCA(kernel=”rbf”, fit_inverse_transform=True, gamma=10)
X_kpca = kpca.fit_transform(X)
pca = pca()
X_pca = pca.fit_transform(X)plt.scatter(X_kpca[rojos, 0], X_kpca[rojos, 1], c=”rojo”,s=20, edgecolor='k')
plt.dispersión(X_kpca[azules, 0], X_kpca[azules, 1], c=”azul”,s=20, edgecolor='k')
x = np.linspace(-1, 1, 1000)
plt.plot(x, -0.1*x, estilo de línea='sólido')
plt.title(“Proyección por KPCA”)
plt.xlabel(r”1er componente principal en el espacio inducido por $\phi$”)
plt.ylabel(“2do componente”)
Si especificamos que el kernel es 'lineal' como el siguiente código (KernelPCA(kernel='linear'), se convierte en el PCA estándar con solo una transformación lineal, y los puntos rojo y azul no son separables.
kpca = KernelPCA(kernel=”lineal”, fit_inverse_transform=True, gamma=10)
X_kpca = kpca.fit_transform(X)
pca = pca()
X_pca = pca.fit_transform(X)plt.scatter(X_kpca[rojos, 0], X_kpca[rojos, 1], c=”rojo”,s=20, edgecolor='k')
plt.dispersión(X_kpca[azules, 0], X_kpca[azules, 1], c=”azul”,s=20, edgecolor='k')
x = np.linspace(-1, 1, 1000)
plt.plot(x, -0.1*x, estilo de línea='sólido')
plt.title(“Proyección por KPCA”)
plt.xlabel(r”1er componente principal en el espacio inducido por $\phi$”)
plt.ylabel(“2do componente”)
Análisis Discriminante Lineal LDA
El origen de LDA es diferente de PCA. PCA es un método de aprendizaje no supervisado que transforma la funcionalidad original en un conjunto de nuevas funcionalidades. No nos importa si el nuevo conjunto de funciones puede proporcionar el mejor poder de discriminación para la variable objetivo. Por el contrario, el Análisis Discriminante Lineal (LDA) busca preservar el mayor poder de discriminación posible para la variable dependiente, mientras proyecta la matriz de datos original en un espacio de menor dimensión.
LDA es un tipo de técnica de aprendizaje supervisado. Utiliza las clases de la variable dependiente para dividir el espacio de predictores en regiones. Todas las regiones deben tener límites lineales. De donde proviene el nombre lineal. El modelo predice que todas las observaciones en una región pertenecen a la misma clase de la variable dependiente.
LDA logra el objetivo anterior en tres pasos principales. Primero, calcula la separabilidad entre las diferentes clases de la variable dependiente, llamada varianza entre clases, como se muestra en (1) de la Figura LDA. En segundo lugar, calcula la distancia entre la media y las muestras de cada clase, denominada varianza intraclase, como se muestra en (2). Luego, construye el espacio de dimensión inferior con este criterio: maximizar la varianza interclase y minimizar la varianza intraclase.
La solución a este criterio es calcular los valores propios y los vectores propios. Los vectores propios resultantes representan las direcciones del nuevo espacio y los valores propios correspondientes representan la longitud de los vectores propios. Por lo tanto, cada vector propio representa un eje del espacio LDA y el valor propio representa la longitud de este vector propio.
Usaré el conjunto de datos "Calidad del vino tinto" para el concurso Kaggle. Este conjunto de datos tiene 11 variables de entrada y una variable de salida de "calidad".
importar matplotlib.pyplot como plt
de sklearn.descomposición importar PCA
de sklearn.discriminant_analysis import LinearDiscriminantAnalysis
vino = pd.read_csv('calidad-vino-rojo.csv')
vino.cabeza()
Para simplificar, agrupo la variable de salida en tres valores. vino['calidad2'] = np.where(vino['calidad']<=4,1, np.where(vino['calidad']<=6,2,3)).
El siguiente código ejecuta PCA y LDA.
X = vino.gota(columnas=['calidad','calidad2'])
y = vino['calidad2']
target_names = np.unique(y)
nombres_objetivospca = PCA(n_componentes=2)
X_r = pca.fit(X).transform(X)lda = AnálisisDiscriminanteLineal(n_componentes=2)
X_r2 = lda.fit(X, y).transform(X)
A continuación, grafique los resultados de PCA y LDA:
# Porcentaje de varianza explicada para cada componente
print('razón de varianza explicada (primeros dos componentes): %s'
% str(pca.explained_variance_ratio_))plt.figura()
colores = ['azul marino', 'turquesa', 'naranja oscuro']
lw = 2para color, i, target_name en zip(colores, target_names, target_names):
plt.dispersión(X_r[y == i, 0], X_r[y == i, 1], color=color, alfa=.8, lw=lw,
etiqueta=nombre_objetivo)
plt.legend(loc='mejor', sombra=Falso, puntos de dispersión=1)
plt.title('PCA del conjunto de datos WINE')plt.figura()
para color, i, target_name en zip(colores, target_names, target_names):
plt.dispersión(X_r2[y == i, 0], X_r2[y == i, 1], alfa=.8, color=color,
etiqueta=nombre_objetivo)
plt.legend(loc='mejor', sombra=Falso, puntos de dispersión=1)
plt.title('LDA del conjunto de datos WINE')plt.mostrar()
LDA es adecuado para un problema de clasificación multiclase.
Descomposición de valores singulares SVD
SVD es un método de síntesis de datos similar a PCA. Extrae características importantes de los datos. Pero hay otra ventaja de SVD: reconstruir el conjunto de datos original en un conjunto de datos pequeño. Por lo tanto, tiene amplias aplicaciones, como la compresión de imágenes. Por ejemplo, si tiene una imagen de 32*32 = 1024 píxeles, SVD puede resumirla en 66 píxeles. Los 66 píxeles pueden recuperar imágenes de 32*32 píxeles sin perder ninguna información importante.
SVD jugó un papel decisivo en el álgebra lineal, pero parece "no tan famoso como debería ser", como se indica en el libro de texto clásico "Álgebra lineal y sus aplicaciones" de Gilbert Strang. Para introducir correctamente SVD, es fundamental comenzar con la operación matricial. Si A es una matriz real simétrica n × n, existe una matriz ortogonal V y una diagonal D tales que
Las columnas V son vectores propios de A, y las entradas diagonales de D son los valores propios de A. Este proceso se llama descomposición de valores propios, o EVD, para la matriz A. Nos dice cómo elegir las bases ortonormales de para que la transformación está representado por una matriz. con la forma más simple posible, es decir en diagonal. (Para los lectores que deseen repasar los pasos para diagonalizar una matriz, este es un buen ejemplo). El término ortonormal significa que dos vectores son ortogonales o perpendiculares.
Al extender la matriz simétrica, la SVD trabaja con cualquier matriz A m×n real. Dada una matriz A real de m×n, existe una matriz ortogonal U de m×m, una matriz ortogonal V de m×m y una matriz diagonal Σ de m×n tal que
Tenga en cuenta que una matriz ortogonal es una matriz cuadrada tal que el producto de sí mismo y su matriz inversa es una matriz identidad. Una matriz diagonal es una matriz en la que las entradas distintas de la diagonal son todas cero.
A continuación, volveré a utilizar el conjunto de datos del iris para mostrarle cómo aplicar SVD.
de importación numpy *
operador de importación
importar matplotlib.pyplot como plt
importar pandas como pd
de importación numpy.linalg *dirección URL = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
# carga el conjunto de datos en Pandas DataFrame
df = pd.read_csv(url, nombres=['longitud del sépalo','ancho del sépalo','longitud del pétalo','ancho del pétalo','objetivo'])# Solo las variables X
data = df[['longitud del sépalo','ancho del sépalo','longitud del pétalo','ancho del pétalo']]#calcular SVD
n = 2 # Tomaremos dos Valores Singulares
U, s, V = linalg.svd(datos)# eye() crea una matriz con unos en la diagonal y ceros en otros lugares
Sig = mat(ojo(n)*s[:n])
nuevosdatos = U[:,:n]
nuevosdatos = pd.DataFrame(nuevosdatos)
nuevosdatos.columnas=['SVD1','SVD2']
nuevosdatos.head()
Puede comparar el resultado de SVD con el de PCA. Ambos obtienen resultados similares.
# Agregue el objetivo real a los datos para trazarlo
newdata['objetivo']=df['objetivo']higo = plt. figura()
hacha = fig.add_subplot(1,1,1)
ax.set_xlabel('SVD 1')
ax.set_ylabel('SVD 2')
hacha.set_title('SVD')
objetivos = ['Iris-setosa', 'Iris-versicolor', 'Iris-virginica']
colores = ['r', 'g', 'b']
para objetivo, color en zip (objetivos, colores):
indicesToKeep = newdata['objetivo'] == objetivo
hacha.dispersión(nuevosdatos.loc[índicesParaMantener, 'SVD1']
, nuevosdatos.loc[índicesParaMantener, 'SVD2']
, c = color
, s = 50)
hacha.leyenda(objetivos)
hacha.grid()
Incrustación del vecino estocástico distribuido en t (t-SNE)
t-SNE es desarrollado por Laurens van der Maaten y Geoggrey Hinton. Se trata de una algoritmo herramienta de aprendizaje automático para visualización que presenta la integración de datos de alta dimensión en un espacio bidimensional o tridimensional de baja dimensión.
¿Cuál es la mejor manera de presentar el rollo suizo tridimensional de arriba en dos dimensiones? Intuitivamente, queremos "desenrollar" el rollo suizo en un pastel plano. En matemáticas, esto significa que los puntos similares se convertirán en puntos cercanos y los puntos diferentes se convertirán en puntos distantes.
La siguiente figura muestra otro ejemplo. Es un tetraedro tridimensional con puntos de datos agrupados en las esquinas de los vértices. Si simplemente reducimos el gráfico tridimensional a un gráfico bidimensional como lo hace el panel (A), no funciona bien porque el grupo (A) se convierte en el grupo central. Por el contrario, el panel (B) es probablemente una mejor exposición 2D que preserva las distancias lejanas entre el grupo (A)–(E) mientras mantiene las distancias locales de los puntos en cada grupo. t-SNE, una técnica de reducción de dimensión no lineal, está diseñada para preservar los vecindarios locales. Si un conjunto de puntos se agrupan en un gráfico t-SNE, podemos estar bastante seguros de que estos puntos están cerca uno del otro.
t-SNE modela similitudes entre puntos. ¿Cómo define las similitudes? Primero, se define por la distancia euclidiana entre el punto Xi y Xj. En segundo lugar, se define como la probabilidad condicional de que “la similitud del punto de datos i con el punto j es la probabilidad condicional p de que el punto i elegiría los datos j como su vecino si se seleccionaran otros vecinos en función de sus probabilidades bajo una distribución gaussiana. En la siguiente expresión condicional, si el punto j está más cerca del punto i que otros puntos, tiene una mayor probabilidad (nótese el signo negativo) de ser elegido.
t-SNE tiene como objetivo hacer coincidir la probabilidad condicional p anterior entre j e i lo mejor posible mediante un espacio de baja dimensión q entre el punto Yi e Yj, como se muestra a continuación. La probabilidad q sigue una distribución t de Student de cola gorda, de donde proviene la “t” en t-SNE.
El siguiente paso es encontrar Yi para que la distribución q se aproxime lo más posible a la distribución p. t-SNE utiliza descenso de gradiente, una técnica de optimización, para encontrar los valores.
A continuación, muestro cómo se utiliza la técnica t-SNE con el conjunto de datos del iris.
de sklearn.manifold importar TSNE
desde sklearn.datasets importar load_iris
de sklearn.descomposición importar PCA
importar matplotlib.pyplot como plt
iris = cargar_iris()
X_tsne = TSNE(índice_de_aprendizaje=100).fit_transform(iris.datos)
X_pca = PCA().fit_transform(iris.datos)
plt. figura(figsize=(10, 5))
plt.subplot(121)
plt.dispersión(X_tsne[:, 0], X_tsne[:, 1], c=iris.objetivo)
plt.subparcela(122)
plt.dispersión(X_pca[:, 0], X_pca[:, 1], c=iris.objetivo)
ES 
FR 
EN