Koda kategoriska variabler: OrdinalEncoder och OneHotEncoder
Ni kommer att omvandla ordinala kategorier till heltal och nominala kategorier till one-hot-vektorer samt hantera okända kategorier vid inferens.
Koda kategoriska variabler: OrdinalEncoder och OneHotEncoder är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Machine Learning Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Varför kategorisk kodning krävs
Maskininlärningsmodeller arbetar med tal, inte strängar. En kolumn som innehåller värden som 'red', 'green', 'blue' kan inte skickas direkt till en estimator i scikit-learn. Ni måste konvertera kategorier till numeriska representationer före träningen. Valet av kodningsmetod har stor betydelse: en olämplig kodning kan införa skenbara ordinala samband eller kraftigt öka dimensionaliteten. Den här lektionen behandlar de två viktigaste kodarna: OrdinalEncoder för ordnade kategorier och OneHotEncoder för oordnade kategorier.
import pandas as pd
df = pd.DataFrame({
'size': ['small', 'medium', 'large', 'medium'],
'color': ['red', 'blue', 'green', 'red'],
'price': [10.5, 20.0, 15.0, 18.5]
})
print(df.dtypes)
# size and color are 'object' (string) — must be encoded before modellingOrdinala kontra nominala kategorier
Alla kategoriska variabler är inte likadana. Ordinala kategorier har en meningsfull ordning: small < medium < large eller bad < fair < good < excellent. Nominala kategorier har ingen inneboende ordning: red, blue, green är bara etiketter. Om Ni väljer fel kodning skapas falska samband – om oordnade färger till exempel heltalskodas som 0, 1, 2 talar det om för modellen att blue (1) på något sätt ligger mellan red (0) och green (2), vilket saknar mening. Identifiera alltid om en variabel är ordinal eller nominal innan Ni kodar den.
# Ordinal: clear ordering
ordinal_example = ['low', 'medium', 'high', 'very high']
# Nominal: no meaningful ordering
nominal_example = ['cat', 'dog', 'bird']
# Wrong approach for nominal: integer encoding implies order
# 0=cat, 1=dog, 2=bird -- model thinks dog is between cat and bird
# Correct approach for nominal: one-hot encoding
# cat -> [1, 0, 0]
# dog -> [0, 1, 0]
# bird -> [0, 0, 1]OrdinalEncoder: mappa ordning till heltal
OrdinalEncoder mappar varje kategori till ett heltal baserat på en angiven ordning. Ni anger parametern categories som en lista med listor, där positionen avgör vilket heltal som tilldelas. Om Ni inte anger någon ordning tilldelar scikit-learn heltal i alfabetisk ordning – vilket kanske stämmer överens med den verkliga ordningen, eller kanske inte. Ange alltid kategoriordningen uttryckligen för ordinala variabler, så att modellen fångar det korrekta sambandet mellan värdena.
from sklearn.preprocessing import OrdinalEncoder
import numpy as np
X = np.array([['low'], ['high'], ['medium'], ['low'], ['high']])
# Specify order explicitly: low=0, medium=1, high=2
enc = OrdinalEncoder(categories=[['low', 'medium', 'high']])
X_encoded = enc.fit_transform(X)
print('Ordinal encoded:', X_encoded.flatten())
# [0. 2. 1. 0. 2.]OneHotEncoder: dummyvariabler för nominaldata
OneHotEncoder skapar en binär kolumn per kategori. För en egenskap color med värdena red, green, blue skapas tre kolumner: color_red, color_green, color_blue, där exakt en är 1 och resten är 0 på varje rad. Detta undviker all antydd ordning. Nackdelen är dimensionaliteten: en egenskap med 100 unika värden skapar 100 nya kolumner. Som standard tar scikit-learns OneHotEncoder bort en kategori (dummy-kodning) för att undvika perfekt multikollinearitet i linjära modeller.
from sklearn.preprocessing import OneHotEncoder
import numpy as np
X = np.array([['red'], ['green'], ['blue'], ['red']])
enc = OneHotEncoder(sparse_output=False) # dense output for readability
X_ohe = enc.fit_transform(X)
print('Categories:', enc.categories_)
print('One-hot encoded:\n', X_ohe)
# [[0. 0. 1.]
# [0. 1. 0.]
# [1. 0. 0.]
# [0. 0. 1.]]Ta bort en kategori: dummy-kodning
När Ni använder OneHotEncoder med linjära modeller leder det till perfekt multikollinearitet att behålla alla K kolumner för en variabel med K kategorier – kolumnerna summerar till 1, så vilken kolumn som helst kan uttryckas som en linjärkombination av de andra. Detta gör designmatrisen singulär (icke-inverterbar). Om Ni anger drop='first' tas den första kategorin bort, vilket lämnar K-1 kolumner som beskriver variabeln fullständigt utan redundans. För trädbaserade modeller är det ofarligt att behålla alla K kolumner och det kan ibland vara något bättre, så Ni kan använda drop=None.
from sklearn.preprocessing import OneHotEncoder
import numpy as np
X = np.array([['red'], ['green'], ['blue'], ['red']])
# Drop first category to avoid multicollinearity
enc = OneHotEncoder(drop='first', sparse_output=False)
X_ohe = enc.fit_transform(X)
print('Categories kept (first dropped):', enc.get_feature_names_out())
print('Encoded:\n', X_ohe)
# Only 2 columns instead of 3Hantera okända kategorier vid inferens
En utmaning i verkliga tillämpningar är att en kategori kan förekomma vid inferens som inte fanns i träningsdata. Som standard ger OrdinalEncoder och OneHotEncoder ett fel för okända kategorier. Ange handle_unknown='ignore' i OneHotEncoder för att skapa rader med enbart nollor för okända värden (modellen gör en förutsägelse utan den egenskapen). För OrdinalEncoder anger Ni handle_unknown='use_encoded_value' tillsammans med unknown_value=-1 för att markera okända värden uttryckligen.
from sklearn.preprocessing import OneHotEncoder
import numpy as np
# Training data: only red and blue seen
X_train = np.array([['red'], ['blue'], ['red']])
X_test = np.array([['green']]) # Unseen at training time
enc = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
enc.fit(X_train)
X_test_enc = enc.transform(X_test)
print('Unknown category encodes as all zeros:', X_test_enc)
# [[0. 0.]] -- no error, unknown silently encoded as zerosMålkodning för egenskaper med hög kardinalitet
När en kategorisk egenskap har hundratals eller tusentals unika värden, till exempel postnummer eller produkt-SKU:er, skapar one-hot-kodning en ohanterligt stor matris. Målkodning ersätter varje kategori med medelvärdet för målvariabeln för den kategorin. Detta komprimerar egenskaper med hög kardinalitet till en enda kolumn. Risken är målläckage: om Ni kodar med ett medelvärde som beräknats på samma rader som Ni tränar på memorerar modellen mönster i stället för att generalisera. Använd alltid målkodning över flera foldar för att förhindra läckage.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'city': ['NYC', 'LA', 'NYC', 'Chicago', 'LA', 'NYC'],
'churned': [1, 0, 1, 0, 1, 0]
})
# Simple (leaky) target encoding
target_mean = df.groupby('city')['churned'].mean()
df['city_encoded'] = df['city'].map(target_mean)
print(df[['city', 'city_encoded', 'churned']])
# Use cross-fold encoding in practice to avoid leakageBinär kodning för medelhög kardinalitet
Binär kodning är en kompromiss mellan ordinal kodning och one-hot-kodning. Varje heltalskod konverteras till sin binära representation, vilket ger log2(K) kolumner i stället för K kolumner. Åtta kategorier behöver till exempel endast 3 binära kolumner i stället för 8 one-hot-kolumner. Detta minskar dimensionaliteten avsevärt för egenskaper med 10–100 kategorier. Biblioteket category_encoders tillhandahåller BinaryEncoder, som hanterar denna transformering med ett scikit-learn-kompatibelt API.
# Conceptual example: binary encoding manually
# Category -> Integer -> Binary columns
categories = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
for i, cat in enumerate(categories):
binary = format(i, '03b') # 3 bits for 8 categories
print(f'{cat} -> {i} -> {list(binary)}')
# A -> 0 -> [0, 0, 0]
# B -> 1 -> [0, 0, 1]
# ...
# H -> 7 -> [1, 1, 1]
# 8 categories need only 3 columns (vs 8 with one-hot)Tillämpa kodare i ColumnTransformer
Verkliga datamängder innehåller en blandning av numeriska, ordinala och nominala kolumner. ColumnTransformer tillämpar olika transformeringar på olika kolumner parallellt och sammanfogar resultaten. Ange ordinala kolumner med OrdinalEncoder, nominala kolumner med OneHotEncoder och numeriska kolumner med StandardScaler. Resultatet är en enda ren numerisk matris som är redo för valfri estimator i scikit-learn. Detta är standardmönstret i produktion för datamängder med blandade datatyper.
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OrdinalEncoder, OneHotEncoder, StandardScaler
preprocessor = ColumnTransformer([
('num', StandardScaler(), ['age', 'income']),
('ord', OrdinalEncoder(categories=[['low', 'medium', 'high']]), ['risk_level']),
('nom', OneHotEncoder(drop='first', sparse_output=False), ['city', 'product'])
])
# Result: numeric + ordinal encoded + one-hot columns in one matrixEgenskapsnamn efter kodning
Efter kodningen har egenskapsmatrisen fler kolumner än den ursprungliga DataFrame, och transformatorerna i scikit-learn håller reda på de nya namnen. Anropa get_feature_names_out() på ColumnTransformer eller OneHotEncoder för att hämta de genererade egenskapsnamnen. Detta är avgörande för modellens tolkningsbarhet: om Ni vet vilken one-hot-kolumn som motsvarar vilken ursprunglig kategori kan Ni tolka egenskapsvikter från Random Forests eller SHAP-värden från gradientboostade modeller korrekt.
from sklearn.preprocessing import OneHotEncoder
import numpy as np
X = np.array([['red', 'small'], ['blue', 'large'], ['green', 'medium']])
enc = OneHotEncoder(sparse_output=False)
enc.fit(X)
print('Feature names:', enc.get_feature_names_out(['color', 'size']))
# ['color_blue' 'color_green' 'color_red' 'size_large' 'size_medium' 'size_small']
X_enc = enc.transform(X)
print('Encoded shape:', X_enc.shape)Fullständig kodningspipeline: exempel från början till slut
Här är en komplett pipeline med blandad kodning. ColumnTransformer hanterar tre kolumntyper: numeriska egenskaper skalas, en ordinal egenskap heltalskodas med en uttryckligen angiven ordning och nominala egenskaper blir one-hot-kolumner. Därefter korsvalideras pipelinen – kodningen anpassas på nytt inom varje CV-fold för att förhindra läckage. Detta mönster fungerar för alla datamängder och är redo för driftsättning när det har tränats på hela datamängden.
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OrdinalEncoder, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
preprocessor = ColumnTransformer([
('num', StandardScaler(), ['age', 'income']),
('ord', OrdinalEncoder(categories=[['low', 'medium', 'high']]), ['risk']),
('ohe', OneHotEncoder(drop='first', handle_unknown='ignore'), ['city'])
])
pipeline = Pipeline([
('prep', preprocessor),
('clf', LogisticRegression(max_iter=500))
])
scores = cross_val_score(pipeline, X, y, cv=5, scoring='accuracy')
print('CV accuracy:', scores.mean().round(3))Snabbtest
Testa Er förståelse av koncepten inom Machine Learning with Python från den här lektionen.
Sammanfattning av lektionen
I den här lektionen har Ni lärt Er: skillnaden mellan ordinala och nominala kategorier och varför den avgör valet av kodning, OrdinalEncoder för ordnade variabler och OneHotEncoder för nominala variabler, samt hur okända kategorier hanteras och hur kodare kombineras i en ColumnTransformer-pipeline. Härnäst utforskar vi hur alla förbehandlingssteg kan kombineras med ColumnTransformer.
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”Koda kategoriska variabler: OrdinalEncoder och OneHotEncoder” gratis?
Ja – hela texten till ”Koda kategoriska variabler: OrdinalEncoder och OneHotEncoder” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Machine Learning Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Koda kategoriska variabler: OrdinalEncoder och OneHotEncoder”?
Ni kommer att omvandla ordinala kategorier till heltal och nominala kategorier till one-hot-vektorer samt hantera okända kategorier vid inferens. Ni övar på Machine Learning Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Machine Learning Academy?
Du behöver inga förkunskaper. Utbildningen i Machine Learning Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Koda kategoriska variabler: OrdinalEncoder och OneHotEncoder”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Machine Learning Academy-lektionen?
Ja. Varje Machine Learning Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Hantera saknade värden: ta bort, imputera och flagga
- Skalning av egenskaper: StandardScaler och MinMaxScaler
- Koda kategoriska variabler: OrdinalEncoder och OneHotEncoder
- Kombinera steg med ColumnTransformer