Entrenamiento de PCA en Python con Scikit-Learn

Aunque puede acelerar la adaptación de un algoritmo de aprendizaje automático cambiando el algoritmo de optimización, la forma más común de acelerar el algoritmo es usar análisis de componentes principales (PCA). Si su algoritmo de aprendizaje es demasiado lento porque el tamaño de entrada es demasiado alto, usar PCA para acelerarlo podría ser una opción razonable. Esta es probablemente la aplicación más común de PCA. Otra aplicación común de PCA es la visualización de datos.

Para comprender el valor de usar PCA para la visualización de datos, la primera parte de este tutorial pasa por un visualización básica de Conjunto de datos de iris Después de aplicar PCA. La segunda parte explora cómo usar PCA acelerar el algoritmo de aprendizaje automático En el conjunto de datos modificado del Instituto Nacional de Estándares y Tecnología (MNIST) (regresión logística).

Comencemos con eso.

PCA para visualización de datos

Para muchos aprendizaje automático aplicaciones de ayuda visualiza tus datos. Visualizar datos en dos o tres dimensiones no es tan difícil. Sin embargo, el conjunto de datos de Iris utilizado en esta parte del tutorial también es de cuatro dimensiones. Puede usar PCA para reducir estos datos de cuatro dimensiones a dos o tres dimensiones para que pueda trazar y, con suerte, comprender mejor los datos.

Más sobre ciencia de datosCómo usar un horario Z y crear el tuyo propio

Paso 1: Descargar el conjunto de datos de iris

Iris viene con un conjunto de datos aprender y no requiere que descargue ningún archivo de algunos sitios web externos. El siguiente código cargará el conjunto de datos de Iris.

import pandas as pd

url = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

# load dataset into Pandas DataFrame
df = pd.read_csv(url, names=['sepal length','sepal width','petal length','petal width','target'])

Paso 2: Estandarizar los datos

PCA se ve afectado por la escala, por lo que debe escalar las características en sus datos antes de aplicar PCA. úsalo StandardScaler para ayudarte para estandarizar los datos características de la sección en una sola escala (mean = 0 y variance = 1), un requisito para que muchos funcionen de manera óptima algoritmos de aprendizaje automático. Que no escala tus datospuede ser impacto negativo en su algoritmo.

from sklearn.preprocessing import StandardScaler

features = ['sepal length', 'sepal width', 'petal length', 'petal width']

# Separating out the features
x = df.loc[:, features].values

# Separating out the target
y = df.loc[:,['target']].values

# Standardizing the features
x = StandardScaler().fit_transform(x)

Paso 3: Proyección PCA a 2D

Los datos originales tienen cuatro columnas (longitud del cáliz, anchura del sépalo, longitud del pétalo y anchura del pétalo). En esta sección, el código proyecta los datos originales de cuatro dimensiones en dos dimensiones. después disminución de tamaño, por lo general no se asigna un significado específico a cada componente principal. Los nuevos componentes son solo dos dimensiones principales de variación.

from sklearn.decomposition import PCA

pca = PCA(n_components=2)

principalComponents = pca.fit_transform(x)

principalDf = pd.DataFrame(data = principalComponents
             , columns = ['principal component 1', 'principal component 2'])

finalDf = pd.concat([principalDf, df[['target']]], axis = 1)

Concatenación de DataFrame axis = 1. finalDf es el último DataFrame antes del trazado de datos.

Paso 4: Visualizar una proyección 2D

Esta sección simplemente traza datos bidimensionales. Tenga en cuenta que las clases están bien separadas en el siguiente gráfico.

fig = plt.figure(figsize = (8,8))
ax = fig.add_subplot(1,1,1) 
ax.set_xlabel('Principal Component 1', fontsize = 15)
ax.set_ylabel('Principal Component 2', fontsize = 15)
ax.set_title('2 component PCA', fontsize = 20)

targets = ['Iris-setosa', 'Iris-versicolor', 'Iris-virginica']
colors = ['r', 'g', 'b']
for target, color in zip(targets,colors):
    indicesToKeep = finalDf['target'] == target
    ax.scatter(finalDf.loc[indicesToKeep, 'principal component 1']
               , finalDf.loc[indicesToKeep, 'principal component 2']
               , c = color
               , s = 50)
ax.legend(targets)
ax.grid()

variación explicativa

él explicó diferencia le dice cuánta información (variación) se puede atribuir a cada uno de los componentes principales. Esto es importante porque si bien puedes convertir un espacio de cuatro dimensiones en un espacio de dos dimensiones, cuando lo haces pierdes algo de varianza (información). Usando el atributo explained_variance_ratio_, puede ver que el primer componente principal contiene el 72,77 por ciento de la varianza y el segundo componente principal contiene el 23,03 por ciento. Los dos componentes juntos contienen el 95,80 por ciento de la información.

pca.explained_variance_ratio_

PCA para acelerar los algoritmos de aprendizaje automático

Aunque hay otras formas acelerar los algoritmos de aprendizaje automático, una de las formas menos conocidas es usar PCA. Para esta sección, no usamos el conjunto de datos Iris porque solo tiene 150 filas y cuatro columnas de características. La base de datos de dígitos escritos a mano del MNIST es más adecuada porque tiene 784 columnas de características (784 dimensiones), un conjunto de entrenamiento de 60 000 muestras y un conjunto de prueba de 10 000 muestras.

