Aplicación Práctica: Regresión Logística (Aprendizaje Supervisado)

 

Definicion.-  La regresión logística es un método estadístico utilizado para modelar la probabilidad de que una variable dependiente binaria (dicotómica) tenga un valor particular (por lo general, 0 o 1) en función de una o más variables independientes. Aunque su nombre incluye la palabra "regresión", la regresión logística se utiliza comúnmente para problemas de clasificación binaria en lugar de predicciones continuas.

La regresión logística es una herramienta poderosa para problemas de clasificación binaria y se utiliza en una variedad de campos para tomar decisiones basadas en la probabilidad de ocurrencia de un evento.

 Implementacion de un caso de estudio

 Se realiza una descripción paso a paso de cómo funciona y dónde se utiliza la regresión logística:

 1. Definición del Problema:

La regresión logística se aplica cuando se quiere predecir la probabilidad de que una variable dependiente binaria tenga un valor específico.

2. Recopilación de Datos:

Se recopilan datos que contienen información sobre la variable dependiente binaria y una o más variables independientes.

3. Exploración de Datos:

Se realiza un análisis exploratorio de los datos para comprender la relación entre las variables y para identificar posibles patrones.

4. Preprocesamiento de Datos:

Se realizan tareas como el manejo de valores atípicos, la imputación de datos faltantes y la normalización de variables para preparar los datos para el modelo.

5. División de Datos:

Los datos se dividen en conjuntos de entrenamiento y prueba para evaluar la capacidad del modelo para generalizar a nuevos datos.

6. Construcción del Modelo:

Se ajusta un modelo de regresión logística utilizando el conjunto de entrenamiento, donde se estima la relación entre las variables independientes y la probabilidad logarítmica de que la variable dependiente sea igual a 1.

7. Entrenamiento del Modelo:

El modelo se entrena utilizando técnicas de optimización, como el descenso de gradiente, para ajustar los parámetros y minimizar la función de pérdida.

8. Evaluación del Modelo:

Se evalúa el rendimiento del modelo utilizando el conjunto de prueba, utilizando métricas como la precisión, la sensibilidad y la especificidad.

9. Interpretación de Coeficientes:

Los coeficientes del modelo se interpretan para entender la influencia de cada variable independiente en la probabilidad de que la variable dependiente sea 1.

10. Aplicaciones de la Regresión Logística:

La regresión logística se utiliza en diversas áreas, como:

Predicción de riesgos crediticios.

Diagnóstico médico (por ejemplo, predicción de enfermedades).

Marketing (para prever la probabilidad de compra).

Análisis de sentiment en análisis de texto.

Modelado de respuesta binaria en encuestas.

11. Ajuste del Umbral:

Dependiendo de la aplicación, se puede ajustar el umbral de clasificación para equilibrar la sensibilidad y la especificidad del modelo.

12. Despliegue del Modelo:

Una vez satisfechos con el rendimiento del modelo, se puede implementar para hacer predicciones en nuevos datos.

  Ejemplo 1

 Crea una clasificación binaria con diagnostico medicos para predecir si un paciente tiene una enfermedad específica (1) o no (0) en función de las características médicas con datos ficticios creados, utilizando el codigo de python,  realiza una tabla y graficas. Para crear un modelo de clasificación binaria en Python con datos ficticios y predecir si un paciente tiene una enfermedad específica o no, podemos utilizar bibliotecas como numpy, pandas, sklearn y matplotlib. 

# Importar las bibliotecas necesarias

import numpy as np

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import confusion_matrix, classification_report

import matplotlib.pyplot as plt

import seaborn as sns

# Configuración para reproducibilidad

np.random.seed(42)

# Crear datos ficticios

data = {

    'Edad': np.random.randint(18, 65, 100),

    'Presion_Sistolica': np.random.randint(90, 160, 100),

    'Presion_Diastolica': np.random.randint(60, 100, 100),

    'Colesterol': np.random.randint(120, 240, 100),

    'Nivel_Glucosa': np.random.randint(70, 150, 100),

    'Enfermedad': np.random.choice([0, 1], size=100)

}

# Crear un DataFrame

df = pd.DataFrame(data)

# Dividir el conjunto de datos en características (X) y etiquetas (y)

X = df.drop('Enfermedad', axis=1)

y = df['Enfermedad']

# 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 y entrenar el modelo de regresión logística

model = LogisticRegression()

model.fit(X_train, y_train)

