Data Science in 5 Minutes: What is One Hot Encoding?

Let’s apply this to an example. Say we have the values red and blue. With one-hot, we would assign red with a numeric value of 0 and blue with a numeric value of 1.

It’s crucial to be consistent when we use these values. This makes it possible to invert our encoding at a later point to get our original categorical back.

Once we assign numeric values, we create a binary vector that represents our numerical values. In this case, our vector will have 2 as its length since we have 2 values. Thus, the red value can be represented with the binary vector [1,0], and the blue value will be represented as [0,1].

One hot encoding is useful for data that has no relationship to each other. Machine learning algorithms treat the order of numbers as an attribute of significance. In other words, they will read a higher number as better or more important than a lower number.

While this is helpful for some ordinal situations, some input data does not have any ranking for category values, and this can lead to issues with predictions and poor performance. That’s when one hot encoding saves the day.

One hot encoding makes our training data more useful and expressive, and it can be rescaled easily. By using numeric values, we more easily determine a probability for our values. In particular, one hot encoding is used for our output values, since it provides more nuanced predictions than single labels.

Manually converting our data to numerical values includes two basic steps:

• Integer encoding
• One hot encoding

For the first step, we need to assign each category value with an integer, or numeric, value. If we had the values red, yellow, and blue, we could assign them 1, 2, and 3 respectively.

When dealing with categorical variables that have no order or relationship, we need to take this one step further. Step two involves applying one-hot encoding to the integers we just assigned. To do this, we remove the integer encoded variable and add a binary variable for each unique variable.

Above, we had three categories, or colors, so we use three binary variables. We place the value 1 as the binary variable for each color and the value 0 for the other two colors.

red,    yellow,  blue
1,      0,      0
0,      1,      0
0,      0,      1

Note: In many other fields, binary variables are referred to as dummy variables.

We don’t have to one hot encode manually. Many data science tools offer easy ways to encode your data. The Python library Pandas provides a function called get_dummies to enable one-hot encoding.

df_new = pd.get_dummies(df, columns=["col1"], prefix="Planet")

Let’s see this in action.

import pandas as pd 
df = pd.DataFrame({"col1": ["Sun", "Sun", "Moon", "Earth", "Moon", "Venus"]})
print("The original data")
print(df)
print("*" * 30)
df_new = pd.get_dummies(df, columns=["col1"], prefix="Planet")
print("The transform data using get_dummies")
print(df_new)

• Line 7 shows that we’re using get_dummies to do one-hot encoding for a pandas DataFrame object. The parameter prefix indicates the prefix of the new column name.
• Line 9 shows us our output.

Let’s apply this to a practical example. Say we have the following dataset.

import pandas as pd
ids = [11, 22, 33, 44, 55, 66, 77]
countries = ['Seattle', 'London', 'Lahore', 'Berlin', 'Abuja']
df = pd.DataFrame(list(zip(ids, countries)),
columns=['Ids', 'Cities'])

Here we have a Pandas dataframe called df with two lists: ids and Cities. Let’s call the head() to get this result:

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

import pandas as pddf = pd.DataFrame({"col1": ["Seattle", "London", "Lahore", "Berlin", "Abuja"]})print("The original data")print(df)print("*" * 30)df_new = pd.get_dummies(df, columns=["col1"], prefix="Cities")print("The transform data using get_dummies")print(df_new)

import sklearn.preprocessing as preprocessingimport numpy as npimport pandas as pdtargets = np.array(["red", "green", "blue", "yellow", "pink",      "white"])labelEnc = preprocessing.LabelEncoder()new_target = labelEnc.fit_transform(targets)onehotEnc = preprocessing.OneHotEncoder()onehotEnc.fit(new_target.reshape(-1, 1))targets_trans = onehotEnc.transform(new_target.reshape(-1, 1))print("The original data")print(targets)print("The transform data using OneHotEncoder")print(targets_trans.toarray())

from sklearn.preprocessing import OneHotEncoder

x = [[11, "Seattle"], [22, "London"], [33, "Lahore"], [44, "Berlin"], [55, "Abuja"]]y = OneHotEncoder().fit_transform(x).toarray()print(y)

[[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.]]