PricingLoginStart free
Machine Learning Academy · leksjon

Koding av kategoriske variabler: OrdinalEncoder og OneHotEncoder

De vil konvertere ordinale kategorier til heltall og nominale kategorier til one-hot-vektorer, og håndtere ukjente kategorier ved prediksjon.

Leksjon 3 av 413 trinn

Koding av kategoriske variabler: OrdinalEncoder og OneHotEncoder er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Machine Learning Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hvorfor kategorisk koding er nødvendig

Maskinlæringsmodeller arbeider med tall, ikke strenger. En kolonne som inneholder verdier som 'red', 'green', 'blue', kan ikke sendes direkte til en estimator i scikit-learn. De må konvertere kategoriene til numeriske representasjoner før treningen. Valget av kodingsmetode har stor betydning: en dårlig koding kan innføre kunstige ordensforhold eller øke dimensjonaliteten kraftig. Denne leksjonen dekker de to viktigste koderne: OrdinalEncoder for ordnede kategorier og OneHotEncoder for uordnede 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 modelling

Ordinale og nominelle kategorier

Alle kategoriske variabler er ikke like. Ordinale kategorier har en meningsfull rekkefølge: small < medium < large, eller bad < fair < good < excellent. Nominelle kategorier har ingen iboende rekkefølge: red, blue, green er bare etiketter. Hvis De velger feil koding, oppstår falske sammenhenger — hvis De for eksempel heltallskoder uordnede farger som 0, 1, 2, forteller De modellen at blå (1) på en eller annen måte ligger mellom rød (0) og grønn (2), noe som er meningsløst. Identifiser alltid om en variabel er ordinal eller nominell før De koder 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: tilordne rekkefølge til heltall

OrdinalEncoder tilordner hver kategori et heltall basert på en angitt rekkefølge. De oppgir parameteren categories som en liste med lister, der plasseringen bestemmer hvilket heltall som tilordnes. Hvis De ikke angir en rekkefølge, tilordner scikit-learn heltall alfabetisk — noe som kanskje samsvarer med den faktiske rekkefølgen, eller kanskje ikke. Angi alltid kategorirekkefølgen eksplisitt for ordinale variabler, slik at modellen fanger opp det riktige forholdet mellom verdiene.

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 for nominelle data

OneHotEncoder oppretter én binær kolonne per kategori. For en color-funksjon med verdiene red, green, blue oppretter den tre kolonner: color_red, color_green, color_blue, der nøyaktig én verdi er 1 og resten er 0 i hver rad. Dette unngår enhver antydet rekkefølge. Ulempen er dimensjonaliteten: En funksjon med 100 unike verdier oppretter 100 nye kolonner. Som standard fjerner scikit-learns OneHotEncoder én kategori (dummy-koding) for å unngå perfekt multikollinearitet i lineære 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.]]

Fjerne én kategori: dummy-koding

Når De bruker OneHotEncoder med lineære modeller, introduserer det å beholde alle K kolonner for en variabel med K kategorier perfekt multikollinearitet — kolonnene summerer seg til 1, slik at enhver kolonne er en lineær kombinasjon av de andre. Dette gjør designmatrisen singulær (ikke-inverterbar). Når De angir drop='first', fjernes den første kategorien, og De står igjen med K-1 kolonner som beskriver variabelen fullstendig uten redundans. For trebaserte modeller er det ufarlig å beholde alle K kolonner, og det kan noen ganger gi litt bedre resultater, så De kan bruke 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 3

Håndtere ukjente kategorier ved inferens

En utfordring i virkelige situasjoner er at det ved inferens kan dukke opp en kategori som ikke fantes i treningsdataene. Som standard gir OrdinalEncoder og OneHotEncoder en feil for ukjente kategorier. Angi handle_unknown='ignore' i OneHotEncoder for å produsere rader med bare nuller for ukjente verdier (modellen predikerer uten denne funksjonen). For OrdinalEncoder angir De handle_unknown='use_encoded_value' sammen med unknown_value=-1 for å markere ukjente verdier eksplisitt.

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 zeros

Målkoding for funksjoner med høy kardinalitet

