Implementación del algoritmo PCA e IPCA

Me toco pasarme al entorno Jupyter por que por consola se mira todo muy mal organizado

Aquí les dejo el código comentado por si les genera un error:

# Importamos las bibliotecas generales
import pandas as pd
import sklearn
import matplotlib.pyplot as plt
# Importamos los módulos específicos
from sklearn.decomposition import PCA
from sklearn.decomposition import IncrementalPCA
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
if __name__ == "__main__":
  # Cargamos los datos del dataframe de pandas
  dt_heart = pd.read_csv('data/heart.csv')
  # Imprimimos un encabezado con los primeros 5 registros
  print(dt_heart.head(5))
  # Guardamos nuestro dataset sin la columna de target
  dt_features = dt_heart.drop(['target'], axis=1)
  # Este será nuestro dataset, pero sin la columna
  dt_target = dt_heart['target']
  # Normalizamos los datos
  dt_features = StandardScaler().fit_transform(dt_features)
   # Partimos el conjunto de entrenamiento y para añadir replicabilidad usamos el random state
  X_train, X_test, y_train, y_test = train_test_split(dt_features, dt_target, test_size=0.3, random_state=42)
  # Consultamos la fórmula para nuestra tabla
  print(X_train.shape)
  print(y_train.shape)
  # Llamamos y configuramos nuestro algoritmo pca
  '''EL número de componentes es opcional, ya que por defecto si no le pasamos el número de componentes lo asignará de esta forma:
  a: n_components = min(n_muestras, n_features)'''
  pca = PCA(n_components=3)
  # Esto para que nuestro PCA se ajuste a los datos de entrenamiento que tenemos como tal
  pca.fit(X_train)
  #Como haremos una comparación con incremental PCA, haremos lo mismo para el IPCA.
  '''EL parámetro batch se usa para crear pequeños bloques, de esta forma podemos ir entrenandolos
  poco a poco y combinarlos en el resultado final'''
  ipca = IncrementalPCA(n_components=3, batch_size=10)
  #Esto para que nuestro PCA se ajuste a los datos de entrenamiento que tenemos como tal
  ipca.fit(X_train)
  ''' Aquí graficamos los números de 0 hasta la longitud de los componentes que me sugirió el PCA o que
  me generó automáticamente el pca en el eje x, contra en el eje y, el valor de la importancia
  en cada uno de estos componentes, así podremos identificar cuáles son realmente importantes
  para nuestro modelo '''
  plt.plot(range(len(pca.explained_variance_)), pca.explained_variance_ratio_)
  plt.show()
  #Ahora vamos a configurar nuestra regresión logística
  logistic = LogisticRegression(solver='lbfgs')
  # Configuramos los datos de entrenamiento
  dt_train = pca.transform(X_train)
  dt_test = pca.transform(X_test)
  # Mandamos los data frames la la regresión logística
  logistic.fit(dt_train, y_train)
  #Calculamos nuestra exactitud de nuestra predicción
  print("SCORE PCA: ", logistic.score(dt_test, y_test))
  #Configuramos los datos de entrenamiento
  dt_train = ipca.transform(X_train)
  dt_test = ipca.transform(X_test)
  # Mandamos los data frames la la regresión logística
  logistic.fit(dt_train, y_train)
  #Calculamos nuestra exactitud de nuestra predicción
  print("SCORE IPCA: ", logistic.score(dt_test, y_test)) 

Como dijo el profe, si no le damos el numero de componentes a PCA, vamos a obtener el mismo numero de features, es decir, el mismo numero de dimensiones, lo cual no tiene sentido porque no estariamos aprovechando la magia de PCA.

Comparación entre PCA e IPCA
Un compañero subió el siguiente gráfico y me pareció interesante hacerlo, comparto código:

