Guía práctica de algoritmos de machine learning con scikit-learn

Clase 12 de 17 • Curso de Introducción a Machine Learning

¡Hola! Te doy la bienvenida a esta clase con un nuevo reto.

Antes que nada espero que te haya ido excelente con el notebook del reto anterior y que hayas completado todos los ejercicios. Recuerda que cualquier duda puedes dejarla en comentarios de la clase para que toda la comunidad de Platzi pueda apoyarte.

Notebook de algoritmos de machine learning

En la notebook en Google Colab de esta clase encontrarás una guía para probar algoritmos de machine learning en código. Desde la carga de datos hasta entrenar el modelo y verificar su performance.

Para estos ejemplos utilizaremos la librería de scikit-learn, una de las librerías con las que podemos comenzar a aprender el uso de algoritmos de machine learning de manera más sencilla.

En los siguientes cursos de la ruta de la Escuela de Data Science profundizarás en el uso de scikit-learn y otras librerías de machine learning. ¡Comencemos con la base! 🧠

Accede al notebook aquí.

Crea una copia de este notebook en tu Google Drive o utilízalo en el entorno de Jupyter notebook que prefieras. Recuerda instalar las librerías necesarias para ejecutar el código si ejecutas tu notebook en un entorno local.

Esta notebook no tiene ejercicios adicionales como la anterior, pero este el reto que tienes para esta clase:

Identifica en qué partes del código aplicamos los diferentes conceptos teóricos aprendidos en las clases anteriores.

¡Leo tus anotaciones en los comentarios y nos vemos en el próximo módulo!

Daniel Pérez

student•

Para evitar la advertencia que se genera al ajustar el modelo de regresión logística, una de las posibles soluciones es incrementar el número de iteraciones (por default es de 100) al configurar la regresión:

model_2 = linear_model.LogisticRegression(max_iter=110)

Rafael Rivera

student•

Gracias, buen aporte

Patricio Sánchez Fernández

student•

Daniel, muchas gracias por el aporte.

Jonathan Vásquez Alvarado

student•

Así queda la gráfica del codo para confirmar que de 3 a 4 serían las mejores elecciones de clústeres.

Les dejo el código:

I = []
centroids = []
for c in range(2,11):
  k2model = KMeans(n_clusters=c, random_state=42)
  k2model.fit(data[["petal length (cm)", "petal width (cm)"]])
  I.append(k2model.inertia_)
  centroids.append(k2model.cluster_centers_)

f = plt.figure(figsize=(7,5))
ax = f.add_subplot(1,1,1)

ax.scatter(x=np.arange(2,11), y=I)
ax.plot(np.arange(2,11),I)

ax.set_xlabel('Clusters')
ax.set_ylabel('Inertia')
ax.set_title('Elbow method for optimal k value')

f.tight_layout()

Rafael Rivera

student•

Super el aporte, precisamente estaba pensando eso.

Gracias por compartir

Julián Cárdenas

student•

Buen aprote!

David Coello

student•

Otra manera de realizar la visualización de "Elbow Method" es mediante KElbowVisualizer, dejo la documentación:

https://www.scikit-yb.org/en/latest/api/cluster/elbow.html#yellowbrick.cluster.elbow.KElbowVisualizer

# instalamos la libreria
!pip install yellowbrick

#I mportamos libreria de elbow method
from yellowbrick.cluster import KElbowVisualizer

# Creamos el modelo
kmodel = KMeans(random_state= 42)

# Inicializamos el visualizador de elbow method
visualizer = KElbowVisualizer(kmodel, k=(2,8))

# Ajustamos el modelo
visualizer.fit(df_iris[['petal length (cm)', 'petal width (cm)']])
visualizer.show()

Sebastian Gaviria

student•

!El mejor aporte! Mil gracias.

Julián Cárdenas

student•

Que buenos aportes están dando!

Antonio Demarco Bonino

student•

Para hablar de modelos este video de Dot Csv es GENIAL: https://www.youtube.com/watch?v=Sb8XVheowVQ&t=438s&ab_channel=DotCSV

Diego Jurado

student•

Gracias por compartir el link

Andres Gutiérrez Castillo

student•

no hagas eso mejor has esto

cargar el dataset en formato de dataframe:

iris = datasets.load_iris(as_frame=True)
data= iris.frame

hacer el hold-out de tu data(particionar):

from sklearn.model_selection import train_test_split
train, test = train_test_split(
 data, test_size=0.2, random_state=42)

creear un scatter plot + un linea que represente un modelo de regresion lineal, en un solo paso usando sns:

import seaborn as sns
sns.jointplot(data=data, x= "petal length (cm)", y="petal width (cm)",  
kind= 'reg'
``
- si quieren aplicar la tecnica del codo para encontrar el numero de K ideal en el algoritmo K-means:

el nombre completo de la funcion de coste es: whithin cluster sum of squares (WCSS)

WCSS = [] for c in range(2,10): m_kmeans = KMeans(n_clusters = c) # 1 cargamos el modelo especificando el n_clusters m_kmeans.fit(data[["petal length (cm)", "petal width (cm)"]]) # 2 entrenamos el modelo con la data sacalada WCSS.append(m_kmeans.inertia_) # 3 guardamos el valor del WCSS

plt.plot(range(len(WCSS)), WCSS, "rx-") plt.title('Encontrar el número correcto de clusters') plt.xlabel('Nº Clusters') plt.ylabel('WCSS') plt.show()

Daniel Pérez

student•

Acá mi resultado del Modelo de K-Means con un k=3.

Daniel Pérez

student•

Un resumen del proceso se regresión linear:

0. Se separan los datos en 'training' y ' 'testing'.

Para predecir Y ('petal width') a partir de X ('petal length'), queremos ajustar un modelo a:

𝜃1 ∗ 𝑥 + 𝜃0 = 𝑦 ,

la ecuación de la recta para generar nuestra regresión lineal.

Ajustamos el modelo con la 'training data y calculamos el coeficiente y el riesgo (bias). En el ejemplo obtenemos: 0.41 ∗ X − 0.36 = Y
Definimos un array con valores aleatorios de X (xvals) entre el mínimo y máximo de nuestro total de datos. Con estos datos y la ecuación hallada en 1, calculamos los Y (yvals). Graficamos y visualmente podemos ver la buena relación. Sin embargo:
debemos calcular el MSE y R2 con la testing data. (Siempre queremos un MSE bajo y 𝑅2 cercano a 1. 𝑅2 está limitado de 0 (efectivamente no correlacionado) a 1 (relación perfecta).). En nuestro caso los valores son de MSE: 0.04 y R2: 0.94, por lo que podemos ver que existe una relación decente entre la longitud (X) y el ancho de los pétalos (Y).

Rigoberto Acosta González

student•

Mi aporte al reto:

Fernando Callasaca Acuña

student•

Para evaluar qué número de cluster colocar. Aquí les dejo mi aporte del gráfico del "codo".

k = 5
train = data[["petal length (cm)", "petal width (cm)"]]
inertia_list = []

for i in range(1,k+1):
  modelKMeans = KMeans(n_clusters = i, random_state=42)
  modelKMeans.fit(train)
  inertia_list.append(modelKMeans.inertia_)

f = plt.figure(figsize=(7,5))
ax = f.add_subplot(1,1,1)
ax.plot(np.arange(1,6,1), inertia_list, '-o', ms=15, mfc='green')
ax.set_title('Elbow-plot - Diagrama de Codo')
ax.set_xlabel('K - Cluster')
ax.set_ylabel('Distorción del Score . inertia')
ax.grid()
f.tight_layout()

Leandro Tenjo

student•

Otra forma de crear el ElbowPlot 📉


def medir_inertia(n_c=1, r_s=42):
    elbowplot_df = pd.DataFrame(columns=['n_clusters', 'inertia'])
    i = 1
    while i <= n_c:
        k2model = KMeans(n_clusters=i, random_state=r_s)
        k2model.fit(iris_df[["petal length (cm)", "petal width (cm)"]])
        elbowplot_df = elbowplot_df.append( 
            {'n_clusters': i, 'inertia': k2model.inertia_}, 
            ignore_index=True )
        i+=1
    
    return elbowplot_df

medir_inertia(n_c=10).pipe(
    lambda df: sns.lineplot(data= df, x='n_clusters', y='inertia',
                marker='o')
);

Emmanuel Guerra Sánchez

student•

De esta forma podemos visualizar la matriz de confunsión:

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

cm = confusion_matrix(ytest, ypred)
print(cm)

disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot()

Eliana Ossio

student•

PREGUNTA:

Predicción con logistic regression:

[2 2 2 1 0 0 0 0 2 1 2 0 0 1 1 2 1 1 2 2 2 0 2 0 0 2 2 1 0 0]

Predicción con random forest:

[2 2 1 1 0 0 0 0 2 1 2 0 0 1 1 2 1 1 2 2 2 0 2 0 0 2 2 1 0 0]

He comparado las predicciones realizadas con logistic regression vs random forest, ambas tienen un Testing accuracy = 1.0. Son casi iguales, excepto por el tercer elemento que en la logistic regression es 2 y en random forest es 1. Si ambos tienen un testing accuracy de 1, no deberían ser exactamente iguales?. Por favor, hay una explicación para esto?

Julian Crispin

student•

Alguien sabe exactamente cual es la funcion del parametro "random_state" cuando se usa DataFrame.sample(). NO entiendo muy bien porque se le da el valor de 1234, o en que cambia si se le da otro valor. Gracias

Violeta Sosa León

student•

El random_state garantiza que tu train_set y tu test_set siempre tengan el mismo tamaño, pero como se organizan aleatoriamente, necesitas garantizar el mismo número aleatorio. El 1234 es un número X, pudo haber sido 7890, no importa. Lo importante es que sea el mismo. Usualmente la convención es usar 42.

Nelson Mauricio Bravo Caballero

student•

tengo una pregunta, despues de realizar el grafico del codo, en este caso deberiamos saber que k tiene que ser 3, ni 2 ni 4 o mas, pero en el grafico no es muy claro.

"Idealmente, los modelos con menor inercia son mejores; sin embargo, con más grupos, la inercia a menudo seguirá disminuyendo marginalmente." entonces como se puede conocer puntualmente cual es el mejor K?

Platzi

student•

Para encontrar el mejor K en K-means, se recomienda usar el gráfico del codo y buscar la 'curva' o 'codo' donde la disminución de la inercia cambia cási no. Si el gráfico no es claro, se podría emplear el 'silhouette score' buscando un valor cercano a uno.

david jurado

student•

Puede ser una pregunta tonta, pero no la entiendo, por qué se usa para predecir la y? tipo ypred? y no la x?

Platzi

student•

Linear regression predice 'y' en función del valor de 'x', porque 'y' es el resultado o la variable dependiente basada en la variable independiente 'x'. No se predice 'x' ya que es el valor conocido que usamos para predecir 'y'.

Marco Antonio Latorre González

student•

Buen día, el programa corre sin errores pero al final no muestra las gráficas, que puede estar pasando?

David Gallego

student•

hola, en el punto 5 de k-means, me arroja un warning por 'n_init', no me queda claro donde ajustar este valor para que el warning no salga, me podrían dar una mano, muchas gracias.

Dionicio Perez

student•

Hola, esto se debe a una modificación en el método que esta implementando sklearn. ¿Que es n_init? La documentación dice lo sigueinte:

Número de veces que se ejecuta el algoritmo k-means con diferentes semillas de centroide. El resultado final es el mejor resultado de n_init ejecuciones consecutivas en términos de inercia. Se recomiendan varias ejecuciones para problemas dispersos de alta dimensión

En versiones menor a la 1.4 el valor por defecto es 10, en versiones igual o superior el valor por defecto es 'auto'. Simplemente es un aviso. Si quieres eliminar este aviso agrega n_init='auto' en donde ejucutes KMeans

Violeta Sosa León

student•

En el código en el que usa el modelo de Random Forests, debería estar usando el y_pred del cfl y no el del ejercicio de logistic regression. Alguien podría aclarar esto?

Emmanuel Guerra Sánchez

student•

Debe ser un typo

Jonathan Fernando Santana Quispillo

student•

Para ver "qué tan bueno es el ajuste" se utiliza dos métricas de rendimiento: el error cuadrático medio (MSE) y R^2, se refiere al error y al acurrancy respectivamente.

Axel Yaguana

Team Platzi•

¡Exacto!

RMSE (raíz del error cuadrático medio)

Nos indica cuán dispersos están los datos de la curva que mejor describe el modelo. En otras palabras, es la desviación estándar de los residuos.

R² (coeficiente de determinación)

Responde a qué tanto se ajustan las predicciones con el modelo. O sea, cuánto de la variación de los datos observados es explicada por las predicciones.

❌NO elevamos nada al cuadrado.

❌NO es ρ (Pearson) elevado al cuadrado.

Otra métrica interesante es ρ (coeficiente de correlación de Pearson)

Nos cuenta sobre los patrones en los datos.

✔️Explica cuán correlacionadas están las dos variables.

❌NO indica qué tan bueno es el modelo.

Cristian Omar Rubio Ceja

student•

Pequeño aporte para entender mejor la confussion matrix

# Add plot for the confusion matrix with seaborn
import seaborn as sns
sns.heatmap(confusion_matrix(ytest, ypred), annot=True, fmt='d', cmap='Greens')
# Add labels to the plot
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.title('Confusion Matrix')
# Add name of the species
species = ['Setosa', 'Versicolor', 'Virginica']
plt.xticks([0.5, 1.5, 2.5], species)
plt.yticks([0.5, 1.5, 2.5], species)
plt.show()

I = []
centroids = []
for c in range(2,11):
  k2model = KMeans(n_clusters=c, random_state=42)
  k2model.fit(data[["petal length (cm)", "petal width (cm)"]])
  I.append(k2model.inertia_)
  centroids.append(k2model.cluster_centers_)

f = plt.figure(figsize=(7,5))
ax = f.add_subplot(1,1,1)

ax.scatter(x=np.arange(2,11), y=I)
ax.plot(np.arange(2,11),I)

ax.set_xlabel('Clusters')
ax.set_ylabel('Inertia')
ax.set_title('Elbow method for optimal k value')

f.tight_layout()

# instalamos la libreria
!pip install yellowbrick

#I mportamos libreria de elbow method
from yellowbrick.cluster import KElbowVisualizer

# Creamos el modelo
kmodel = KMeans(random_state= 42)

# Inicializamos el visualizador de elbow method
visualizer = KElbowVisualizer(kmodel, k=(2,8))

# Ajustamos el modelo
visualizer.fit(df_iris[['petal length (cm)', 'petal width (cm)']])
visualizer.show()

import seaborn as sns
sns.jointplot(data=data, x= "petal length (cm)", y="petal width (cm)",  
kind= 'reg'
``
- si quieren aplicar la tecnica del codo para encontrar el numero de K ideal en el algoritmo K-means:

k = 5
train = data[["petal length (cm)", "petal width (cm)"]]
inertia_list = []

for i in range(1,k+1):
  modelKMeans = KMeans(n_clusters = i, random_state=42)
  modelKMeans.fit(train)
  inertia_list.append(modelKMeans.inertia_)

f = plt.figure(figsize=(7,5))
ax = f.add_subplot(1,1,1)
ax.plot(np.arange(1,6,1), inertia_list, '-o', ms=15, mfc='green')
ax.set_title('Elbow-plot - Diagrama de Codo')
ax.set_xlabel('K - Cluster')
ax.set_ylabel('Distorción del Score . inertia')
ax.grid()
f.tight_layout()

def medir_inertia(n_c=1, r_s=42):
    elbowplot_df = pd.DataFrame(columns=['n_clusters', 'inertia'])
    i = 1
    while i <= n_c:
        k2model = KMeans(n_clusters=i, random_state=r_s)
        k2model.fit(iris_df[["petal length (cm)", "petal width (cm)"]])
        elbowplot_df = elbowplot_df.append( 
            {'n_clusters': i, 'inertia': k2model.inertia_}, 
            ignore_index=True )
        i+=1
    
    return elbowplot_df

medir_inertia(n_c=10).pipe(
    lambda df: sns.lineplot(data= df, x='n_clusters', y='inertia',
                marker='o')
);

# Add plot for the confusion matrix with seaborn
import seaborn as sns
sns.heatmap(confusion_matrix(ytest, ypred), annot=True, fmt='d', cmap='Greens')
# Add labels to the plot
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.title('Confusion Matrix')
# Add name of the species
species = ['Setosa', 'Versicolor', 'Virginica']
plt.xticks([0.5, 1.5, 2.5], species)
plt.yticks([0.5, 1.5, 2.5], species)
plt.show()

Guía práctica de algoritmos de machine learning con scikit-learn

Introducción a machine learning

Curso actualizado

Algoritmos de Machine Learning: Preparación y Aplicación de Datos

Introducción al Machine Learning: Historia y Conceptos Básicos

Introducción a la Ciencia de Datos: Carga y Visualización de Conjuntos

Algoritmos Supervisados y No Supervisados en Machine Learning

Procesamiento y Análisis de Datos para Machine Learning

Algoritmos simples de machine learning

Modelos de Machine Learning: Uso, Implementación y Evaluación

Regresión Lineal: Predicción y Evaluación de Modelos Numéricos

Regresión Logística: Clasificación y Predicción de Probabilidades

Clasificadores de Bosque Aleatorio: Conceptos y Aplicaciones

Aprendizaje No Supervisado: Clustering con K-means

Guía práctica de algoritmos de machine learning con scikit-learn

Deep learning

Fundamentos de Redes Neuronales y Deep Learning

Mejora de Redes Neuronales: Ajuste, Overfitting y Dropout

Entrenamiento Efectivo de Redes Neuronales: Arquitectura y Tasa de Aprendizaje

Conclusiones

Curso de Fundamentos Prácticos de Machine Learning

Resumen del Curso de Machine Learning y Habilidades Avanzadas