# Realizar predicciones en el conjunto de prueba

y_pred = model.predict(X_test)

# Evaluar el modelo

conf_matrix = confusion_matrix(y_test, y_pred)

class_report = classification_report(y_test, y_pred)

# Mostrar la matriz de confusión y el informe de clasificación

print("Matriz de Confusión:")

print(conf_matrix)

print("\nInforme de Clasificación:")

print(class_report)

# Visualizar la matriz de confusión con seaborn

sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=['No Enfermo', 'Enfermo'], yticklabels=['No Enfermo', 'Enfermo'])

plt.xlabel('Predicciones')

plt.ylabel('Valores Reales')

plt.title('Matriz de Confusión')

plt.show()

Ejemplo 2

En función al ejemplo 1 expandir el código para incluir más exploración de datos, preprocesamiento y evaluación del modelo. que muestren gráficos y tablas, agregar visualizaciones adicionales como la biblioteca seaborn para algunas de las visualizaciones y yellowbrick para visualizar la curva ROC. 

# Importar las bibliotecas necesarias

import numpy as np

import pandas as pd

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import confusion_matrix, classification_report, roc_curve, roc_auc_score, precision_recall_curve, auc

from yellowbrick.classifier import ROCAUC, PrecisionRecallCurve

import matplotlib.pyplot as plt

# Configuración para reproducibilidad

np.random.seed(42)

# Crear datos ficticios

data = {

    'Edad': np.random.randint(18, 65, 100),

    'Presion_Sistolica': np.random.randint(90, 160, 100),

    'Presion_Diastolica': np.random.randint(60, 100, 100),

    'Colesterol': np.random.randint(120, 240, 100),

    'Nivel_Glucosa': np.random.randint(70, 150, 100),

    'Enfermedad': np.random.choice([0, 1], size=100)

}

# Crear un DataFrame

df = pd.DataFrame(data)

# Exploración de datos

sns.pairplot(df, hue='Enfermedad', diag_kind='kde')

plt.show()

# Dividir el conjunto de datos en características (X) y etiquetas (y)

X = df.drop('Enfermedad', axis=1)

y = df['Enfermedad']

# 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 y entrenar el modelo de regresión logística

model = LogisticRegression()

model.fit(X_train, y_train)

# Visualizar la importancia de las características

coef_df = pd.DataFrame({'Feature': X.columns, 'Coefficient': model.coef_[0]})

coef_df = coef_df.sort_values(by='Coefficient', ascending=False)

sns.barplot(x='Coefficient', y='Feature', data=coef_df)

plt.title('Importancia de las Características')

plt.show()

# Realizar predicciones en el conjunto de prueba

y_pred = model.predict(X_test)

# Evaluar el modelo

conf_matrix = confusion_matrix(y_test, y_pred)

class_report = classification_report(y_test, y_pred)

# Mostrar la matriz de confusión y el informe de clasificación

print("Matriz de Confusión:")

print(conf_matrix)

print("\nInforme de Clasificación:")

print(class_report)

# Visualizar la matriz de confusión con seaborn

sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=['No Enfermo', 'Enfermo'], yticklabels=['No Enfermo', 'Enfermo'])

plt.xlabel('Predicciones')

plt.ylabel('Valores Reales')

plt.title('Matriz de Confusión')

plt.show()

# Visualizar la curva ROC y el área bajo la curva (AUC)

visualizer = ROCAUC(model)

visualizer.fit(X_train, y_train)

visualizer.score(X_test, y_test)

visualizer.show()

# Visualizar la curva Precisión-Recuperación y el área bajo la curva (AUC)

visualizer = PrecisionRecallCurve(model)

visualizer.fit(X_train, y_train)

visualizer.score(X_test, y_test)

visualizer.show()

# Calcular y mostrar el AUC-ROC manualmente

y_probs = model.predict_proba(X_test)[:, 1]

fpr, tpr, _ = roc_curve(y_test, y_probs)

roc_auc = auc(fpr, tpr)

plt.figure()

plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'AUC = {roc_auc:.2f}')

plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')

plt.xlabel('Tasa de Falsos Positivos')

plt.ylabel('Tasa de Verdaderos Positivos')

plt.title('Curva ROC')

plt.legend(loc='lower right')

plt.show()

 

