Aprender los conceptos clave

1

Todo lo que aprender谩s sobre MA con Scikit-Learn

2

驴C贸mo aprenden las m谩quinas?

3

Problemas que podemos resolver con Scikit-learn

4

Las matem谩ticas que vamos a necesitar

Iniciar un proyecto con sklearn

5

Configuraci贸n de nuestro entorno Python

6

Instalaci贸n de librer铆as en Python

7

Datasets que usaremos en el curso

Optimizaci贸n de features

8

驴C贸mo afectan nuestros features a los modelos de Machine Learning?

9

Introducci贸n al PCA

10

Preparaci贸n de datos para PCA e IPCA

11

Implementaci贸n del algoritmo PCA e IPCA

12

Kernels y KPCA

13

驴Qu茅 es la regularizaci贸n y c贸mo aplicarla?

14

Implementaci贸n de Lasso y Ridge

15

Explicaci贸n resultado de la implementaci贸n

16

ElasticNet: Una t茅cnica intermedia

Regresiones robustas

17

El problema de los valores at铆picos

18

Regresiones Robustas en Scikit-learn

19

Preparaci贸n de datos para la regresi贸n robusta

20

Implementaci贸n regresi贸n robusta

M茅todos de ensamble aplicados a clasificaci贸n

21

驴Qu茅 son los m茅todos de ensamble?

22

Preparaci贸n de datos para implementar m茅todos de ensamble

23

Implementaci贸n de Bagging

24

Implementaci贸n de Boosting

Clustering

25

Estrategias de Clustering

26

Implementaci贸n de Mean-Shift

27

Implementaci贸n de Batch K-Means

Optimizaci贸n param茅trica

28

Validaci贸n de nuestro modelo usando Cross Validation

29

Implementaci贸n de K-Folds Cross Validation

30

Optimizaci贸n param茅trica

31

Implementaci贸n de Randomized

32

Bonus: Auto Machine Learning

Salida a producci贸n

33

Revisi贸n de nuestra arquitectura de c贸digo

34

Importar y exportar modelos con Sklearn

35

Creaci贸n de una API con Flask para el modelo

36

Cierre del curso

37

Material adicional para consultar

A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Implementaci贸n del algoritmo PCA e IPCA

11/37
Recursos

Aportes 33

Preguntas 14

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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

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.

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.

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

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.

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 ))

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)) 

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

sudo apt install python3-tk

Para el diagrama de factores, les recomiendo usar el paquete 鈥減rince鈥. Aunque el circulo de correlaciones no se como obtenerlo. Seria un buen aporte.

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()

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.

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

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

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!

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(鈥榠ris鈥)
scaler = StandardScaler()
scaled = scaler.fit_transform(
iris[[鈥榮epal_length鈥, 鈥榮epal_width鈥,鈥榩etal_length鈥,鈥榩etal_width鈥橾].values
)

covariance_matrix = np.cov(scaled.T)
sns.pairplot(iris)
sns.pairplot(iris , hue=鈥榮pecies鈥)

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 = [鈥楶rincipal 1鈥, 鈥楶rincipal 2鈥橾)

dt_target = dt_heart[鈥榯arget鈥橾
dt_target.columns =[鈥榯arget鈥橾

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

fig = plt.figure(figsize = (8,8))
ax = fig.add_subplot(1,1,1)

ax.set_xlabel(鈥楶rincipal Component 1鈥, fontsize = 15)
ax.set_ylabel(鈥楶rincipal 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 = [鈥楽in Problema鈥,鈥楥on Problema鈥橾

colors = [鈥榬鈥, 鈥榞鈥橾

for target, color in zip(targets,colors):
indicesToKeep = finalDf[鈥榯arget鈥橾 == target
ax.scatter(finalDf.loc[indicesToKeep, 鈥楶rincipal 1鈥橾,
finalDf.loc[indicesToKeep, 鈥楶rincipal 2鈥橾,
c = color,
s = 50)

ax.legend(titulos)
ax.grid()

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=鈥榣bfgs鈥)

pca_data = {鈥榓ccuracy鈥: [],鈥榥_components鈥: []}
ipca_data = {鈥榓ccuracy鈥: [],鈥榥_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[鈥榥_components鈥橾, pca_data[鈥榓ccuracy鈥橾, label=鈥楶CA鈥)
plt.plot(ipca_data[鈥榥_components鈥橾, ipca_data[鈥榓ccuracy鈥橾, label=鈥業PCA鈥)
plt.title(鈥楴 Components vs Accuracy - PCA vs IPCA鈥)
plt.xlabel(鈥楴umber of Components鈥)
plt.ylabel(鈥楢ccuracy of Logistic-Regression鈥)
plt.legend()
plt.show()

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

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

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.

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 鈥減asando鈥 informaci贸n.

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

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 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

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)}')