Introducción al Algoritmo K-Means

En el artículo anterior vimos los conceptos básicos de ML.NET. En esta oportunidad, exploraremos el algoritmo de clustering K-Means, una técnica fundamental para agrupar datos según su similitud.

1. Fundamentos del Algoritmo K-Means

El algoritmo K-Means es un método de clustering que agrupa objetos similares en el mismo grupo (clúster) y separa los objetos diferentes en grupos distintos. La palabra "means" (media) representa el promedio de los datos dentro de cada clúster, describiendo el centroide del grupo.

Este algoritmo utiliza la distancia como métrica de similitud: cuando la distancia entre dos objetos es menor, su similitud es mayor, y es más probablee que pertenezcan al mismo clúster. Aunque existen múltiples formas de calcluar distancias, K-Means típicamente emplea la distancia euclidiana.

Ventajas y Desventajas:

• Ventajas: Implementación sencilla y eficiente computacionalmente.
• Desventajas: Requiere especificar el número de clústeres previamente; los resultados dependen de la inicialización de los centroides; puede converger a un óptimo local; únicamente detecta clústeres esféricos.

2. Dataset Iris

El dataset Iris es un clásico en aprendizaje automático. Consiste en muestras de flores iris con cuatro atributos:

• Longitud del sépalo
• Ancho del sépalo
• Longitud del pétalo
• Ancho del pétalo

El dataset contiene tres especies: setosa, versicolor y virginica. Cada especie tiene 50 muestras, totalizando 150 registros. Cada muestra incluye las medidas del sépalo y pétalo, junto con la especie a la que pertenece.

Formato de los datos:

5.2,3.4,1.4,0.2,Iris-setosa
4.7,3.2,1.6,0.2,Iris-setosa
4.8,3.1,1.6,0.2,Iris-setosa
6.0,2.2,4.0,1.0,Iris-versicolor
6.1,2.9,4.7,1.4,Iris-versicolor
5.6,2.9,3.6,1.3,Iris-versicolor
5.7,2.5,5.0,2.0,Iris-virginica
5.8,2.8,5.1,2.4,Iris-virginica
6.4,3.2,5.3,2.3,Iris-virginica

Las primeras cuatro columnas representan las características de la flor, y la quinta columna indica la especie.

3. Implementación con ML.NET

A continuación, implementaremos el algoritmo K-Means utilizando ML.NET con el dataset Iris:

Paso 1: Crear el Proyecto

Creamos un nuevo proyecto de consola .NET Core llamado AgrupacionIris.

Paso 2: Instalar el Paquete NuGet

Agregamos el paquete Microsoft.ML en su versión 1.2.0. Descargamos el archivo de datos desde el repositorio oficial de ML.NET y lo guardamos como iris.data en una carpeta Data del proyecto.

Paso 3: Definir las Clases de Modelo

using Microsoft.ML.Data;

namespace AgrupacionIris
{
    /// <summary>
    /// Representa los datos de una flor iris
    /// </summary>
    public class FlorIris
    {
        [LoadColumn(0)]
        public float LongitudSepalo;

        [LoadColumn(1)]
        public float AnchoSepalo;

        [LoadColumn(2)]
        public float LongitudPetalo;

        [LoadColumn(3)]
        public float AnchoPetalo;
    }

    public class ResultadoAgrupacion
    {
        [ColumnName("PredictedLabel")]
        public uint IdCluster;

        [ColumnName("Score")]
        public float[] Distancias;
    }
}

Paso 4: Entrenar el Modelo

using Microsoft.ML;
using System;
using System.IO;

namespace AgrupacionIris
{
    class Program
    {
        static readonly string rutaDatos = Path.Combine(Environment.CurrentDirectory, "Data", "iris.data");
        static readonly string rutaModelo = Path.Combine(Environment.CurrentDirectory, "Data", "ModeloAgrupacionIris.zip");

        static void Main(string[] args)
        {
            var contextoML = new MLContext(seed: 0);
            IDataView vistaDatos = contextoML.Data.LoadFromTextFile<FlorIris>(rutaDatos, hasHeader: false, separatorChar: ',');
            
            string nombreColumnaFeatures = "Features";
            var pipeline = contextoML.Transforms
                .Concatenate(nombreColumnaFeatures, "LongitudSepalo", "AnchoSepalo", "LongitudPetalo", "AnchoPetalo")
                .Append(contextoML.Clustering.Trainers.KMeans(nombreColumnaFeatures, numberOfClusters: 3));
            
            var modelo = pipeline.Fit(vistaDatos);
            
            using (var flujoArchivo = new FileStream(rutaModelo, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                contextoML.Model.Save(modelo, vistaDatos.Schema, flujoArchivo);
            }
            
            Console.WriteLine("¡Entrenamiento completado!");
            Console.WriteLine("Archivo del modelo: " + rutaModelo);
            
            var predictor = contextoML.Model.CreatePredictionEngine<FlorIris, ResultadoAgrupacion>(modelo);
            
            var muestraSetosa = new FlorIris
            {
                LongitudSepalo = 5.1f,
                AnchoSepalo = 3.5f,
                LongitudPetalo = 1.4f,
                AnchoPetalo = 0.2f
            };

            var resultado = predictor.Predict(muestraSetosa);
            Console.WriteLine($"Clúster: {resultado.IdCluster}");
            Console.WriteLine($"Distancias: {string.Join(" ", resultado.Distancias)}");
            Console.WriteLine("Presione cualquier tecla para salir...");
            Console.ReadKey();
        }
    }
}

Paso 5: Ejecutar y Verificar Resultados

Al ejecutar el programa, observaremos el clúster asignado a la muestra de entrada y las distancias a cada centroide. El modelo identifica automáticamente grupos en los datos sin necesidad de etiquetas previas.

Conclusión

Hemos implementado exitosamente el algoritmo K-Means utilizando ML.NET para clustering del dataset Iris. Este ejemplo demuestra cómo agrupar datos numéricos según sus características. En el próximo artículo, exploraremos cómo aplicar clustering a datos que combinan texto y valores numéricos.