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

One-Hot Encoding es un esquema de codificación común y fundamental que se utiliza en el aprendizaje automático y la ciencia de datos. En este artículo, abordaremos la codificación One-Hot con Pandas y Scikit-Learn en Python.

Introducción

En informática, los datos se pueden representar de muchas maneras diferentes y, naturalmente, cada una de ellas tiene sus ventajas y desventajas en ciertos 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 estar preparada si queremos que una computadora pueda procesarla.

Esta acción se llama preprocesamiento. Una gran parte del preprocesamiento es codificación: representar cada pieza de datos de una manera que una computadora pueda entender (el nombre literalmente significa "convertir a código de computadora").

En muchas ramas de la informática, especialmente en el aprendizaje automático y el diseño de circuitos digitales, One-Hot Encoding se usa 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-Aprender](https:// scikit-learn.org/). También compararemos su efectividad con otros tipos de representación en computadoras, sus puntos fuertes y débiles, 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 un booleano que especifica una categoría del elemento.

También existe una implementación similar llamada One-Cold Encoding, donde todos los elementos en 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 múltiples 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 código binario, Gray y one-hot:

Decimal Binario Código Gray One-Hot


0 000 000 0000000 1 001 001 0000001 2 010 011 0000010 3 011 010 0000100 4 100 110 0001000 5 101 111 0010000 6 110 101 0100000 7 111 100 1000000

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? ¿Este es el número 2? ... ¿Es este el número 7?

Cada "0" es "falso" y una vez que encontramos un "1" en un vector, la respuesta a la pregunta es "verdadero".

La codificación one-hot transforma características categóricas a un formato que funciona mejor con 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 de aproximación basadas en valores de retorno anteriores) y algunos pueden ser óptimos para la clasificación (categorización en conjuntos/clases fijos, típicamente binarios):


identificación de la etiqueta fresa 1 manzana 2 sandía 3 limón 4 melocotón 5 naranja 6


Aquí tenemos seis entradas de muestra de datos categóricos. El tipo de codificación que se usa aquí se denomina "codificación de etiquetas", y es muy simple: solo 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 efectivo, porque 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 ordinales.

Si representáramos estas categorías en una codificación one-hot, en realidad reemplazaríamos las filas con columnas. Hacemos esto creando una columna ‘booleana’ 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 Durazno Naranja ID 1 0 0 0 0 0 1 0 1 0 0 0 0 2 0 0 1 0 0 0 3 0 0 0 1 0 0 4 0 0 0 0 1 0 5 0 0 0 0 0 1 6


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 valores n, mientras que la codificación binaria o Gray puede representar valores 2^n^ utilizando 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:

1
2
3
4
5
6
7
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 dataframe de Pandas, llamado df utilizando dos listas, es decir, ids y countries. Si llama al método head() en el marco de datos, debería ver el siguiente resultado:

1
df.head()

dataframe header one hot encoding

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

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

Pasamos País como el valor para el atributo prefijo del método get_dummies(), por lo tanto, puede ver la cadena País con el prefijo antes del encabezado de cada una de las columnas codificadas en caliente en la salida.

Ejecutar este código produce:

1
2
3
4
5
6
   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 usar otra biblioteca popular: Scikit-Learn. Ofrece tanto la clase OneHotEncoder como la clase LabelBinarizer para este propósito.

Primero, comencemos importando LabelBinarizer:

1
from sklearn.preprocessing import LabelBinarizer

Y luego, usando el mismo marco de datos que antes, vamos a crear una instancia de LabelBinarizer y ajustarlo:

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

Imprimir y produciría:

1
2
3
4
5
[[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.

De manera similar, podemos usar la clase OneHotEncoder, que admite datos de varias columnas, a diferencia de la clase anterior:

1
from sklearn.preprocessing import OneHotEncoder

Y luego, completemos una lista y ajústela en el codificador:

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

Ejecutar esto producirá:

1
2
3
4
5
[[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 de Machine Learning y Digital Circuit Design.

Aprendizaje automático {#aprendizaje automático}

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 limitado (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 aprendizaje automático reciben datos de muestra ("datos de entrenamiento") de los que se extraen las características. Con base en estas características, se crea un modelo matemático, que luego se usa para hacer predicciones o decisiones sin estar programado explícitamente para realizar estas tareas.

Un buen ejemplo sería Clasificación, donde la entrada puede ser técnicamente ilimitada, pero la salida generalmente se limita a unas pocas clases. En el caso de la clasificación binaria (digamos que estamos enseñando una red neuronal para clasificar gatos y perros), 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 la fruta mencionado anteriormente. Una vez más, si bien esto tiene mucho sentido para nosotros, las palabras en sí no tienen 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 {#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 estados finitos one-hot no necesita el decodificador, porque si el bit nth es alto, la máquina está, lógicamente, en el estado nth.

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 en 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 se establecen en '0', excepto el primero, que se establece en '1'.

El siguiente flanco 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 la codificación one-hot en el diseño de circuitos digitales sería un descodificador de dirección, 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 (se muestra en la imagen de abajo).

Es exactamente lo contrario y toma la entrada one-hot y la convierte a binario o gris:

digital circuit design

Ventajas y desventajas de la codificación one-hot {#ventajas y desventajas de la codificación one-hot}

Como cualquier otro tipo de codificación, one-hot tiene muchos puntos buenos así como aspectos 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 igual de rápido, ya que solo necesita acceder a dos flip-flops.

Otra gran ventaja de la codificación one-hot es la 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, lo 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 (para n estados, necesitaríamos n dígitos - o flip-flops ). Esta es la razón por la que, si quisiéramos implementar un contador de anillo de 15 estados en caliente, por ejemplo, necesitaríamos 15 flip-flops, mientras que la implementación binaria solo necesitaría tres flip-flops.

Esto lo hace especialmente poco práctico para dispositivos PAL, y también puede ser muy costoso, pero aprovecha los abundantes flip-flops de un FPGA.

Otro problema con este tipo de codificación es que muchos de los estados en una máquina de estado finito serían ilegales: por cada n estados válidos, hay (2^n^ - 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 sorprende 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 pros superan claramente a los contras, por lo que este tipo de implementación definitivamente se mantendrá durante mucho tiempo en el futuro.