Compra acceso a todo Platzi por 1 a帽o

Antes: $249

Currency
$209/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscr铆bete

Termina en:

14D
4H
33M
42S

Reto: explora diferentes ejemplos de modelos y qu茅 pueden hacer

11/16

Lectura

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

...

Reg铆strate o inicia sesi贸n para leer el resto del contenido.

Aportes 14

Preguntas 5

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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)

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

Otra manera de realizar la visualizaci贸n de 鈥淓lbow 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()

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

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

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[[鈥減etal length (cm)鈥, 鈥減etal 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, 鈥渞x-鈥)
plt.title(鈥楨ncontrar el n煤mero correcto de clusters鈥)
plt.xlabel(鈥楴潞 Clusters鈥)
plt.ylabel(鈥榃CSS鈥)
plt.show()


Un resumen del proceso se regresi贸n linear:

0. Se separan los datos en 鈥榯raining鈥 y 鈥 鈥榯esting鈥.

Para predecir Y (鈥榩etal width鈥) a partir de X (鈥榩etal length鈥), queremos ajustar un modelo a:

饾渻1 鈭 饾懃 + 饾渻0 = 饾懄 ,

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

  1. 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
  2. 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:
  3. 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).

Para evaluar qu茅 n煤mero de cluster colocar. Aqu铆 les dejo mi aporte del gr谩fico del 鈥渃odo鈥.

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

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

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

Todo muy interesante

Con Seaborn podemos escribir un c贸digo m谩s simple y podemos hacer una divisi贸n por especies para visualizar mejor los datos.

sns.scatterplot(data=data, x='petal length (cm)', y='petal width (cm)', hue='species', palette='dark').set(title= 'Petal Width vs Length')

Desarrollo desaf铆o

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Cargar el dataset Iris
iris = load_iris()
X = iris.data[:, :2]  # Tomar las dos primeras caracter铆sticas (variables independientes)
y = iris.target  # Variable dependiente (clases)

# Dividir el conjunto de datos en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Crear el modelo de regresi贸n log铆stica
model = LogisticRegression()

# Ajustar el modelo a los datos de entrenamiento
model.fit(X_train, y_train)

# Realizar predicciones en el conjunto de prueba
y_pred = model.predict(X_test)

# Calcular la precisi贸n del modelo
accuracy = accuracy_score(y_test, y_pred)
print("Precisi贸n del modelo:", accuracy)

# Crear una funci贸n para graficar los resultados
def plot_decision_boundary(X, y, model):
    # Crear una malla de puntos para graficar la superficie de decisi贸n
    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, 0.1),
                           np.arange(x2_min, x2_max, 0.1))
    Z = model.predict(np.c_[xx1.ravel(), xx2.ravel()])

    # Graficar los puntos de datos y la superficie de decisi贸n
    Z = Z.reshape(xx1.shape)
    plt.contourf(xx1, xx2, Z, alpha=0.8)
    plt.scatter(X[:, 0], X[:, 1], c=y)
    plt.xlabel('Longitud del s茅palo')
    plt.ylabel('Ancho del s茅palo')
    plt.title('Regresi贸n Log铆stica - Iris Dataset')
    plt.show()

# Graficar los resultados
plot_decision_boundary(X, y, model)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# Cargar el dataset Iris
iris = load_iris()
X = iris.data[:, 1:]  # Tomar las dos 煤ltimas caracter铆sticas como variables independientes
y = iris.data[:, 0]  # Tomar la primera caracter铆stica como variable dependiente

# Dividir el conjunto de datos en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Crear el modelo de regresi贸n lineal
model = LinearRegression()

# Ajustar el modelo a los datos de entrenamiento
model.fit(X_train, y_train)

# Obtener los coeficientes del modelo
coef = model.coef_
intercept = model.intercept_

# Realizar predicciones en el conjunto de prueba
y_pred = model.predict(X_test)

# Calcular el coeficiente de determinaci贸n (R^2) del modelo
r2_score = model.score(X_test, y_test)
print("Coeficiente de determinaci贸n (R^2):", r2_score)

# Graficar los resultados
plt.scatter(X_test[:, 0], y_test, color='b', label='Datos reales')
plt.plot(X_test[:, 0], y_pred, color='r', label='Regresi贸n lineal')
plt.xlabel('Ancho del p茅talo')
plt.ylabel('Longitud del s茅palo')
plt.title('Regresi贸n Lineal - Iris Dataset')
plt.legend()
plt.show()

Preparaci贸n de los datos para el modelo:

# Fracci贸n de entrenamiento 0.8.
Ntrain = int(data.shape[0] * 0.8)

# Datos de entrenamiento.
train = data.iloc[:Ntrain, :]

# Datos de prueba.
test = data.iloc[Ntrain:, :]