Codificación One-Hot en Python con Pandas y Scikit-Learn

    Introducción

    En informática, los datos se pueden representar de muchas formas diferentes y, naturalmente, cada una de ellas tiene sus ventajas y desventajas en determinados campos.

    Dado que las computadoras no pueden procesar datos categóricos, ya que estas categorías no tienen significado para ellos, esta información debe prepararse si queremos que una computadora pueda procesarla.

    Esta acción se denomina preprocesamiento. Una gran parte del preprocesamiento es la codificación, que representa cada uno de los datos de una manera que una computadora pueda entender (el nombre significa literalmente «convertir a código de computadora»).

    En muchas ramas de la informática, especialmente en el Machine Learning y el diseño de circuitos digitales, la codificación One-Hot Encoding se utiliza ampliamente.

    En este artículo, explicaremos qué es la codificación one-hot y la implementaremos en Python usando algunas opciones populares, Pandas y Scikit-Learn. También compararemos su efectividad con otros tipos de representación en computadoras, sus puntos fuertes y debilidades, así como sus aplicaciones.

    ¿Qué es la codificación One-Hot?

    La codificación one-hot es un tipo de representación vectorial en la que todos los elementos de un vector son 0, excepto uno, que tiene 1 como valor, donde 1 representa una boolean especificando una categoría del elemento.

    También existe una implementación similar llamada One-Cold Encoding, donde todos los elementos de un vector son 1, excepto uno, que tiene 0 como valor.

    Por ejemplo, [0, 0, 0, 1, 0] y [1 ,0, 0, 0, 0] podrían ser algunos ejemplos de vectores one-hot. Una técnica similar a esta, también utilizada para representar datos, sería variables ficticias en estadística.

    Esto es muy diferente de otros esquemas de codificación, que permiten que varios bits tengan 1 como valor. A continuación se muestra una tabla que compara la representación de los números del 0 al 7 en binario, código Gray y one-hot:

    Decimal Binary Gray code One-Hot

    00000000000000
    10010010000001
    20100110000010
    30110100000100
    41001100001000
    51011110010000
    61101010100000
    71111001000000

    Prácticamente, para cada vector one-hot, hacemos n preguntas, donde n es el número de categorías que tenemos:

    ¿Es este el número 1? ¿Es este el número 2? … ¿Es este el número 7?

    Cada «0» es «falso» y una vez que damos a un «1» en un vector, la respuesta a la pregunta es «verdadera».

    La codificación one-hot transforma las características categóricas en un formato que funciona mejor con los algoritmos de clasificación y regresión. Es muy útil en métodos donde se necesitan múltiples tipos de representación de datos.

    Por ejemplo, algunos vectores pueden ser óptimos para la regresión (funciones aproximadas basadas en valores de retorno anteriores), y algunos pueden ser óptimos para la clasificación (categorización en conjuntos / clases fijos, generalmente binarios):

    ID de etiqueta

    fresa1
    manzana2
    Sandía3
    Limón4
    melocotón5
    naranja6

    Aquí tenemos seis entradas de muestra de datos categóricos. El tipo de codificación que se usa aquí se llama «codificación de etiqueta» y es muy simple: simplemente asignamos una ID para un valor categórico.

    Nuestra computadora ahora sabe cómo representar estas categorías, porque sabe cómo trabajar con números. Sin embargo, este método de codificación no es muy eficaz, ya que tiende naturalmente a dar mayor peso a los números más altos.

    No tendría sentido decir que nuestra categoría de «Fresas» es mayor o menor que «Manzanas», o que agregar la categoría «Limón» a «Melocotón» nos daría una categoría «Naranja», ya que estos valores no son ordinal.

    Si representáramos estas categorías en una codificación one-hot, en realidad reemplazaríamos las filas con columnas. Hacemos esto creando uno boolean columna para cada una de nuestras categorías dadas, donde solo una de estas columnas podría tomar el valor 1 para cada muestra:

    Fresa Manzana Sandía Limón Melocotón Naranja ID

    1000001
    0100002
    0010003
    0001004
    0000105
    0000016

    Podemos ver en las tablas anteriores que se necesitan más dígitos en la representación one-hot en comparación con el código binario o Gray. Para n dígitos, la codificación one-hot solo puede representar n valores, mientras que la codificación binaria o Gray puede representar 2n valores usando n dígitos.

    Implementación

    Pandas

    Echemos un vistazo a un ejemplo simple de cómo podemos convertir valores de una columna categórica en nuestro conjunto de datos en sus contrapartes numéricas, a través del esquema de codificación one-hot.

    Crearemos un conjunto de datos realmente simple: una lista de países y sus ID:

    import pandas as pd
    
    ids = [11, 22, 33, 44, 55, 66, 77]
    countries = ['Spain', 'France', 'Spain', 'Germany', 'France']
    
    df = pd.DataFrame(list(zip(ids, countries)),
                      columns=['Ids', 'Countries'])
    

    En el script anterior, creamos un marco de datos de Pandas, llamado df usando dos listas, es decir ids y countries. Si llamas al head() en el marco de datos, debería ver el siguiente resultado:

    df.head()
    

    los Countries La columna contiene valores categóricos. Podemos convertir los valores en el Countries columna en vectores codificados one-hot usando el get_dummies() función:

    y = pd.get_dummies(df.Countries, prefix='Country')
    print(y.head())
    

    Pasamos Country como el valor de la prefix atributo del get_dummies() método, por lo tanto, puede ver la cadena Country prefijado antes del encabezado de cada una de las columnas codificadas one-hot en la salida.

    Ejecutar este código produce:

       Country_France  Country_Germany  Country_Spain
    0               0                0              1
    1               1                0              0
    2               0                0              1
    3               0                1              0
    4               1                0              0
    

    Scikit-Learn

    Una alternativa sería utilizar otra biblioteca popular: Scikit-Learn. Ofrece tanto la OneHotEncoder clase y el LabelBinarizer clase para este propósito.

    Primero, comencemos importando el LabelBinarizer:

    from sklearn.preprocessing import LabelBinarizer
    

    Y luego, usando el mismo marco de datos que antes, instanciamos el LabelBinarizer y encajarlo:

    y = LabelBinarizer().fit_transform(df.Countries)
    

    Impresión y rendiría:

    [[0 0 1]
     [1 0 0]
     [0 0 1]
     [0 1 0]
     [1 0 0]]
    

    Sin embargo, esto no es tan bonito como el enfoque de Pandas.

    Del mismo modo, podemos utilizar el OneHotEncoder class, que admite datos de varias columnas, a diferencia de la clase anterior:

    from sklearn.preprocessing import OneHotEncoder
    

    Y luego, completemos una lista y colóquela en el codificador:

    x = [[11, "Spain"], [22, "France"], [33, "Spain"], [44, "Germany"], [55, "France"]]
    y = OneHotEncoder().fit_transform(x).toarray()
    print(y)
    

    Ejecutar esto producirá:

    [[1. 0. 0. 0. 0. 0. 0. 1.]
     [0. 1. 0. 0. 0. 1. 0. 0.]
     [0. 0. 1. 0. 0. 0. 0. 1.]
     [0. 0. 0. 1. 0. 0. 1. 0.]
     [0. 0. 0. 0. 1. 1. 0. 0.]]
    

    Aplicaciones de la codificación One-Hot

    La codificación one-hot ha visto la mayor parte de su aplicación en los campos del Machine Learning y el diseño de circuitos digitales.

    Machine Learning

    Como se indicó anteriormente, las computadoras no son muy buenas con datos categóricos. Si bien entendemos bien los datos categóricos, se debe a un tipo de conocimiento previo que las computadoras no tienen.

    La mayoría de las técnicas y modelos de Machine Learning funcionan con un conjunto de datos muy delimitado (normalmente binario). Las redes neuronales consumen datos y producen resultados en el rango de 0..1 y rara vez iremos más allá de ese alcance.

    En resumen, la gran mayoría de los algoritmos de Machine Learning reciben datos de muestra («datos de entrenamiento») de los que se extraen características. Con base en estas características, se crea un modelo matemático, que luego se utiliza para realizar predicciones o decisiones sin estar programado explícitamente para realizar estas tareas.

    Un gran ejemplo sería la Clasificación, donde la entrada puede ser técnicamente ilimitada, pero la salida normalmente se limita a unas pocas clases. En el caso de la clasificación binaria (digamos que estamos enseñando una red neuronal para clasificar perros y gatos), tendríamos un mapeo de 0 para gatos, y 1 para perros.

    La mayoría de las veces, los datos de entrenamiento sobre los que deseamos realizar predicciones son categóricos, como el ejemplo con frutas mencionado anteriormente. Una vez más, aunque esto tiene mucho sentido para nosotros, las palabras en sí mismas no tienen ningún significado para el algoritmo, ya que no las entiende.

    El uso de codificación one-hot para la representación de datos en estos algoritmos no es técnicamente necesario, pero es bastante útil si queremos una implementación eficiente.

    Diseño de circuitos digitales

    Muchos circuitos digitales básicos utilizan la notación one-hot para representar sus valores de E / S.

    Por ejemplo, puede usarse para indicar el estado de una máquina de estados finitos. Si se usa algún otro tipo de representación, como Gray o Binary, se necesita un decodificador para determinar el estado, ya que no son tan naturalmente compatibles. Por el contrario, una máquina de estado finito de un solo calor no necesita el decodificador, porque si el enésimo bit es alto, la máquina está, lógicamente, en el enésimo estado.

    Un buen ejemplo de una máquina de estados finitos es un contador de anillo, un tipo de contador compuesto por flip-flops conectados a un registro de desplazamiento, en el que la salida de un flip-flop se conecta a la entrada del otro.

    El primer flip-flop de este contador representa el primer estado, el segundo representa el segundo estado, y así sucesivamente. Al principio, todos los flip-flops de la máquina están configurados en ‘0’, excepto el primero, que está configurado en ‘1’.

    El siguiente borde del reloj que llega a los flip flops avanza el bit «caliente» al segundo flip flop. El bit ‘caliente’ avanza así hasta el último estado, después de lo cual la máquina vuelve al primer estado.

    Otro ejemplo del uso de codificación one-hot en el diseño de circuitos digitales sería un decodificador de direcciones, que toma una entrada de código binario o Gray y luego la convierte en one-hot para la salida, así como un codificador de prioridad (que se muestra en la imagen debajo).

    Es exactamente lo contrario y toma la entrada one-hot y la convierte a Binary o Gray:

    Ventajas y desventajas de la codificación One-hot

    Como cualquier otro tipo de codificación, one-hot tiene muchos aspectos positivos y problemáticos.

    Ventajas

    Una gran ventaja de la codificación one-hot es que determinar el estado de una máquina tiene un costo bajo y constante, porque todo lo que necesita hacer es acceder a un flip-flop. Cambiar el estado de la máquina es casi tan rápido, ya que solo necesita acceder a dos flip-flops.

    Otra gran ventaja de la codificación one-hot es su fácil implementación. Los circuitos digitales hechos en esta notación son muy fáciles de diseñar y modificar. Los estados ilegales en la máquina de estados finitos también son fáciles de detectar.

    Una implementación one-hot es conocida por ser la más rápida, ya que permite que una máquina de estado se ejecute a una velocidad de reloj más rápida que cualquier otra codificación de esa máquina de estado.

    Desventajas

    Una de las principales desventajas que tiene la codificación one-hot es el hecho mencionado anteriormente de que no puede representar muchos valores (por norte estados, necesitaríamos norte dígitos – o flip-flops). Por eso, si quisiéramos implementar un contador de anillo de 15 estados de un solo estado, por ejemplo, necesitaríamos 15 flip-flops, mientras que la implementación binaria solo necesitaría tres flip-flops.

    Esto lo hace especialmente impráctico para dispositivos PAL, y también puede ser muy costoso, pero aprovecha las abundantes flip-flops de una FPGA.

    Otro problema con este tipo de codificación es que muchos de los estados en una máquina de estados finitos serían ilegales, por cada norte estados válidos, hay (2n – n) ilegales. Lo bueno es que estos estados ilegales son, como se dijo anteriormente, realmente fáciles de detectar (una puerta XOR sería suficiente), por lo que no es muy difícil cuidarlos.

    Conclusión

    Dado que la codificación one-hot es muy simple, es fácil de entender y usar en la práctica. No es de extrañar que sea tan popular en el mundo de la informática.

    Debido al hecho de que las desventajas no son tan malas, se ha visto una amplia aplicación. Al final del día, sus ventajas superan claramente a las desventajas, por lo que este tipo de implementación definitivamente se mantendrá durante mucho tiempo en el futuro.

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *