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.

Comentarios

Entradas populares de este blog

Instalar programa como servicio Windows

Ejecutar programa como servicio windows server 2008

Habilitar Ping Firewall Windows 2008