Når en kategorisk funksjon har hundrevis eller tusenvis av unike verdier, for eksempel postnumre eller produkt-SKU-er, oppretter one-hot-koding en uhåndterlig stor matrise. Målkoding erstatter hver kategori med gjennomsnittet av målvariabelen for den kategorien. Dette komprimerer funksjoner med høy kardinalitet til én enkelt kolonne. Risikoen er : Hvis De koder ved hjelp av gjennomsnittet beregnet fra de samme radene som De trener på, lærer modellen seg mønstre utenat i stedet for å generalisere. Bruk alltid målkoding på tvers av foldene for å hindre lekkasje.

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 leakage

Binær koding for middels kardinalitet

Binær koding er et mellompunkt mellom ordinal koding og one-hot-koding. Hver heltallskode konverteres til sin binære representasjon, noe som gir log2(K) kolonner i stedet for K kolonner. For eksempel trenger 8 kategorier bare 3 binære kolonner i stedet for 8 one-hot-kolonner. Dette reduserer dimensjonaliteten betydelig for funksjoner med 10–100 kategorier. Biblioteket category_encoders tilbyr BinaryEncoder, som håndterer denne transformasjonen med et 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)

Bruke kodere i ColumnTransformer

Reelle datasett inneholder en blanding av numeriske, ordinale og nominelle kolonner. ColumnTransformer bruker ulike transformasjoner på ulike kolonner parallelt og setter resultatene sammen. Angi ordinale kolonner med OrdinalEncoder, nominelle kolonner med OneHotEncoder og numeriske kolonner med StandardScaler. Resultatet er én ren numerisk matrise som er klar for enhver estimator i scikit-learn. Dette er standardmønsteret i produksjon for datasett med blandede typer.

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 matrix

Funksjonsnavn etter koding

Etter koding har funksjonsmatrisen Deres flere kolonner enn den opprinnelige DataFrame-en, og transformatorene i scikit-learn holder oversikt over de nye navnene. Kall get_feature_names_out() på ColumnTransformer eller OneHotEncoder for å hente de genererte funksjonsnavnene. Dette er avgjørende for tolkbarhet av modellen: Når De vet hvilken one-hot-kolonne som svarer til hvilken opprinnelig kategori, kan De tolke funksjonsviktighet fra Random Forest-modeller eller SHAP-verdier fra gradientforsterkede modeller riktig.

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)

Full kodingspipeline: eksempel fra start til slutt

Her er en komplett pipeline med blandet koding. ColumnTransformer håndterer tre kolonnetyper: numeriske funksjoner skaleres, en ordinal funksjon heltallskodes med en eksplisitt rekkefølge, og nominelle funksjoner blir one-hot-kolonner. Pipelinen valideres deretter på tvers av foldene — kodingen tilpasses på nytt innenfor hver CV-fold for å hindre lekkasje. Dette mønsteret fungerer for alle datasett og er klart for utrulling når det er trent på hele datasettet.

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))

Rask kontroll

Test forståelsen Deres av konsepter innen maskinlæring med Python fra denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen har De lært: forskjellen mellom ordinale og nominelle kategorier, og hvorfor den avgjør valg av koding, OrdinalEncoder for ordnede variabler og OneHotEncoder for nominelle variabler, samt hvordan De håndterer ukjente kategorier og kombinerer kodere i en ColumnTransformer-pipeline. Deretter skal vi se på hvordan alle forbehandlingsstegene kan kombineres med ColumnTransformer.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
30
Leksjoner
120
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Koding av kategoriske variabler: OrdinalEncoder og OneHotEncoder» gratis?

Ja – hele teksten i «Koding av kategoriske variabler: OrdinalEncoder og OneHotEncoder» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Machine Learning Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Koding av kategoriske variabler: OrdinalEncoder og OneHotEncoder»?

De vil konvertere ordinale kategorier til heltall og nominale kategorier til one-hot-vektorer, og håndtere ukjente kategorier ved prediksjon. Du øver på Machine Learning Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Machine Learning Academy?

Ingen tidligere erfaring er nødvendig. Machine Learning Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Koding av kategoriske variabler: OrdinalEncoder og OneHotEncoder»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Machine Learning Academy-leksjonen?

Ja. Alle Machine Learning Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Håndtering av manglende verdier: Fjern, imputér og marker
  2. Skalering av egenskaper: StandardScaler og MinMaxScaler
  3. Koding av kategoriske variabler: OrdinalEncoder og OneHotEncoder
  4. Kombinere trinn med ColumnTransformer
← Tilbake til Machine Learning Academy