What is one-hot encoding in machine learning?

One-hot encoding turns a categorical column into numeric columns a model can use. Each distinct category becomes its own 0/1 indicator column, and every row has a single 1 in the column for its category and 0 everywhere else. Unlike label encoding, it adds no artificial ordering between categories, which is why it is the default for nominal features.

When should I use one-hot encoding instead of label encoding?

Use one-hot encoding for nominal data, categories with no natural order, like colour, city, or payment method, because label encoding (Red=0, Green=1, Blue=2) invents a false ordering and spacing that tree-agnostic models will misread. Label encoding is fine for tree models or for genuinely ordinal data where you set the order deliberately. This tool shows both side by side so the difference is concrete.

What is the dummy variable trap and does drop-first fix it?

When you keep one indicator column per category, the columns are perfectly collinear, any one is a linear combination of the others, which breaks linear and logistic regression that assume independent predictors. Turning on drop-first removes the first category's column; that category is then represented by an all-zero row. It is the standard fix and matches pandas get_dummies(drop_first=True).

How does one-hot encoding handle unknown or unseen categories?

In scikit-learn, an encoder fitted on training data meets new categories at transform time. With handle_unknown='ignore' an unseen category produces an all-zero row instead of raising an error; with handle_unknown='error' it raises. This tool fits and transforms the same column, so no unknowns arise here, but the setting is reflected in the generated code for when you reuse the encoder on fresh data.

Should I one-hot encode ordinal data like small / medium / large?

Usually no. One-hot encoding deliberately discards order, so S/M/L/XL become four independent columns and the model loses the fact that L sits between M and XL. For genuinely ordered categories, use an ordinal encoder with an explicit order (small < medium < large). One-hot is the right choice only when the order truly does not matter.

Why are the categories sorted alphabetically by default?

That mirrors scikit-learn's OneHotEncoder, whose default categories='auto' fits the unique values and sorts them lexicographically, and pandas get_dummies, which also orders columns alphabetically. This tool defaults to the same lexicographic order so its output matches a fresh notebook exactly. You can switch to numeric or first-seen order if you need a different column layout.

Is my data uploaded anywhere?

No. Parsing, fitting the categories, and building the matrix all happen locally in your browser with plain string operations. There is no server call and no API key. You can paste up to 10,000 values across at most 500 distinct categories, and nothing ever leaves your device.

Does the generated Python reproduce this exact matrix?

Yes. The scikit-learn snippet passes the resolved category order explicitly, so its OneHotEncoder output matches the table regardless of which ordering you picked. The pandas snippet is the idiomatic get_dummies form; because get_dummies always sorts columns alphabetically, a note is added when you choose a non-lexicographic order, the 0/1 values are identical, only the column order differs.

AI · Preprocessing

One-Hot Encoding Calculator, Categorical to Numeric

Paste a categorical column and instantly get the one-hot encoded 0/1 matrix, matching scikit-learn's OneHotEncoder and pandas get_dummies, with copy-ready Python, CSV, and NumPy. It runs entirely in your browser, so nothing is uploaded.

By Induwara Ashinsana· Co-Founder, Ryzera TechnologiesUpdated Jul 13, 2026

One-hot encode your column

OneHotEncoder · get_dummies

Categorical column (one value per line or comma-separated)

Up to 10,000 values / 500 distinct categories. Blank lines are ignored. Nothing leaves your browser.

Try

Category order

Column prefix

Handle unknown

Drop first categoryDrop-first (dummy-variable trap)

Fitted categories

0Blue×11Green×22Red×2

5 input rows → 3 columns.

One-hot matrix

#	Value	Label	x_Blue	x_Green	x_Red
1	Red	2	0	0	1
2	Green	1	0	1	0
3	Blue	0	1	0	0
4	Green	1	0	1	0
5	Red	2	0	0	1

The Label column is single-integer label encoding of the same data, shown for contrast. It implies a false numeric order, which is exactly what one-hot encoding avoids.

Copy-ready output

from sklearn.preprocessing import OneHotEncoder
import numpy as np

X = np.array(["Red", "Green", "Blue", "Green", "Red"]).reshape(-1, 1)
  # lexicographic order == OneHotEncoder default (categories='auto')
enc = OneHotEncoder(
    categories=[["Blue", "Green", "Red"]],
    sparse_output=False,
)
onehot = enc.fit_transform(X)
# handle_unknown="ignore" only affects transform() of
# categories not seen here; on this fit set the matrix is unchanged.
print(enc.get_feature_names_out(["x"]))
print(onehot.astype(int))