Utilice los datos que el profesor subió en los archivos. Comento esto, porque me quedo ligeramente diferente que al otro compañero.
.
Código
Al código de la clase anterior le suman el siguiente y obtienen el gráfico de arriba.

    # Configuracion de la regresión logística
    logistic = LogisticRegression(solver='lbfgs')

    pca_data = {'accuracy': [],
                'n_components': []}
    ipca_data = {'accuracy': [],
                'n_components': []}
    # PCA
    for n in range(2, 10):
        pca = PCA(n_components=n)
        pca.fit(X_train)
        df_train = pca.transform(X_train)
        df_test = pca.transform(X_test)
        logistic.fit(df_train, y_train)
        acccuracy = logistic.score(df_test, y_test)
        
        pca_data['accuracy'].append(acccuracy)
        pca_data['n_components'].append(n)
    
    # IPC
    for n in range(2, 10):
        ipca = IncrementalPCA(n_components=n, batch_size=10)
        ipca.fit(X_train)
        df_train = ipca.transform(X_train)
        df_test = ipca.transform(X_test)
        logistic.fit(df_train, y_train)
        acccuracy = logistic.score(df_test, y_test)
        
        ipca_data['accuracy'].append(acccuracy)
        ipca_data['n_components'].append(n)
    
    
    plt.plot(pca_data['n_components'], pca_data['accuracy'], label='PCA')
    plt.plot(ipca_data['n_components'], ipca_data['accuracy'], label='IPCA')
    plt.title('N Components vs Accuracy - PCA vs IPCA')
    plt.xlabel('Number of Components')
    plt.ylabel('Accuracy of Logistic-Regression')
    plt.legend()
    plt.show()

Comparto mis apuntes del curso en un repo de Github

Es interesante ver cómo cambia la exactitud del modelo en función del número de componentes que se elijan tanto para el IPCA como para el PCA. No tenía idea de la influencia que podría tener al hacer el .fit_transform() sobre el X_test.

La gráfica es el resultado de aplicar el mismo código de la clase, pero simplemente variando el número de componentes (el random_state=42).
No obstante, esto desde luego dependerá del split realizado para obtener el X_train.

Para los que usáis linux necesitáis instalar una herramienta extra para la visualización tkinter.

sudo apt install python3-tk

Sobre la implementación al calcular el accuracy, recuerden que generalmente, luego de hacer el fit , se hace un predict y el accuracy se calcula comparando (y_test,y_predic). dejo mi codigo para que comparen.

import pandas as pd
import sklearn 
import matplotlib.pyplot as plt 


from sklearn.decomposition import PCA
from sklearn.decomposition import IncrementalPCA

from sklearn.linear_model import LogisticRegression

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

from sklearn.metrics import jaccard_score



if __name__=="__main__":
    dt_heart = pd.read_csv('./data/heart.csv')
    #print(dt_heart.head(5))

    dt_features = dt_heart.drop('target', axis =1) # axis=1  (columas)
    dt_target = dt_heart['target']

    # Normalizando los datos
    dt_features = StandardScaler().fit_transform(dt_features)
    # Get train and test sets
    X_train,X_test, y_train, y_test = train_test_split(dt_features,dt_target, test_size=0.3, random_state=42)

    # por defecto n_components = min(n_columnas, n_filas)
    pca = PCA(n_components=3)
    pca.fit(X_train)
    ipca = IncrementalPCA(n_components=3, batch_size=10)
    ipca.fit(X_train)

    plt.plot(range(len(pca.explained_variance_)), pca.explained_variance_ratio_)
    #plt.show()

    logistic = LogisticRegression(solver='lbfgs')
    dt_train = pca.transform(X_train)
    dt_test = pca. transform(X_test)
    logistic.fit(dt_train, y_train)
    log_predic = logistic.predict(dt_test)
    print('SCORE PCA:', jaccard_score(y_test, log_predic))
    dt_train = ipca.transform(X_train)
    dt_test = ipca.transform(X_test)
    logistic.fit(dt_train, y_train)
    log_predic=logistic.predict(dt_test)
    print('SCORE IPCA', jaccard_score(y_test,log_predic ))

Un pequeño recordatorio:

Vamos a recordar que estanos estamos trabajando bajo el dataset de pacientes con riesgo a padecer una enfermedad cardiaca, con este dataset pretendemos que utilizando ciertas variables de los pacientes, por ejemplo su edad, su sexo, su presión sanguínea y un indice de dolor que pueden sentir al realizar un ejercicio física. Vamos a intentar hacer una clasificación binaria, entre si el paciente tiene una enfermedad cardiaca o no la tiene, el objetivo de esta clase es hacer una clasificación básica, pero que nos dé una información relevante, maximizando la información de todos estos features.

Conclusión:

