Reducción Dimensiones Usando Entropía

Para este algoritmo se utilizó el algoritmo de Distancia de Hamming y se realizaron todas las adecuaciones para ir buscando la mínima entropía eliminando columnas de datos hasta al final tener solamente 2 columnas. Tener en cuenta que como el desarrollo se realizo en c# las columnas inician en 0.

Para ayuda de vectores se usó la librería Math.Net Numerics

public static string Entropy(ArrayList arrText)
{
    string retorno = "";
    //Total de columnas
    string sT = arrText[0].ToString();
    double F = (double)Tools.ContarEjemplos(sT, ",");
    double E = 0;
    int i, j = 0;
    DenseMatrix S = new DenseMatrix(arrText.Count, arrText.Count, 0);

    for (i = 0; i < arrText.Count; i++)
    {
        for (j = i + 1; j < arrText.Count; j++)
        {
            S[i, j] = Tools.HammingDistance(arrText[i].ToString().Replace(",", ""), arrText[j].ToString().Replace(",", "")) / F;
        }
    }
    //A diferencia de la formula en c# la matrix inicia en 0, 0
    for (i = 0; i < arrText.Count - 1; i++)
    {
        for (j = i + 1; j < arrText.Count; j++)
        {
            if (S[i, j] > 0 && S[i, j] < 1)
            {
                E += (S[i, j] * Math.Log10(S[i, j]) + (1 - S[i, j]) * Math.Log10(1 - S[i, j]));
            }
        }
    }
    E = -1 * E;
    //Calcular las entropias eliminando una columna. Se guarda la minima.
    double MinE = E;
    double NewE = E;
    int indiceMinE = 0;
    double TempE = 0;
    int totalF = (int)F;
    for (int features = totalF; features >= 2; features--)
    {
        F = features;
        indiceMinE = 0;
        for (int f = 0; f < F; f++)
        {
            S.Clear();
            TempE = 0;

            for (i = 0; i < arrText.Count; i++)
            {
                for (j = i + 1; j < arrText.Count; j++)
                {
                    S[i, j] = Tools.HammingDistance(arrText[i].ToString().Replace(",", "").Remove(f, 1), arrText[j].ToString().Replace(",", "").Remove(f, 1)) / (F - 1);
                }
            }
            //A diferencia de la formula en c# la matrix inicia en 0, 0
            for (i = 0; i < arrText.Count - 1; i++)
            {
                for (j = i + 1; j < arrText.Count; j++)
                {
                    if (S[i, j] > 0 && S[i, j] < 1)
                    {
                        TempE += (S[i, j] * Math.Log10(S[i, j]) + (1 - S[i, j]) * Math.Log10(1 - S[i, j]));
                    }
                }
            }
            TempE = -1 * TempE;
            if (Math.Abs(E - TempE) < MinE)
            {
                MinE = Math.Abs(E - TempE);
                NewE = TempE;
                indiceMinE = f;
            }
        }
        //Se suma 1 al indice porque en c# los indices inician en 0
        retorno += "Columna con Entropia minima: " + (indiceMinE + 1).ToString() + "\n";
        //Eliminar la caracteristica del conjunto de datos
        for (i = 0; i < arrText.Count; i++)
        {
            arrText[i] = arrText[i].ToString().Replace(",", "").Remove(indiceMinE, 1);
        }
        //Asignar el nuevo E
        E = NewE;
        MinE = E;
    }
    return retorno;
}

Para la prueba de este algoritmo se usaron los siguientes datos como datos de prueba:

X,1,U,5,P,A
Y,2,D,7,O,B
Y,2,U,8,Q,C
X,1,U,7,O,B
Z,3,P,8,Q,C
Y,2,P,5,P,A
X,3,U,5,P,A

Resultados Obtenidos:
Columna con Entropía mínima: 4
Columna con Entropía mínima: 1
Columna con Entropía mínima: 3
Columna con Entropía mínima: 1
Columna con Entropía mínima: 1


Los resultados indican:

Iteración 1: La columna que minimiza la diferencia entre la entropía F y el valor correspondiente a la entropía sin esa columna es la 4. Eliminando esa columna del conjunto de datos obtenemos:

X,1,U,P,A
Y,2,D,O,B
Y,2,U,Q,C
X,1,U,O,B
Z,3,P,Q,C
Y,2,P,P,A
X,3,U,P,A

Iteración 2: La columna que minimiza la diferencia entre la entropía F y el valor correspondiente a la entropía sin esa columna es la 1. Eliminando esa columna del conjunto de datos obtenemos:

1,U,P,A
2,D,O,B
2,U,Q,C
1,U,O,B
3,P,Q,C
2,P,P,A
3,U,P,A

Iteración 3: La columna que minimiza la diferencia entre la entropía F y el valor correspondiente a la entropía sin esa columna es la 3. Eliminando esa columna del conjunto de datos obtenemos:

1,U,A
2,D,B
2,U,C
1,U,B
3,P,C
2,P,A
3,U,A

Iteración 4: La columna que minimiza la diferencia entre la entropía F y el valor correspondiente a la entropía sin esa columna es la 1. Eliminando esa columna del conjunto de datos obtenemos:

U,A
D,B
U,C
U,B
P,C
P,A
U,A

Iteración 5: La columna que minimiza la diferencia entre la entropía F y el valor correspondiente a la entropía sin esa columna es la 1. Eliminando esa columna del conjunto de datos obtenemos:

A
B
C
B
C
A
A

Al visualizar los resultados obtenidos podemos tener una visualización inicial de un ranking de importancia para cada una de las columnas o características de nuestro conjunto de datos. Esto por si deseamos posteriormente reducir la dimensión de este.