Paso 1: Descargar y cargar datos

También puedes agregar data_home parámetro para fetch_mldata para cambiar el lugar donde descargó los datos.

from sklearn.datasets import fetch_openml
mnist = fetch_openml('mnist_784')

Aquí están las imágenes que subiste mnist.data y tiene la forma (70000, 784), lo que significa que hay 70.000 imágenes con 784 dimensiones (784 características).

Contiene etiquetas (enteros 0-9). mnist.target. Las funciones tienen un tamaño de 784 (imágenes de 28 x 28) y las etiquetas son números del 0 al 9.

Paso 2: dividir los datos en conjuntos de entrenamiento y prueba

El siguiente código realiza un división de pruebas de trenes esto coloca 6/7 de los datos en el conjunto de entrenamiento y 1/7 en el conjunto de prueba.

from sklearn.model_selection import train_test_split

# test_size: what proportion of original data is used for test set
train_img, test_img, train_lbl, test_lbl = train_test_split( mnist.data, mnist.target, test_size=1/7.0, random_state=0)

Paso 3: estandarizar los datos

El texto de este párrafo es una copia casi exacta de lo que se escribió anteriormente. PCA se ve afectado por la escala, por lo que debe escalar las características en los datos antes de aplicar PCA. Puede convertir los datos a una escala uniforme (mean = 0 y variance = 1), es un requisito para el rendimiento óptimo de muchos algoritmos de aprendizaje automático. StandardScaler ayuda a estandarizar las características del conjunto de datos. Te adaptas al conjunto de entrenamiento y te conviertes en el conjunto de entrenamiento y prueba.

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()

# Fit on training set only.
scaler.fit(train_img)

# Apply transform to both the training set and the test set.
train_img = scaler.transform(train_img)
test_img = scaler.transform(test_img)

Paso 4: Importar y aplicar PCA

Tenga en cuenta que el código a continuación tiene .95 para el parámetro de número de componentes. Esto significa que scikit-learn elige la cantidad mínima de componentes principales para que se retenga el 95 por ciento de la varianza.

from sklearn.decomposition import PCA

# Make an instance of the Model
pca = PCA(.95)

Coloque el PCA en el conjunto de entrenamiento. tú solamente Ajuste de PCA al conjunto de entrenamiento.

pca.fit(train_img)

Puede averiguar cuántos componentes tiene un PCA después de ajustar el modelo usando pca.n_components_. En este caso, el 95 por ciento de la diferencia es igual a 330 componentes principales.

Paso 5: aplicar la asignación (transformación) al conjunto de entrenamiento y al conjunto de prueba.

train_img = pca.transform(train_img)
test_img = pca.transform(test_img)

Paso 6: aplicar la regresión logística a los datos transformados

1. Importa el modelo que quieras usar.

Todos los modelos de aprendizaje automático en Sklearn se implementan como clases de Python.

from sklearn.linear_model import LogisticRegression

2. Cree una instancia del modelo.

# all parameters not specified are set to their defaults
# default solver is incredibly slow which is why it was changed to 'lbfgs'
logisticRegr = LogisticRegression(solver="lbfgs")

3. Entrene el modelo en los datos almacenando la información aprendida de los datos.

El modelo aprende la relación entre números y etiquetas.

logisticRegr.fit(train_img, train_lbl)

4. Predecir las etiquetas de nuevos datos (nuevas imágenes).

Esta parte utiliza la información que el modelo ha aprendido durante el proceso de entrenamiento. El siguiente código hace una predicción para una observación.

# Predict for One Observation (image)
logisticRegr.predict(test_img[0].reshape(1,-1))

El siguiente código hace predicciones para múltiples observaciones.

# Predict for One Observation (image)
logisticRegr.predict(test_img[0:10])

Paso 7: Medición del rendimiento del modelo

Aunque la precisión no siempre es la mejor métrica para los algoritmos de aprendizaje automático (precisión, recordarcuenta f1, curva ROCetc., sería mejor), se usa aquí por simplicidad.

logisticRegr.score(test_img, test_lbl)

Prueba del tiempo de ajuste a la regresión logística después de PCA

El objetivo de esta parte del tutorial era mostrar que puede usar PCA para acelerar la instalación de algoritmos de aprendizaje automático. La siguiente tabla muestra cuánto tiempo lleva adaptarse Regresión logística en el MacBook después de usar PCA (manteniendo una cantidad diferente de variación cada vez).

Más sobre ciencia de datosEl concepto de diagramas de caja

Reconstrucción de imágenes a partir de representación comprimida

Las secciones anteriores de este tutorial demostraron cómo usar PCA para comprimir datos de alta dimensión en datos de baja dimensión. Pero PCA también puede tomar una representación comprimida de datos (datos de baja dimensión) y devolverla a una aproximación de los datos originales de alta dimensión. Si estás interesado, puedes usarlo. este código para replicar la imagen de abajo.

Podría escribir mucho más sobre PCA en esta publicación porque tiene muchos usos diferentes. Pero espero que esto te ayude con lo que sea que estés trabajando.