El rendimiento de los dos algoritmos es casi exactamente el mismo, pero hay que considerar que nuestro dataset tenia 13 fetures originalmente para intentar predecir una clasificación binaria y utilizando PCA, solo tuvimos que utilizar 3 features artificiales que fueron los que nos devolvió PCA para llegar a un resultado coste computacional y estamos utilizando información que es realmente relevante para nuestro modelo.

Os dejo un grafico que muestra que tan correlacionada estan los 2 componentes principales, creo que es importante, vemos que no estan correlacionados, y eso nos dice que al ser independientes los 2 componentes aportan mucho

from sklearn.decomposition import PCA

pca = PCA(n_components=2)
principalComponents = pca.fit_transform(dt_features)

principalDf = pd.DataFrame(data = principalComponents
, columns = [‘Principal 1’, ‘Principal 2’])

dt_target = dt_heart[‘target’]
dt_target.columns =[‘target’]

finalDf = pd.concat([principalDf, dt_target], axis = 1)

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)

#valores de target 0- No tiene problemas, 1- TIene problemas
targets = [0, 1]
titulos = [‘Sin Problema’,‘Con Problema’]

colors = [‘r’, ‘g’]

for target, color in zip(targets,colors):
indicesToKeep = finalDf[‘target’] == target
ax.scatter(finalDf.loc[indicesToKeep, ‘Principal 1’],
finalDf.loc[indicesToKeep, ‘Principal 2’],
c = color,
s = 50)

ax.legend(titulos)
ax.grid()

Por si alguien se pregunta de donde viene o qué es el variace_explained_ratio:

# Get variance explained by singular values
explained_variance_ = (S ** 2) / (n_samples - 1)
total_var = explained_variance_.sum()
explained_variance_ratio_ = explained_variance_ / total_var

donde S viene de:

U, S, V = linalg.svd(X, full_matrices=False)

y X viene siendo la matriz de entrada, es decir las features X_train.

• Referencia:

Scikit-Learn

Para el diagrama de factores, les recomiendo usar el paquete “prince”. Aunque el circulo de correlaciones no se como obtenerlo. Seria un buen aporte.

Para quien se encuentre trabajando en Windows Subsystem for Linux con Ubuntu y no le muestre la ventana de matplotlib esto me funcionó:

Primero descargué VcXsrv

Con esta configuración

Despues en el cmd de windows corres ipconfig para que conozcas tu IP local

Y finalmente en la consola corres esta línea
export DISPLAY=aqui_tu_ip:0

Como extra puedes guardar la última linea en ~/.bashrc para que se guarde y no tengas que correr la línea después

pca = PCA(n_components=3)
pca.fit(X_train)
ipca =IncrementalPCA(n_components=3,batch_size=10)
ipca.fit(X_train)
X_reduced = pca.transform(X)
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = Axes3D(fig)
ax.set_title('Heart Dataset by PCA', size=14)
ax.scatter(X_reduced[:,0],X_reduced[:,1],X_reduced[:,2], c=y, cmap=cmap)
ax.set_xlabel('First eigenvector')
ax.set_ylabel('Second eigenvector')
ax.set_zlabel('Third eigenvector')
ax.w_xaxis.set_ticklabels(())
ax.w_yaxis.set_ticklabels(())
ax.w_zaxis.set_ticklabels(())
plt.show()

Muy bien el ejercicio para aprender a usar sklearn, sin embargo, se debe entender el dataset que se está manejando, deberían transformar las columnas “cp” y “thal” a variables dicótomas, ya que a pesar de éstas ser numéricas, no tienen ningún orden de jerarquía (es decir, que tener cp tipo 2 no es peor o mejor que tener cp tipo 0). Pueden hacer algo de este estilo:

for i in ['cp', 'thal']:
	dt_features[i] = dt_features[i].astype('category')
dt_features = pd.get_dummies(dt_features)

Y solamente con ese cambio ganan 3% más de accuracy.

poner un numero al azar en los componentes (n_components =3) puede estar errado si antes no hacemos un estudio previo para ver que tanta varianza explican esos 3 componentes , en este caso esos 3 componentes estan explicando aprox un 45% de varianza es decir se pierde mucha informacion , una solucion para eso es colocar un numero decimal por ejemplo (n_components = 0.90) y python va a asumir que quieres los componentes que conserven entre todos un 90% de la informacion o el porcentaje que desees

o hacer una grafica para ver con cada componente cuanta varianza se conserva o se explica!