Aplicación Práctica: Árboles de Decisión (Aprendizaje Supervisado)

 Definición de Árboles de Decisión: Los árboles de decisión son estructuras jerárquicas en forma de árbol que representan decisiones y sus posibles consecuencias. Cada nodo interno del árbol representa una prueba en un atributo, cada rama representa el resultado de la prueba y cada hoja representa una decisión o un valor de salida. En resumen, son modelos de predicción utilizados para tareas de clasificación y regresión.

Fundamentos de Árboles de Decisión:

1.     División de Datos: Los árboles de decisión buscan dividir los datos en subconjuntos más puros en términos de la variable objetivo (clasificación) o reducir la variabilidad (regresión).

2.     Criterios de División: Al tomar decisiones en cada nodo, se utiliza un criterio para determinar qué característica dividir. Algunos criterios comunes incluyen Gini impurity para clasificación y error cuadrático medio para regresión.

3.     Entropía: La entropía mide la impureza de un conjunto de datos. El objetivo es reducir la entropía a medida que se avanza en el árbol, creando subconjuntos más homogéneos.

4.     Poda (Pruning): La poda es un proceso que se utiliza para evitar el sobreajuste (overfitting) del modelo. Consiste en eliminar nodos o ramas del árbol que no contribuyen significativamente a la precisión.

Aplicación de Árboles de Decisión:

1.     Clasificación: Los árboles de decisión son comúnmente utilizados para tareas de clasificación, donde se intenta predecir a qué clase pertenece una observación.

2.     Regresión: Además de clasificación, los árboles de decisión también se utilizan para tareas de regresión, prediciendo un valor numérico en lugar de una clase.

3.     Interpretación: Una ventaja clave de los árboles de decisión es su interpretabilidad. Son fáciles de entender y visualizar, lo que hace que sea sencillo explicar cómo se toman las decisiones.

4.     Aprendizaje Supervisado: Se utilizan en aprendizaje supervisado, donde el modelo se entrena con ejemplos etiquetados para aprender a hacer predicciones en datos nuevos.

5.     Ensembles: Los árboles de decisión se pueden combinar en conjuntos (ensambles) como Random Forests o Gradient Boosted Trees para mejorar la precisión y robustez del modelo.

Pasos Generales para Crear un Árbol de Decisión:

1.     Recopilación de Datos: Obtener un conjunto de datos etiquetado para entrenar el modelo.

2.     Selección de Características: Identificar las características relevantes para la tarea.

3.     División de Datos: Utilizar criterios para dividir el conjunto de datos en subconjuntos más homogéneos.

4.     Construcción del Árbol: Repetir el proceso de división hasta que se alcance cierto criterio de parada o pureza.

5.     Poda (Opcional): Aplicar técnicas de poda para evitar el sobreajuste.

6.     Predicción: Utilizar el árbol entrenado para hacer predicciones en nuevos datos.

Ejemplo 1

Realizar una implementación simple de un árbol de decisión en un caso de estudio de clasificación binaria para el diagnóstico médico. Es importante señalar que el conjunto de datos utilizado en este ejemplo es hipotético y no representa datos médicos reales Supongamos que estamos construyendo un modelo para predecir si un paciente tiene diabetes o no, basándonos en características médicas.

import pandas as pd

import numpy as np

# Configuración para reproducibilidad

np.random.seed(42)

# Crear un conjunto de datos ficticio

num_samples = 1000

data = {

    'Edad': np.random.randint(18, 65, num_samples),

    'PresionArterial': np.random.randint(80, 140, num_samples),

    'NivelAzucar': np.random.randint(70, 200, num_samples),

    'Colesterol': np.random.randint(120, 240, num_samples),

    'Peso': np.random.uniform(50, 100, num_samples),

    'Altura': np.random.uniform(150, 190, num_samples),

    'Diabetes': np.random.choice([0, 1], num_samples)

}

# Crear DataFrame

df = pd.DataFrame(data)

# Guardar DataFrame como CSV

df.to_csv('datos_csv.csv', index=False)

# Mostrar las primeras filas del conjunto de datos

print(df.head())

Ejemplo 2

Ajustando el ejemplo 1 con los hiperparámetros, realizando ingeniería de características y considerando técnicas de validación cruzada

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

from sklearn.preprocessing import StandardScaler

# Cargar datos ficticios desde el archivo CSV

data = pd.read_csv('datos_csv.csv')

# Dividir datos en características (X) y etiquetas (y)

X = data.drop('Diabetes', axis=1)

y = data['Diabetes']

# Escalar características

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

