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

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

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

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

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.

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

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:, :]