Tenía entendido que era una buena práctica realizar el escalamiento/estandarización de los datos de forma separada para los datos de entrenamiento y de prueba, de esta manera se aseguraba que no se estuviera “pasando” información.

Les comparto este gráfico en donde se puede ver de una manera gráfica como se comporta el variance ratio en la medida que agregamos mas n_components al PCA.

Como es obvio, cuando el n_components llega a 1 indica que llego a las 13 features originales que tenia el dataset

Hola! presenté problemas al mostrar la gráfica en la terminal. Gracias a chat gpt encontré una forma de crear el gráfico en un png que se guarda en la carpeta:
Primero se debe importar matplotlib de esta manera:

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt 

Luego para mostrar el grafico creariamos un png en la carpeta con:

plt.savefig('grafic.png')

Según Chat gpt “Este error se debe a que Matplotlib está intentando utilizar el backend Qt5Agg, que depende de ciertas bibliotecas de Qt y puede haber problemas de compatibilidad o configuración en su sistema”.
Y la alternativa es cambiar el backend utilizado por Matplotlib a otro que no dependa de Qt, como el backend Agg.

Está bien interesante este curso, excelente presentación del profe Ariel y acertados aportes de los compañeros.

Estoy trabajando con ambiente virtual en Anaconda y Jupyter Notebook. Hasta ahora todo ha compilado bien.

Habia trabajado en Colab y ahora probando con ambiente virtual y no me ha gustado el tamaño que ocupa la carpeta del ambiente virtual. Llevo un notebook con 40 lineas de codigo y la carpeta ya pesa 120MB, instalando un montón de dependencias. Punto a favor de Colab.

Se puede llagar al mismo resultado usando vectores, y analisis de covarianza, es mucho mas largo, aqui os dejo un codigo para ver la covarianza en matriz, lo que nos ayuda es a ver que variables estan altamente correlacionadas, y solo se utilizaria una de ellas

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.preprocessing import StandardScaler

iris = sns.load_dataset(‘iris’)
scaler = StandardScaler()
scaled = scaler.fit_transform(
iris[[‘sepal_length’, ‘sepal_width’,‘petal_length’,‘petal_width’]].values
)

covariance_matrix = np.cov(scaled.T)
sns.pairplot(iris)
sns.pairplot(iris , hue=‘species’)

Hola!! Por favor me aclaran por qué en este ejercicio el score se calculo así:

logistic.score(dt_test, y_test).

