Implementaciones en python

Para implementar el algoritmo K-Means sobre el dataset iris.arff en Python sin usar Weka, podemos utilizar la biblioteca scikit-learn, que proporciona una implementación directa de K-Means. A continuación te muestro cómo cargar el dataset iris.arff, aplicar K-Means y visualizar los resultados.

Pasos:

1. Instalación de dependencias: Si no tienes las bibliotecas necesarias, ejecuta el siguiente comando:

   pip install scikit-learn scipy pandas matplotlib
   

2. Código en Python para implementar K-Means:

from scipy.io import arff
import pandas as pd
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA

# Cargar el archivo iris.arff
data, meta = arff.loadarff('iris.arff')

# Convertir el dataset a un DataFrame de pandas
df = pd.DataFrame(data)

# Convertir la columna 'class' de bytes a string
df['class'] = df['class'].apply(lambda x: x.decode('utf-8'))

# Separar las características (X)
X = df.drop('class', axis=1)

# Aplicar el algoritmo KMeans con 3 clusters (correspondientes a las 3 especies de iris)
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(X)

# Predecir los clusters a los que pertenecen las instancias
y_kmeans = kmeans.predict(X)

# Mostrar los centros de los clusters
print("Centroides de los clusters:\n", kmeans.cluster_centers_)

# Visualización de los clusters con reducción de dimensionalidad usando PCA
pca = PCA(2)
X_pca = pca.fit_transform(X)

# Colores para los clusters
colors = ['red', 'green', 'blue']

# Graficar los clusters
plt.figure(figsize=(8, 6))
for i in range(3):
    plt.scatter(X_pca[y_kmeans == i, 0], X_pca[y_kmeans == i, 1], 
                s=100, c=colors[i], label=f'Cluster {i}')

# Graficar los centroides
centroids_pca = pca.transform(kmeans.cluster_centers_)
plt.scatter(centroids_pca[:, 0], centroids_pca[:, 1], s=300, c='yellow', label='Centroides', marker='X')

plt.title('Clusters de Iris usando K-Means')
plt.xlabel('Componente Principal 1')
plt.ylabel('Componente Principal 2')
plt.legend()
plt.show()

# Evaluación: Mostrar la cantidad de instancias en cada cluster
print("\nCantidad de instancias por cluster:")
print(pd.Series(y_kmeans).value_counts())

Explicación del código:

1. Carga del dataset iris.arff: Utilizamos scipy.io.arff para cargar el archivo ARFF y luego lo convertimos en un DataFrame de pandas para un manejo más fácil de los datos.
2. Preprocesamiento:
   • La columna class (que contiene las especies de iris) se elimina ya que K-Means es un algoritmo no supervisado y no requiere las etiquetas.
3. Aplicación de K-Means:
   • Definimos KMeans con 3 clusters ya que sabemos que el dataset Iris tiene tres especies diferentes de flores.
   • El modelo se ajusta a los datos y luego se predicen los clusters para cada instancia.
4. Visualización:
   • Usamos PCA (Principal Component Analysis) para reducir las dimensiones de los datos a 2, de modo que podamos visualizarlos fácilmente en un gráfico.
   • Se grafican los puntos de cada cluster y los centroides obtenidos por K-Means.
5. Evaluación:
   • Se muestran los centroides de los clusters, que son las coordenadas promedio de los puntos en cada cluster.
   • Se cuenta cuántas instancias quedaron asignadas a cada cluster.

Ejemplo de Salida:

1. Centroides de los clusters:

Centroides de los clusters:
[[6.85384615 3.07692308 5.71538462 2.05384615]
 [5.006      3.428      1.462      0.246     ]
 [5.88360656 2.74098361 4.38852459 1.43442623]]

1. Cantidad de instancias por cluster:

Cantidad de instancias por cluster:
0    65
2    50
1    35
dtype: int64

Visualización:

El gráfico generado mostrará los puntos distribuidos en tres clusters (en rojo, verde y azul), con los centroides de cada cluster marcados como una “X” amarilla.

Aquí tienes un ejemplo que utiliza DBSCAN para detectar clusters en un conjunto de datos más complejo con ruido y clusters de diferentes densidades. Este ejemplo muestra cómo ajustar el parámetro eps en DBSCAN y visualizar los resultados.

Usaremos make_moons de sklearn.datasets para generar datos en forma de media luna y agregar un poco de ruido, lo que hace que sea un desafío para los algoritmos de clustering tradicionales.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import DBSCAN
from sklearn.datasets import make_moons
from sklearn.preprocessing import StandardScaler

# Generar datos en forma de media luna con ruido
X, y = make_moons(n_samples=300, noise=0.1, random_state=42)

# Escalar datos para que DBSCAN funcione mejor
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Ajustar el modelo DBSCAN con diferentes valores de eps
dbscan = DBSCAN(eps=0.2, min_samples=5)
clusters = dbscan.fit_predict(X_scaled)

# Visualización
plt.figure(figsize=(10, 6))
plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=clusters, cmap='viridis', s=50)
plt.title("DBSCAN clustering with eps=0.2")
plt.xlabel("Feature 1 (scaled)")
plt.ylabel("Feature 2 (scaled)")
plt.colorbar(label="Cluster Label")
plt.show()

Explicación de los parámetros

• eps=0.2: El radio dentro del cual DBSCAN considera vecinos. Valores bajos pueden crear muchos clusters pequeños, mientras que valores más altos pueden agrupar más puntos.
• min_samples=5: Número mínimo de puntos necesarios para formar un cluster. Esto ayuda a definir la densidad.

Interpretación del Resultado

• Los puntos con el mismo color pertenecen al mismo cluster.
• Los puntos etiquetados como -1 en clusters son considerados ruido, es decir, no forman parte de ningún cluster.

Este tipo de ajuste de DBSCAN funciona bien con datos no lineales y distribuidos en formas complejas, como las formas de media luna, y es ideal para detectar tanto clusters como puntos ruidosos.