Behaviour mirrors scikit-learn's OneHotEncoder and pandas get_dummies. Everything runs in your browser, no upload, no API key.

How it works

One-hot encodingconverts a categorical column into a set of numeric 0/1 indicator columns, one per distinct category, so a model that only understands numbers can use it without inferring a fake ordering. This tool reproduces the deterministic behaviour of scikit-learn's OneHotEncoder and pandas get_dummies, so its output matches a fresh notebook. Every step is a plain string operation and never leaves your device.

Parse. Your text is split on new lines and commas, each value is trimmed, and blank entries are dropped. You get an ordered list of category tokens, kept in the original row order.
Fit the categories.The distinct tokens become the encoder's vocabulary. The order is resolved by your choice: lexicographicsorts them as strings, matching scikit-learn's default categories='auto' (sorted unique); numeric sorts numerically when every value is a number, otherwise it falls back to lexicographic with a note; first-seen keeps the order each category first appears.
Transform.For each input row the tool emits a vector of length K (the number of fitted categories) with a 1 in that row's category position and 0 elsewhere, the formula onehot(x)[j] = 1 if x == category[j] else 0. Exactly one column is 1 per row, so every row sums to 1.
Drop-first (optional). To avoid the dummy-variable trap, the perfect collinearity that breaks linear and logistic regression, the first category's column can be dropped. That category is then represented by an all-zero row, matching get_dummies(drop_first=True).
Name and count. Columns are named {prefix}_{category}, the same convention as get_dummies, and each category's frequency is tallied so you can see the class balance at a glance.

The result is cross-checked by an independent inverse transform: every row of the matrix is decoded back to a category by taking the position of its 1 (or the dropped category for an all-zero row) and compared against the original input. When all rows round-trip exactly. They always should, the tool shows an "inverse-verified" badge. Alongside the matrix, a single integer label-encoding column is shown for contrast: it is compact but imposes a false numeric order, which is precisely what one-hot encoding avoids. What this tool deliberately does not do is encode multiple columns at once, or apply target, frequency, or binary encoders. It is a focused one-hot encoder for a single column.

Worked examples

Colours, default settings (n = 3)

Red, Green, Blue, Green, Red · lexicographic · drop-first off

Distinct = {Blue, Green, Red}; sorted → [Blue, Green, Red], K = 3
Columns: x_Blue, x_Green, x_Red
Red → [0,0,1] Green → [0,1,0] Blue → [1,0,0]
Every row sums to 1; label encoding: Blue=0, Green=1, Red=2
Drop-first drops x_Blue → Red [0,1], Green [1,0], Blue [0,0]

Ordinal sizes, teaching case (identity matrix)

S, M, L, XL · lexicographic

ASCII order L(76) M(77) S(83) X(88) → [L, M, S, XL], K = 4
One-hot = the 4×4 identity, each row exactly one 1, trace = 4
Label encoding L=0, M=1, S=2, XL=3, a false numeric spacing
Lesson: ordered data wants an ordinal encoder, not label encoding

Single category + drop-first (edge case)

Yes, Yes · drop-first on

Distinct = {Yes}; K = 1 before dropping
Drop-first removes the only column → 0 columns remain
Every row becomes the all-zero vector, no crash, no NaN
Correct dummy-trap result: one category needs zero indicators

Frequently asked questions

Sources & references

The behaviour and worked examples on this page were last reconciled against these sources on 2026-07-13. The definitions are standard and stable; the page is reviewed if the reference implementations change their default behaviour.

Related tools

Cross-Entropy Loss Calc

Compute cross-entropy (log) loss for binary and multi-class classification from labels and predicted probabilities or logits. Shows per-sample loss, the mean log-loss metric, perplexity and full step-by-step working, matches scikit-learn log_loss and PyTorch CrossEntropyLoss, entirely in the browser.

Open tool

TF-IDF Calculator

Compute the full TF-IDF weighting for a small corpus, the term-frequency table, the IDF per term, and the final TF-IDF matrix, with the complete per-term working. Supports the textbook and scikit-learn smoothed variants, runs entirely in your browser.

Open tool

Feature Scaling Calculator

Paste a column of numbers and rescale it four ways, Min-Max normalization, Z-score standardization, MaxAbs, and Robust (median/IQR) scaling, with the exact scikit-learn formulas and every fitted parameter (min, max, mean, std, median, IQR) shown so you can reproduce each number by hand.

Open tool

Comments & feedback

Spotted a bug or want an improvement? Tell us, our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a bug, edge case, or want to suggest an improvement?

Email me at [email protected] , most fixes ship within 24 hours.