ya que lo aprendido en el curso de fundamentos de Machine Learning nos explican que debe ser así: y_pred es decir, calcular el accuracy con ((y_test, y_pred).

Gracias

LE COMPARTO LA NOTBOOK

Recuerda que PCA es una técnica que busca la máxima varianza en los datos, mientras que IPCA es una variante que funciona bien para conjuntos de datos grandes que no caben en la memoria. La elección entre PCA e IPCA dependerá del tamaño de tus datos y de tus objetivos específicos.

Comparación entre ambos métodos de reducción de dimensionalidad (bueno, de hecho es el mismo, sólo para que difieren en su entrenamiento):

Profe en el random state se pone cualquier valor ,es decir si pongo 100000000 estaría bien o hay alguna regla que deba tener en cuenta?

Con 3 componentes solo estamos explicando poco mas del 40% de la varianza, un profesor me recomendaba intentar usar por lo menos el 75%

El aporte de la grafica de numero de componentes con la exactitud dio que

Con 3 componentes la exactitud es 0.78 y .80
Pero usando 9 componentes la exactitud fue de 0.8 y 0.84

Es decir, si de los 13 componentes tomamos 9 tendremos mas exactitud.

Ese grafico me dejo mas claro la importancia de evaluar el porcentaje de exactitud al aumentar componentes.

Mi duda es que no ensena que features escogio el algoritmo

lo que hacemos en la primera parte de la clase, donde se grafica la varianza de cad una de la features es un scree plot o diagrama de desprendimiento

para mas info vease -> pca explaines

Previo al desarrollo final en archivos .py, se pueden usar las Jupyter Notebooks para exploración (.ipynb).
Se pueden usar tanto en plataformas como Colab o Deepnote o de forma local en VSCode.

PCA es una muy buena alternativa para reducir el numero de features e incrementar la calidad de los modelos. Sin embargo esto tiene un costo muy alto y es la interpretabilidad. Aún no he encontrado un manera sencilla de desglosar la importancia que tienen estos vectores en relación a lo que esta aportando cada variable. Siempre es importante que podamos interpretar los modelos que entrenamos!

En los aportes aparece que cuando variamos los componentes de 3 a 9 la exactitud aumenta, pero hice el calculo con mi codigo y vi que no era correcto, con mas de 3 componentes no aumenta la exactitud, aqui esta mi codigo

PUEDE ALGUIEN CONFIRMAR SI ES CORRECTO?

GRAFICA COMPARATIVA

logistic = LogisticRegression(solver=‘lbfgs’)

pca_data = {‘accuracy’: [],‘n_components’: []}
ipca_data = {‘accuracy’: [],‘n_components’: []}

for n in range(2, 10):

#PCA
pca = PCA(n_components=n)
pca.fit(X_train)

#IPCA
# Batch 10 es con bloques de 10 muestras a la vez
ipca = IncrementalPCA(n_components=n, batch_size=10)
ipca.fit(X_train)

#Train PCA
df_train = pca.transform(X_train)
df_test = pca.transform(X_test)
logistic.fit(df_train, y_train)
acccuracy = logistic.score(df_test, y_test)
    
pca_data['accuracy'].append(acccuracy)
pca_data['n_components'].append(n)


# TRAIN IPCA
df_train = ipca.transform(X_train)
df_test = ipca.transform(X_test)
logistic.fit(df_train, y_train)
acccuracy = logistic.score(df_test, y_test)
   
ipca_data['accuracy'].append(acccuracy)
ipca_data['n_components'].append(n)

plt.plot(pca_data[‘n_components’], pca_data[‘accuracy’], label=‘PCA’)
plt.plot(ipca_data[‘n_components’], ipca_data[‘accuracy’], label=‘IPCA’)
plt.title(‘N Components vs Accuracy - PCA vs IPCA’)
plt.xlabel(‘Number of Components’)
plt.ylabel(‘Accuracy of Logistic-Regression’)
plt.legend()
plt.show()

PCA permite crear features artificiales en base a a los features reales y generar un rendimiento bastante bueno, con esto unicamente se utilizan las variables necesarias para entrenar el modelo y realizar predicciones

Método PCA con 4 componentes principales:
Score = 0.827

Método IPCA con 4 componentes principales:
Score = 0.805

Mi notebook en git hub

Tienen que probar el jupyter notebook de microsoft en VS code.

Según la documentación de Scikit-Learn, para consultar las direcciones de máxima varianza dentro del espacio de features podemos usar:

pca.components_

Estas componentes son ordenadas de acuerdo a la cantidad de varianza que acumula cada uno.

recominendo llevar el curso en jupyter notebook o google collab para hacer esas pruebas como xtrain.shape

Funciona… pero no en el entorno

¿Cómo podemos consultar los componentes que recomienda PCA t IPCA’

¿Por qué se usa regresión logistica?

Les dejo mi código por si tuvieron algún error

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from sklearn.decomposition import PCA 
from sklearn.decomposition import IncrementalPCA

from sklearn.linear_model import LogisticRegression

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

if __name__ == '__main__':
    dt_heart = pd.read_csv('./data/heart.csv')

    print(dt_heart.head(5))

    dt_features = dt_heart.drop(['target'], axis=1) 
    dt_target = dt_heart['target']

    dt_features = StandardScaler().fit_transform(dt_features)
    
    X_train, X_test, y_train, y_test = train_test_split(dt_features, dt_target, test_size=0.3, random_state=42)

    print(X_train.shape)
    print(y_train.shape)
    #n_components = min(n_muestras, n_features)
    pca = PCA(n_components=3)
    pca.fit(X_train)

    ipca = IncrementalPCA(n_components=3, batch_size=10)
    ipca.fit(X_train)

    plt.plot(range(len(pca.explained_variance_)), pca.explained_variance_ratio_)
    plt.show()
 
    logistic = LogisticRegression(solver='lbfgs')

    dt_train = pca.transform(X_train)
    dt_test = pca.transform(X_test)
    logistic.fit(dt_train, y_train)
    print(f'SCORE PCA: {logistic.score(dt_test, y_test)}')
    
    dt_train = ipca.transform(X_train)
    dt_test = ipca.transform(X_test)
    logistic.fit(dt_train, y_train)
    print(f'SCORE IPCA: {logistic.score(dt_test, y_test)}')