La famosa maldición de la dimensión, en inglés ‘curse of dimensionality‘, muchísimos algoritmos la sufren, lo habrás leído en más de un curso. Estoy seguro de que ha salido el tema si has estudiado SVM (Support Vector Machine).
Que sÍ… que lo hemos oído, pero qué es ‘the curse of dimensionality‘?
Bien, esta ‘maldición’ no quiere decir que el algoritmo esté maldito y te vayas a encontrar al payaso de IT la próxima vez que pases por una alcantarilla. Se trata más bien de un problema de la cantidad de datos, y su dimensión, que introduces a tu modelo. El sentido comín nos dice que tener más datos siempre es mejor para predecir cualquier cosa, y, por norma general, es verdad. Pero aumentar la dimensionalidad de tus datos (número de variables) trae sus problemas también.
Este problema quiere decir que la complejidad de nuestros modelos y la potencia computacional necesaria para entrenarlos y ejecutarlos crece al aumentar la cantidad de variables que tenemos en cuenta. También tenemos muchas papeletas de meter ruido o variables redundantes al introducir más campos.
¿ Cómo reduzco la dimensión si las variables son necesarias?
Aquí es donde entra el PCA: Principal Component Analysis, o Análisis de las Componentes Principales en español. Esta herramienta nos sirve para tener la misma información que nuestro dataset original pero explicada con componentes ortogonales.
¿Qué es que sean ortogonales? Significa que son no correlacionadas entre sí, son completamente independientes la una de la otra.
Ojito que también esto nos obliga a asumir que existe una relación lineal en nuestros datos, por lo que no es una pastilla para curar todas las enfermedades.
Al ejecutar el algoritmo, obtenemos una serie de componentes ordenadas de mayor a menor según la cantidad de varianza que describen. Es decir, la componente 1 explica mucho mas nuestros datos que la componente 6. Esto nos viene de perlas para reducir la dimensión de nuestros datos. Por ejemplo, si la 1 explica mucho más que la 13, ¿para qué quedarnos con la 13 si las 12 primeras ya explican el 99% de los datos? !Aquí tenemos el elixir para librarnos de la maldición!
Vale, igual este ~elixir~ no vale 50k en Skyrim como el de la foto, pero te aseguro que el PCA es una herramienta muy útil para tener en el arsenal cuando tenemos problemas de dimensiones.
Ahora os voy a enseñar un ejemplo rápido de cómo ejecutarlo.
Cómo ejecutar PCA en python
Para el ejemplo vamos a utilizar de nuevo los datos de las casas de california que utilizamos para la regresión logística. Estos datos son datos de ejemplo de Google Colab (aquí tienes un link por si todavía no sabes lo que es).
Primero importamos las librerías que necesitamos:
import pandas as pd from sklearn.preprocessing import StandardScaler from sklearn.decomposition import PCA import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D
Importamos los datos, vemos la cabecera del dataframe:
train = pd.read_csv("/content/sample_data/california_housing_train.csv")
train.head()
Vamos a realizar un mini tratamiento de datos express (eliminar NaNs, separar datos del target, y re-escalar:
# Eliminamos los NA de los datos, que a sklearn no le gustan train.dropna(inplace=True) # Separamos nuestro target de los datos x = train.drop(columns='median_house_value') target = train['median_house_value'] # Normalizamos las varibles para que todas esten en la misma escala: x = StandardScaler().fit_transform(x)
Bien, podemos avanzar ya por fin a ejecutar el PCA!
# Creamos el objeto de PCA, indicando cuantas componentes queremos quedarnos
pca = PCA(n_components=2)
# Entrenamos el PCA con nuestros datos, y lo aplicamos a los datos
principalComponents = pca.fit_transform(x)
principalDf = pd.DataFrame(data = principalComponents
, columns = ['principal component 1', 'principal component 2'])
# Resultados:
principalDf.head()
Como ahora tenemos los datos en 3 dimensiones (2 variables y 1 target) ahora si que podemos ver de manera visual cómo están distribuidos nuestros datos!
# Como ahora tenemos solo 2 dimensiones m?s el target, lo podemos plotear fig = plt.figure() ax = fig.add_subplot(111, projection='3d') xs = principalDf.iloc[:,0] ys = principalDf.iloc[:,1] zs = target ax.scatter(xs=xs, ys=ys, zs=zs)
Vale, como vemos el target está muy concentrado, posiblemente porque hemos reducido la cantidad de variables, y también porque hemos hecho un reescalado a los datos de entrenamiento.
Vamos a ver cómo se distribuyen los datos si nos quedáramos solo con una componente:
# Vamos a plotear ahora en una unica dimension pca = PCA(n_components=1) # Entrenamos el PCA con nuestros datos, y lo aplicamos a los datos principalComponents = pca.fit_transform(x) df = pd.DataFrame() df['x'] = list(principalComponents) df['y'] = target # plot plt.plot( 'x', 'y', data=df, linestyle='none', marker='o') plt.show()
Conclusiones a llevar a casa
- Tener más datos, por norma general, va a venir muy bien a nuestros modelos, pero es muy posible que aumenten la complejidad del modelo, o incluso que metamos ruido.
- PCA nos ayuda a quedarnos con las componentes que más valor aportan, aunque tenemos que hacer la asunción de los datos son linealmente dependientes, y no siempre es así.
- Reducir los datos a dimensiones más pequeñas nos permite poder visualizar la distribución de nuestros datos
Espero que os haya gustado y os sea útil esta breve explicación de qué es la maldición de la dimensionalidad y cómo el PCA nos puede ayudar.
Reducir la dimensión de los datos baja la varianza del modelo. Si no sabes de que te estoy hablando, mira este post.
