Klassisk maskinlæring: kraftfullt og undervurdert

Har du en tabell med tall og et spørsmål om en kategori eller en verdi, er en språkmodell som regel feil verktøy. Det du trenger er eldre, billigere og ofte bedre.

AI er mer enn språkmodeller

Når folk sier AI nå, mener de nesten alltid språkmodeller. Men mye av AI-en som faktisk kjører i drift, i banker, energiselskaper og industribedrifter, er noe annet. Det er modeller som gjetter om en transaksjon er svindel, hvor mye strøm en bygning bruker i morgen, eller om en maskin trenger service snart. Det kalles klassisk maskinlæring, og den gjorde jobben lenge før ChatGPT.

To oppgaver dekker det meste

Du gir modellen mange eksempler med riktig svar. Den gjetter, får vite hvor langt unna den var, og justerer seg litt. Etter mange runder treffer den. Trær bygges på en annen måte, ved å velge én deling om gangen, men tanken er den samme: ende opp med færre feil på eksemplene. Det er samme grunnidé som i en språkmodell, men med en mye mindre modell, på mye mindre data og med én bestemt jobb.

Hvorfor enkle modeller ofte vinner

På tabeller har trebaserte modeller, som gradient boosting, lenge slått store nevrale nett. I 2022 sammenlignet Grinsztajn, Oyallon og Varoquaux modellene på 45 datasett og fant at trebaserte modeller fortsatt lå øverst på middels store datasett, selv uten å regne med at de er mye raskere å trene. Siden har feltet beveget seg, som tallet lengst til høyre viser.

Det siste tallet viser at historien ikke stopper her. En modell trent på millioner av syntetiske tabeller, TabPFN, slo tidligere metoder på små datasett uten tidkrevende finjustering. Det betyr ikke at du skal bytte i morgen. Det betyr at feltet ikke står stille, og at «enkelt» ikke er det samme som «ferdig utviklet».

Les lisensen før du prøver TabPFN i en bedrift. Koden er Apache 2.0, men modellvektene har egen lisens. README på GitHub (lest 8. oktober 2026) sier at vektene til TabPFN-2.5, 2.6, 3 og 3.5 er ikke-kommersielle, og viser til en egen bedriftslisens for kommersiell bruk. Vektene til TabPFN-2 har Prior Labs-lisensen, som er Apache 2.0 med krav om navngiving. For TabPFN-2.5 og nyere åpnes en nettleser første gang, der du logger inn hos Prior Labs og godtar lisensen. README anbefaler GPU, og sier at CPU er tregt. Installeres med pip install tabpfn. De 2,8 sekundene er tallet fra Nature-artikkelen, og jeg har ikke sjekket hvilken maskinvare som lå bak.

Men også uten nye modeller er det god grunn til å starte enkelt:

• Billig og rask. Treningen går ofte på sekunder til minutter på en vanlig bærbar, og svaret kommer på millisekunder. Ingen GPU og ingen pris per kall. Det gjelder trær og regresjon, ikke TabPFN.
• Forutsigbar. Med samme data og samme tilfeldighetsfrø får du samme modell, og du kan se hvilke variabler som veide tyngst.
• Lite data. For en avgrenset oppgave kan hundrevis til noen tusen rader være nok.

Det gjelder tabeller. På bilder, lyd og fri tekst er det motsatt.

Når du bytter verktøy

Rekkefølgen er poenget. Start der det enkleste kan virke, og gå videre først når du har sett at det ikke holder.

Hva som skal til, for at det virker

Modellen blir aldri bedre enn dataene. Det er der arbeidet starter, ikke i valget av algoritme.

• Representativt. Dataene må speile virkeligheten du skal bruke modellen i, også de sjeldne tilfellene.
• Nok eksempler. Særlig av de tilfellene du bryr deg om. Er det få deler som sviktet, har modellen lite å lære av.
• Riktig fasit. Feil i fasiten er en vanlig grunn til dårlige modeller, og den er lett å overse.
• Ferske. Verden endrer seg. En modell trent på gamle data kan gå glipp av nye mønstre.

Regn ut den dumme regelen først

Før du trener noe: regn ut hva en dum regel gir. Holder 98 av 100 deler, og modellen din alltid svarer «holder», har den 98 prosent rett og finner ikke en eneste feil. Slår ikke modellen den dumme regelen på det du faktisk bryr deg om, har du ikke en modell. Sjekk derfor hvor mange av de som sviktet den fant, ikke bare hvor ofte den hadde rett. Og test alltid på data den ikke har sett under treningen.

Elefanten

Det kalles distribusjonsskift, og det skjer når modellen møter data som er annerledes enn treningsdataene. En maskin får ny driftsform, en sensor blir byttet, eller verden endrer seg. Derfor må modeller i drift følges opp og trenes på nytt. Og husk at modellen finner det som henger sammen med utfallet, ikke det som forårsaker det. Handler du som om det er det samme, kan du gjøre noe dumt med stor selvtillit.

La AI hjelpe deg å velge

