Algoritmos de Discretización Binning

En Mineria de Datos una de las técnicas que podemos emplear para realizar la discretización de nuestros datos es la de separar nuestros datos en BINs (Binning discretization).

Esta discretización hace parte del pre-procesamieto inicial que debemos realizar a los datos.

El desarrollo de los algoritmos se realizó en .NET con el lenguaje c#. Para ayuda de vectores se usó la librería Math.Net Numerics.

Para los resultados aquí mostrados se usaron 3 Bins y se usaron los siguientes datos:
3,2,1,5,4,3,1,7,5,3,8,10,9,5,5,2

Para el algoritmo BIN se implementaron los siguientes modos:

Anchos Iguales (BIN Equal-Width)
Este algoritmo organiza los Bins en grupos donde el salto de cada uno es: (maximo-minimo)/N, donde N es el numero de bins que se desean.

public static DenseVector[] ObtenerBinsEqualWidth(double[] data, int nBins)
{
    int i = 0;

    double maximo = data.Max();
    double minimo = data.Min();

    //Se organizan los Bins con saltos iguales
    double salto = (maximo - minimo) / nBins;

    //Organizar de menor a mayor el arreglo
    var sortedlData = data.OrderBy(x => x);

    DenseVector[] vBins = new DenseVector[0];

    i = 0;
    double inicial = minimo;
    while (i < nBins)
    {
        //Redimensiona el arreglo para el nuevo BIN y luego asigna los items cuyo index se encuentre en el rango.
        Array.Resize(ref vBins, vBins.Length + 1);
        vBins[i] = new DenseVector(sortedlData.Where((x, index) => x >= inicial && x <= inicial + salto).ToArray());
        i++;
        inicial = i * salto + 1;
    }

    return vBins;
}

Resultados:
Bin 1: 1,1,2,2,3,3,3,4
Bin 2: 5,5,5,5,7,8
Bin 3: 9,10

Como el salto en este caso 10-1/3 es 3 el primer grupo tiene de 1 hasta 1+3=4, el segundo tiene desde 5 hasta 5+3=8 y el ultimo tiene los restantes.

Igualando Cantidad x Grupo (BIN Equal-Depth)
Este algoritmo distribuye uniformemente los datos dentro de los grupos tratando de que cada grupo quede con la misma cantidad de datos.

En caso de no lograr asignar la misma cantidad de datos a cada grupo, los primeros grupos quedan con un dato de más.
public static DenseVector[] ObtenerBinsEqualDepth(double[] data, int nBins)
{
    int i = 0;
    //Organizar de menor a mayor el arreglo
    var sortedlData = data.OrderBy(a => a);

    //BIN Equal-Depth
    int tam, res;
    DenseVector[] vBins = new DenseVector[0];
    //Realizar division Entera y Residuo para sacar tamaño de grupos
    tam = Math.DivRem(data.Length, nBins, out res);
    i = 0;
    int indexGroup = 0;
    if (res > 0)
    {
        while (res > 0)
        {
            //Redimensiona el arreglo para el nuevo BIN y luego asigna los items cuyo index se encuentre en el rango. Se suma uno al tamaño por el residuo
            Array.Resize(ref vBins, vBins.Length + 1);
            vBins[i] = new DenseVector(sortedlData.Where((f, index) => index >= indexGroup && index < indexGroup + tam + 1).ToArray());
            indexGroup = indexGroup + tam + 1;
            i++;
            res--;
        }
    }
    while (i < nBins)
    {
        //Redimensiona el arreglo para el nuevo BIN y luego asigna los items cuyo index se encuentre en el rango.
        Array.Resize(ref vBins, vBins.Length + 1);
        vBins[i] = new DenseVector(sortedlData.Where((f, index) => index >= indexGroup && index < indexGroup + tam).ToArray());
        indexGroup = indexGroup + tam;
        i++;
    }

    return vBins;
}

Resultados:
Bin 1: 1,1,2,2,3,3
Bin 2: 3,4,5,5,5
Bin 3: 5,7,8,9,10

En este caso se trataron de distribuir la misma cantidad de números en cada bin. Como en total eran 16 datos se distribuyo 6 en el primer grupo y 5 en los dos siguientes.


Grupos con Suavizado (BIN with Smoothing)
Para este algoritmo se dejaron las opciones de valor medio y promedio de los datos.

En los dos casos se ejecuta primero el BIN Equal-Depth y sobre estos resultados se realiza el remplazo en cada bin, ya sea por el valor medio o por el promedio.
public static DenseVector[] ObtenerBinsStatistic(DenseVector[] vBins, int type)
{
    DenseVector[] vOutput = new DenseVector[vBins.Length];
    int i = 0;
    foreach (DenseVector bin in vBins)
    {
        var statistics = new DescriptiveStatistics(bin);
        if (type == 1)
        {
            vOutput[i] = new DenseVector(bin.Count, statistics.Median);
        }
        else
        {
            vOutput[i] = new DenseVector(bin.Count, statistics.Mean);
        }
        i++;
    }
    return vOutput;
}

Resultados con el valor medio:
Bin 1: 2,2,2,2,2,2
Bin 2: 5,5,5,5,5
Bin 3: 8,8,8,8,8

Si nos fijamos en estos bins el valor corresponde justo al valor medio de los resultados obtenidos con el algoritmo de BIN Equal-Depth.

Resultados con el promedio:
Bin 1: 2,2,2,2,2,2
Bin 2: 4.4,4.4,4.4,4.4,4.4
Bin 3: 7.8,7.8,7.8,7.8,7.8

Estos resultados corresponden al valor promedio  de los resultados obtenidos con el algoritmo de BIN Equal-Depth.

Comentarios

Entradas populares de este blog

Instalar programa como servicio Windows

Ejecutar programa como servicio windows server 2008

Habilitar Ping Firewall Windows 2008