# Dividir datos escalados en conjunto de entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# Crear y entrenar el árbol de decisiones

model = DecisionTreeClassifier(random_state=42)

model.fit(X_train, y_train)

# Realizar predicciones en el conjunto de prueba

y_pred = model.predict(X_test)

# Evaluar el rendimiento del modelo

accuracy = accuracy_score(y_test, y_pred)

conf_matrix = confusion_matrix(y_test, y_pred)

classification_rep = classification_report(y_test, y_pred)

# Mostrar resultados

print(f'Accuracy: {accuracy:.2f}')

print(f'Confusion Matrix:\n{conf_matrix}')

print(f'Classification Report:\n{classification_rep}')

En este ejemplo, se ha utilizado la técnica de validación cruzada con GridSearchCV para ajustar los hiperparámetros del árbol de decisión. También se ha incorporado la estandarización de características utilizando StandardScaler.

Ejemplo 3

Crear un árbol de decisiones con datos ficticios usando el código Python en el area de la medicina para un caso de clasificación binaria para el diagnóstico médico para predecir si el paciente tiene diabetes o no, incluir visualizaciones y tablas comparativas con los resultados alcanzados. Utilizando las bibliotecas matplotlib y seaborn para visualizaciones, y pandas para crear tablas comparativas.

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

from sklearn.preprocessing import StandardScaler

# Cargar datos ficticios desde el archivo CSV

data = pd.read_csv('datos_csv.csv')

# Dividir datos en características (X) y etiquetas (y)

X = data.drop('Diabetes', axis=1)

y = data['Diabetes']

# Escalar características

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

# Dividir datos escalados en conjunto de entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# Crear y entrenar el árbol de decisiones

model = DecisionTreeClassifier(random_state=42)

model.fit(X_train, y_train)

# Realizar predicciones en el conjunto de prueba

y_pred = model.predict(X_test)

# Evaluar el rendimiento del modelo

accuracy = accuracy_score(y_test, y_pred)

conf_matrix = confusion_matrix(y_test, y_pred)

classification_rep = classification_report(y_test, y_pred)

# Visualizar la matriz de confusión

plt.figure(figsize=(8, 6))

sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False)

plt.title('Matriz de Confusión')

plt.xlabel('Predicciones')

plt.ylabel('Valores Verdaderos')

plt.show()

# Tabla comparativa de resultados

results_df = pd.DataFrame({

    'Métrica': ['Accuracy'],

    'Modelo': [accuracy]

})

# Mostrar resultados en forma de tabla

print("\nTabla Comparativa de Resultados:")

print(results_df)

# Visualizar características más importantes

feature_importances = model.feature_importances_

feature_names = X.columns

plt.figure(figsize=(10, 6))

sns.barplot(x=feature_importances, y=feature_names, palette='viridis')

plt.title('Importancia de las Características')

plt.xlabel('Importancia')

plt.ylabel('Características')

plt.show()

Este código añade:

Visualización de la matriz de confusión.

Una tabla comparativa de resultados.

Visualización de la importancia de las características.

Aplicación Práctica: K-Means (Aprendizaje No Supervisado)

 

Definición del Algoritmo K-Means: K-Means es un algoritmo de agrupamiento (clustering) que se utiliza para dividir un conjunto de datos en grupos homogéneos llamados "clusters". Su objetivo principal es agrupar datos similares en conjuntos y asignar etiquetas a los grupos. El número de clusters, denotado por "k", es un parámetro que se establece antes de ejecutar el algoritmo.

Pasos del Algoritmo K-Means:

1.     Inicialización de Centroides:

Selecciona aleatoriamente K puntos del conjunto de datos como centroides iniciales. Un centroide es el punto representativo de un cluster.

2.     Asignación de Puntos a Clúster:

Asigna cada punto del conjunto de datos al cluster cuyo centroide está más cercano. Esto se hace generalmente utilizando la distancia euclidiana.

3.     Actualización de Centroides:

Recalcula los centroides de cada cluster tomando la media de todos los puntos asignados a ese cluster.

4.     Repetición:

Repite los pasos 2 y 3 hasta que los centroides de los clusters no cambien significativamente o hasta que se alcance un número predeterminado de iteraciones.

Funcionamiento del Algoritmo:

·     El algoritmo trata de minimizar la suma de las distancias cuadradas entre cada punto y el centroide de su cluster asignado.

·       En cada iteración, los puntos pueden cambiar de cluster, y los centroides se recalculan.

