Introduction

If you encoded categories with scikit-learn's OneHotEncoder, the clean way to recover the original labels is inverse_transform. The important catch is that you need the same fitted encoder object, because the encoder stores the category order that makes the reverse mapping possible.

Fit and Transform the Data

OneHotEncoder turns each categorical column into a set of binary columns. To reverse it later, the encoder must have been fitted on the original categories first.

1import numpy as np
2from sklearn.preprocessing import OneHotEncoder
3
4X = np.array([
5    ["red", "S"],
6    ["blue", "M"],
7    ["green", "L"],
8], dtype=object)
9
10encoder = OneHotEncoder(sparse_output=False)
11encoded = encoder.fit_transform(X)
12
13print(encoded)

At this point, encoder.categories_ remembers how each original category maps into the encoded columns.

Recover the Original Categories

Once you have the encoded matrix and the fitted encoder, reversing it is straightforward:

decoded = encoder.inverse_transform(encoded)
print(decoded)

The output will match the original categorical values column by column. This is the main answer for most real use cases: if you want the original labels back, use inverse_transform on the same fitted encoder.

Inspect the Category Mapping

To understand why the reverse step works, inspect the learned category order:

for i, categories in enumerate(encoder.categories_):
    print(f"column {i}: {categories}")

Scikit-learn stores one array of categories per original input column. The encoded output is laid out according to that internal order, so reverse transformation is only meaningful if the encoded columns still line up with the same encoder metadata.

Sparse Encodings Also Work

In many pipelines, OneHotEncoder returns a sparse matrix instead of a dense NumPy array. inverse_transform still works.

1encoder = OneHotEncoder()
2encoded_sparse = encoder.fit_transform(X)
3
4decoded = encoder.inverse_transform(encoded_sparse)
5print(decoded)

You do not need to convert the sparse matrix to dense just to decode it. That is useful for large categorical feature spaces where dense matrices would waste memory.

Handle Dropped Categories and Unknown Values

Reverse transformation becomes trickier when the encoder was configured with options such as dropping one category or ignoring unknown values.

Example:

1encoder = OneHotEncoder(
2    drop="first",
3    handle_unknown="ignore",
4    sparse_output=False
5)
6
7encoded = encoder.fit_transform(X)
8decoded = encoder.inverse_transform(encoded)
9print(decoded)

This still works, but the semantics matter:

• with dropped categories, the all-zero pattern may map back to the dropped baseline category
• with unknown categories ignored during transform, the reverse step can produce None values when the encoded input does not correspond to a known category cleanly

That is why reverse transformation is easiest when the data still follows the same assumptions used during fitting.

Recover Only One Column

If your encoder was fitted on multiple categorical columns and you only need one recovered column, you can decode the full matrix and then slice the result.

1decoded = encoder.inverse_transform(encoded)
2colors = decoded[:, 0]
3sizes = decoded[:, 1]
4
5print(colors)
6print(sizes)

This is usually simpler than trying to reverse-engineer the one-hot column boundaries yourself.

When Manual Recovery Is the Wrong Tool

Sometimes people try to reconstruct categories manually with argmax over slices of the encoded array. That can work in a very controlled setup, but it is brittle because:

• you must know the exact column ranges
• dropped-category settings change the meaning of zero vectors
• sparse and dense outputs may be handled differently

If you still have the encoder, inverse_transform is the safer and clearer option.

Common Pitfalls

The biggest mistake is losing the fitted encoder. Without the original category ordering, the encoded matrix alone does not fully describe how to recover the labels.

Another common issue is feeding an encoded matrix that no longer matches the encoder that created it. If columns were reordered, removed, or concatenated differently, the reverse mapping becomes wrong.

Dropped categories and ignored unknown values are another source of confusion. The reverse result may contain baseline categories or missing values in ways that surprise people who expected a perfect round trip.

Finally, be careful when comparing arrays of strings and objects. The decoded result may use an object dtype, which is normal for categorical text data.

Summary

• Use encoder.inverse_transform(...) to recover original categories from one-hot encoded data.
• Keep the fitted OneHotEncoder, because it stores the category order.
• Sparse outputs can be decoded directly; dense conversion is not required.
• Options such as drop and handle_unknown affect how cleanly the reverse mapping behaves.
• Manual argmax decoding is usually more fragile than using the encoder itself.