Introduction

Many machine learning and numeric workflows need category labels as integers instead of raw strings. NumPy can do this conversion cleanly, but you should understand how the mapping is created so you do not accidentally scramble category meaning between training and inference.

Use np.unique with return_inverse

The most direct NumPy solution is np.unique(..., return_inverse=True). It returns the unique sorted categories and, for each original value, the integer index of that category.

1import numpy as np
2
3animals = np.array(["dog", "cat", "dog", "bird", "cat"])
4classes, encoded = np.unique(animals, return_inverse=True)
5
6print(classes)
7print(encoded)

Output looks like this:

['bird' 'cat' 'dog']
[2 1 2 0 1]

This means:

• 'bird maps to 0'
• 'cat maps to 1'
• 'dog maps to 2'

The mapping is based on sorted unique values, not first appearance.

Build an Explicit Mapping When Order Matters

If you want categories to be assigned in the order they first appear, build the mapping yourself. That is often easier to reason about when you need consistent IDs across multiple steps.

1import numpy as np
2
3def encode_in_order(values):
4    mapping = {}
5    encoded = []
6
7    for value in values:
8        if value not in mapping:
9            mapping[value] = len(mapping)
10        encoded.append(mapping[value])
11
12    return np.array(encoded, dtype=np.int64), mapping
13
14
15animals = np.array(["dog", "cat", "dog", "bird", "cat"])
16encoded, mapping = encode_in_order(animals)
17
18print(encoded)
19print(mapping)

Now the first seen category, dog, becomes 0, then cat becomes 1, and bird becomes 2.

Reuse the Same Mapping for New Data

The most important practical rule is to reuse the exact same mapping when you transform new data. If you rebuild the mapping independently on a test set, the integers can change and your model will misinterpret the values.

1import numpy as np
2
3mapping = {"dog": 0, "cat": 1, "bird": 2}
4new_animals = np.array(["cat", "bird", "dog", "cat"])
5
6encoded_new = np.array([mapping[item] for item in new_animals], dtype=np.int64)
7print(encoded_new)

If unknown categories are possible, handle them explicitly:

encoded_new = np.array([mapping.get(item, -1) for item in new_animals], dtype=np.int64)

Using -1 as a sentinel value is common when the model or downstream pipeline knows how to treat unseen labels.

Know When Integer Encoding Is Not Enough

Integer encoding is useful, but it does not mean the categories are ordered. Some models incorrectly treat 2 as larger or more meaningful than 1. Tree-based models can often tolerate integer-encoded categories better than linear models or neural networks.

If the categories are purely nominal, one-hot encoding may be the safer representation:

1import numpy as np
2
3encoded = np.array([2, 1, 2, 0, 1])
4one_hot = np.eye(3, dtype=np.int64)[encoded]
5print(one_hot)

Choose the representation based on the model, not just on what is easiest to generate.

Common Pitfalls

The biggest mistake is rebuilding the category mapping separately for train and test data. The integer values may look valid in both places while silently meaning different things.

Another issue is assuming np.unique preserves original order. It does not. It sorts the categories, which can be surprising if you expected the first item seen to become 0.

Unknown labels also require a plan. A production system often encounters categories that were not present in training. Without a fallback code or validation rule, the encoding step may fail at runtime.

Finally, remember that integer encoding can imply a false ordering to some models. If there is no natural rank among the categories, consider one-hot encoding or another model-friendly representation.

Summary

• 'np.unique(..., return_inverse=True) is the quickest NumPy way to map strings to integer IDs.'
• 'np.unique sorts categories, so the mapping may not follow original appearance order.'
• Build and store an explicit mapping when you need reproducible encoding across datasets.
• Decide how to handle unknown categories before inference time.
• Use one-hot encoding when integer IDs would create a misleading numeric ordering.