·       El algoritmo converge cuando los centroides ya no cambian significativamente o cuando se alcanza un número máximo de iteraciones.

Aplicaciones y Usos de K-Means:

1.     Segmentación de Clientes:

En marketing, K-Means puede utilizarse para segmentar clientes en grupos con características similares, facilitando estrategias de marketing personalizadas.

2.     Compresión de Imágenes:

Puede aplicarse para comprimir imágenes, reduciendo la cantidad de colores utilizados mientras se mantiene la calidad visual.

3.     Agrupamiento de Documentos:

En minería de texto, se puede utilizar para agrupar documentos similares, facilitando la organización y búsqueda de información.

4.     Análisis de Datos Biológicos:

En biología, K-Means se ha utilizado para analizar patrones en datos genéticos y clasificar genes.

5.     Detección de Anomalías:

Puede identificar patrones inusuales en conjuntos de datos, siendo útil en la detección de anomalías o fraudes.

Ejemplo 1

Ejemplo práctico con Python utilizando la biblioteca scikit-learn para aplicar el algoritmo K-Means y matplotlib para realizar algunas visualizaciones.

Este código realiza los siguientes pasos:

Importa las bibliotecas necesarias (NumPy, pandas, matplotlib, scikit-learn).

Crea un DataFrame con los datos de los clientes.

Escala los datos para que tengan la misma magnitud.

Aplica el algoritmo K-Means con K=3 clusters.

Visualiza los resultados mediante un gráfico de dispersión, coloreando cada punto según su cluster y marcando los centroides en rojo.

Este ejemplo proporcionará una representación visual de cómo se han agrupado los clientes. 

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from sklearn.cluster import KMeans

from sklearn.preprocessing import StandardScaler

# Datos de clientes

data = {

    'Frecuencia': [10, 5, 2, 8, 3, 12, 6, 15, 4, 9],

    'Monto_Gastado': [500, 200, 1000, 800, 150, 600, 300, 1200, 250, 700]

}

df = pd.DataFrame(data)

# Escalamos los datos para que tengan la misma escala

scaler = StandardScaler()

scaled_data = scaler.fit_transform(df)

# Aplicamos K-Means con K=3 clusters

kmeans = KMeans(n_clusters=3, random_state=42)

df['Cluster'] = kmeans.fit_predict(scaled_data)

# Visualizamos los resultados

plt.figure(figsize=(10, 6))

# Scatter plot para mostrar los clusters

for cluster in df['Cluster'].unique():

    plt.scatter(df[df['Cluster'] == cluster]['Frecuencia'],

                df[df['Cluster'] == cluster]['Monto_Gastado'],

                label=f'Cluster {cluster}')

# Centroides

plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1],

            marker='X', s=200, c='red', label='Centroides')

plt.title('Segmentación de Clientes con K-Means')

plt.xlabel('Frecuencia de Compra')

plt.ylabel('Monto Total Gastado')

plt.legend()

plt.show()

/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:870: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning warnings.warn(

Ejemplo 1

Vamos a crear un conjunto de datos ficticios para la aplicación de K-Means en la segmentación de clientes para una empresa de gimnasio. Supongamos que tenemos los siguientes datos:

Nombre del Cliente

Antigüedad del Cliente en meses

Frecuencia que asiste al GYM por semana

Precio de la entrada por mes

Utilizaremos estos datos para segmentar a los clientes en clusters y visualizar los resultados. con Python utilizando scikit-learn y matplotlib:

Este código crea un conjunto de datos ficticios para clientes de un gimnasio, aplica el algoritmo K-Means con K=3 clusters y visualiza los resultados en un gráfico de dispersión.

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from sklearn.cluster import KMeans

from sklearn.preprocessing import StandardScaler

# Crear datos ficticios

np.random.seed(42)

clientes = {

    'Nombre': ['Cliente A', 'Cliente B', 'Cliente C', 'Cliente D', 'Cliente E', 'Cliente F', 'Cliente G', 'Cliente H', 'Cliente I', 'Cliente J'],

    'Antiguedad': np.random.randint(1, 36, 10),  # Antigüedad en meses

    'Frecuencia_Semanal': np.random.randint(1, 6, 10),  # Frecuencia de asistencia al GYM por semana

    'Precio_Entrada': np.random.uniform(30, 80, 10)  # Precio de entrada por mes

}

df_gym = pd.DataFrame(clientes)

# Escalar los datos para que tengan la misma magnitud

scaler = StandardScaler()

scaled_data_gym = scaler.fit_transform(df_gym.drop('Nombre', axis=1))

# Aplicar K-Means con K=3 clusters

kmeans_gym = KMeans(n_clusters=3, random_state=42)

df_gym['Cluster'] = kmeans_gym.fit_predict(scaled_data_gym)

# Visualizar los resultados

plt.figure(figsize=(10, 6))

# Scatter plot para mostrar los clusters

for cluster in df_gym['Cluster'].unique():

    plt.scatter(df_gym[df_gym['Cluster'] == cluster]['Frecuencia_Semanal'],

                df_gym[df_gym['Cluster'] == cluster]['Precio_Entrada'],

                label=f'Cluster {cluster}')

# Centroides

plt.scatter(kmeans_gym.cluster_centers_[:, 1], kmeans_gym.cluster_centers_[:, 2],

            marker='X', s=200, c='red', label='Centroides')

# Etiquetas y título

plt.title('Segmentación de Clientes del Gimnasio con K-Means')

plt.xlabel('Frecuencia Semanal de Asistencia al GYM')

plt.ylabel('Precio de la Entrada por Mes')

plt.legend()

plt.show()

/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:870: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning warnings.warn(

 

Ejemplo 2

Del ejemplo 1 se va a ajustar el número de clusters, explorando diferentes características y analizando las segmentaciones resultantes. Utilizaremos un número diferente de clusters (por ejemplo, K=4) y visualizaremos la segmentación en tablas y gráficos. Se mostrará estadísticas descriptivas para cada cluster.

Código actualizado: Este código ajusta el número de clusters a 4 y presenta un gráfico de dispersión con los puntos coloreados según su cluster. También se imprime una tabla con la segmentación de clientes y estadísticas descriptivas por cluster.

La interpretación de los clusters puede depender de la naturaleza específica de los datos y del contexto del negocio.

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from sklearn.cluster import KMeans

from sklearn.preprocessing import StandardScaler

# Crear datos ficticios

np.random.seed(42)

clientes = {

    'Nombre': ['Cliente A', 'Cliente B', 'Cliente C', 'Cliente D', 'Cliente E', 'Cliente F', 'Cliente G', 'Cliente H', 'Cliente I', 'Cliente J'],

    'Antiguedad': np.random.randint(1, 36, 10),  # Antigüedad en meses

    'Frecuencia_Semanal': np.random.randint(1, 6, 10),  # Frecuencia de asistencia al GYM por semana

    'Precio_Entrada': np.random.uniform(30, 80, 10)  # Precio de entrada por mes

}

df_gym = pd.DataFrame(clientes)

# Escalar los datos para que tengan la misma magnitud

scaler = StandardScaler()

scaled_data_gym = scaler.fit_transform(df_gym.drop('Nombre', axis=1))

# Aplicar K-Means con K=4 clusters

kmeans_gym = KMeans(n_clusters=4, random_state=42)

df_gym['Cluster'] = kmeans_gym.fit_predict(scaled_data_gym)

# Visualizar los resultados

plt.figure(figsize=(12, 8))

# Scatter plot para mostrar los clusters

for cluster in df_gym['Cluster'].unique():

    plt.scatter(df_gym[df_gym['Cluster'] == cluster]['Frecuencia_Semanal'],

                df_gym[df_gym['Cluster'] == cluster]['Precio_Entrada'],

                label=f'Cluster {cluster}')

# Centroides

plt.scatter(kmeans_gym.cluster_centers_[:, 1], kmeans_gym.cluster_centers_[:, 2],

            marker='X', s=200, c='red', label='Centroides')

# Etiquetas y título

plt.title('Segmentación de Clientes del Gimnasio con K-Means (K=4)')

plt.xlabel('Frecuencia Semanal de Asistencia al GYM')

plt.ylabel('Precio de la Entrada por Mes')

plt.legend()

plt.show()

# Tabla de segmentación

segmentacion_table = df_gym[['Nombre', 'Cluster']].sort_values(by='Cluster')

print("Tabla de Segmentación:")

print(segmentacion_table)

# Estadísticas descriptivas por cluster

estadisticas_por_cluster = df_gym.groupby('Cluster').describe().transpose()

print("\nEstadísticas Descriptivas por Cluster:")

print(estadisticas_por_cluster)

/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:870: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning warnings.warn(