Jeg har data om [hva dataene handler om]. Hver rad er [én enhet, for eksempel én del eller én kunde], og jeg vil forutsi [hva]. Jeg har omtrent [antall] rader og [antall] kolonner.

Er dette klassifisering, regresjon eller noe annet? Trenger jeg maskinlæring, eller holder en enkel regel? Foreslå en enkel baseline og en modell å starte med, og fortell hva som kan gå galt med akkurat disse dataene.

Klassisk maskinlæring er ikke utdatert. Det er riktig verktøy for en bestemt jobb, og den jobben er det mange som har. Et eksempel på hvordan det ser ut når mønsteret er «lær det normale», står i Å finne det unormale.

import random

# Konstruerte data: 2 000 deler, omtrent 3 prosent sviktet.
# Kolonnene er vibrasjon (mm/s) og temperatur (°C). Alle tall er funnet på.
def lag_data(n=2000, andel_svikt=0.03, frø=1):
    rng = random.Random(frø)
    rader = []
    for _ in range(n):
        svikt = rng.random() < andel_svikt
        if svikt:
            rader.append(((rng.gauss(3.4, 0.7), rng.gauss(80, 6)), 1))
        else:
            rader.append(((rng.gauss(2.0, 0.5), rng.gauss(68, 5)), 0))
    return rader

# Del i trening og test. Testdelen brukes aldri til å velge regler.
def del_opp(rader, testandel=0.3, frø=1):
    rng = random.Random(frø)
    rader = rader[:]
    rng.shuffle(rader)
    snitt = int(len(rader) * (1 - testandel))
    return rader[:snitt], rader[snitt:]

import statistics

from deler import lag_data, del_opp

trening, test = del_opp(lag_data())
holdt = [x for x, y in trening if y == 0]
snitt = [statistics.mean(k) for k in zip(*holdt)]
sd = [statistics.stdev(k) for k in zip(*holdt)]

def dum_regel(x):
    return 0  # alle deler holder

def terskel_regel(x):
    return int(x[0] > 2.8)  # fast grense på vibrasjon

def z_score_regel(x, grense=2.5):
    z = [(v - m) / s for v, m, s in zip(x, snitt, sd)]
    return int(max(z) > grense)  # én variabel langt over det normale holder

def vurder(regel):
    ekte = [y for _, y in test]
    gjett = [regel(x) for x, _ in test]
    rett = sum(g == e for g, e in zip(gjett, ekte)) / len(test)
    funnet = sum(g and e for g, e in zip(gjett, ekte)) / sum(ekte)
    falske = sum(g and not e for g, e in zip(gjett, ekte))
    return rett, funnet, falske

print(f"Test: {len(test)} deler, {sum(y for _, y in test)} sviktet")
for navn, regel in [("dum regel", dum_regel), ("terskel", terskel_regel),
                    ("z-score", z_score_regel)]:
    rett, funnet, falske = vurder(regel)
    print(f"{navn:10} {rett:5.1%} rett | {funnet:5.1%} av svikten funnet | {falske} falske alarmer")

Test: 600 deler, 19 sviktet
dum regel  96.8% rett |  0.0% av svikten funnet | 0 falske alarmer
terskel    94.0% rett | 84.2% av svikten funnet | 33 falske alarmer
z-score    97.8% rett | 84.2% av svikten funnet | 10 falske alarmer

# pip install scikit-learn
from sklearn.dummy import DummyClassifier
from sklearn.metrics import accuracy_score, recall_score
from sklearn.tree import DecisionTreeClassifier

from deler import lag_data, del_opp

trening, test = del_opp(lag_data())
X_tr, y_tr = [x for x, _ in trening], [y for _, y in trening]
X_te, y_te = [x for x, _ in test], [y for _, y in test]

modeller = {
    "dum regel": DummyClassifier(strategy="most_frequent"),
    "beslutningstre": DecisionTreeClassifier(max_depth=3, random_state=0),
}
for navn, modell in modeller.items():
    modell.fit(X_tr, y_tr)
    gjett = modell.predict(X_te)
    falske = sum(g and not e for g, e in zip(gjett, y_te))
    print(f"{navn:15} {accuracy_score(y_te, gjett):5.1%} rett | "
          f"{recall_score(y_te, gjett):5.1%} av svikten funnet | {falske} falske alarmer")

dum regel       96.8% rett |  0.0% av svikten funnet | 0 falske alarmer
beslutningstre  98.7% rett | 73.7% av svikten funnet | 3 falske alarmer

Oppdatert oktober 2026. Kilder: Grinsztajn, Oyallon og Varoquaux, «Why do tree-based models still outperform deep learning on typical tabular data?», NeurIPS 2022 (Datasets and Benchmarks). Hollmann m.fl., «Accurate predictions on small data with a tabular foundation model», Nature 637, 2025. Jeg har lest sammendragene og ikke alle resultattabellene, og 2,8 sekunder gjelder klassifisering på datasett opp til 10 000 rader. Punktene om kostnad og datamengde er erfaringsregler og ikke målt her. Punktene i figuren er konstruert. Lisensopplysningene om TabPFN er fra README på GitHub, lest 8. oktober 2026, og kan endre seg per modellversjon.