{"canonical_url":"https://engineer.company/da/glossary/machine-learning/","content_markdown":"# Maskinlæring\n\n## Hvad det er\n\nMaskinlæring betyder at bygge software, der lærer en opgave af eksempler i\nstedet for at følge regler, som en programmør har formuleret på forhånd. Man\nviser den mange tilfælde, hvor svaret allerede er kendt. Den finder en\nsammenhæng mellem det, der gik ind, og det svar, der kom ud, og bruger derefter\nsammenhængen til at forudsige svaret i hvert nyt tilfælde. Betegnelsen er ældre\nend næsten al den software, der bærer den i dag: A. L. Samuel brugte den i\ntitlen på en undersøgelse af brætspillet dam, som IBM Journal of Research and\nDevelopment udgav i juli 1959.\n\nBegreberne er nemmest at holde fast i med scikit-learn, et open source-bibliotek\ntil Python, og det er dets dokumentation, denne artikel bygger på. Eksemplerne\nligger i en tabel. Hver række er en observation (scikit-learn siger sample), for\neksempel en faktura, en kunde eller en måling fra en sensor. Hver kolonne er en\nfeature, altså et tal, der beskriver observationen. Det svar, softwaren skal\nlære at give, er målvariablen. Det, der lærer, kalder scikit-learn en estimator.\nAlle estimatorer har en `fit`-metode, som lærer af de rækker, man viser den.\nPrædiktive estimatorer bruger `predict` til at give svar på nye rækker;\ntransformere bruger `transform` til at danne en transformeret tabel med\nobservationer.\n\nLangt det meste arbejde falder i to grupper. Ved superviseret læring har hver\ntræningsrække sin målvariabel med. Er målvariablen en kategori, for eksempel\nbetalt til tiden eller betalt for sent, kaldes opgaven klassifikation. Er den en\nstørrelse, for eksempel antal dage til betaling, hedder det regression. Ved\nikke-superviseret læring findes der ingen målvariabel, og softwaren leder selv\nefter struktur i data, typisk ved at samle kunder, der opfører sig ens, i\ngrupper. I scikit-learns dokumentation har hver af de to grupper sit eget\nkapitel, og bagefter kommer et kapitel om modelvalg og evaluering. Det er dér,\nde fleste praktiske vanskeligheder gemmer sig.\n\nMaskinlæring er derimod ikke et samlebegreb for al software, der virker klog.\nNår en regel markerer hver faktura over et bestemt beløb, har et menneske\nskrevet den, og den gør hverken mere eller mindre, end der står. En model, der\nmarkerer fakturaer, har selv udledt sin regel af gamle fakturaer. Den kan derfor\ntage fejl på måder, som ingen har skrevet ned, og den skifter adfærd, så snart\nde data, den lærer af, skifter.\n\n## Hvorfor det betyder noget\n\nVisse opgaver er langt lettere at vise end at forklare. Ingen kan skrive en\nudtømmende regel for, hvilke fakturaer der ender med at blive betalt for sent,\nmen de fleste virksomheder ligger inde med flere års fakturaer, hvor det\nfaktiske udfald er registreret. Maskinlæring forvandler den historik til en\nregel, der kan bruges, og kan gøre det for mange lignende spørgsmål på én gang.\nDerfor er teknikken gået fra forskningslaboratoriet til helt almindelig\nforretningssoftware.\n\nBagsiden er, at data nu gør det arbejde, som koden før gjorde. Er der fejl,\ndubletter eller huller i historikken, lærer modellen dem også, og der er intet i\nkoden, der røber det. D. Sculley og ni kolleger fra Google beskrev følgerne i\n*Hidden Technical Debt in Machine Learning Systems*, en artikel i proceedings\nfra NIPS-konferencen i 2015, og deres emne er teknisk gæld. Artiklens første\nfigur tegner selve læringskoden som en lille sort boks midt i et meget større\nsystem, og ifølge billedteksten er infrastrukturen omkring den både enorm og\nkompleks. Et sted vurderer forfatterne, at et modent system kan ende med at\nbestå af højst 5 procent maskinlæringskode og mindst 95 procent limkode, hvis\neneste opgave er at flytte data ind i og ud af generelle softwarepakker.\n\nDe påpeger også, at det er dyrere at afhænge af data end af kode. Compilere og\nbyggesystemer kan analysere, hvilken kode der afhænger af hvilken, men\ntilsvarende værktøjer til data er langt sjældnere. En kolonne kan derfor få en\nny betydning, uden at noget som helst opdager det. Forfatterne giver også et\nprincip et navn, CACE, som står for »Changing Anything Changes Everything«:\nændres fordelingen af ét input, kan modellens måde at bruge alle de andre input\npå ændre sig med.\n\nEn model er med andre ord billig at bygge og dyr at holde kørende. Det, der\nafgør, om den gør nytte, handler for det meste om data: hvor de stammer fra, om\nhver kunde står der én eller tre gange, om det registrerede udfald overhovedet\ner korrekt, og hvem der opdager det, når et system længere oppe i kæden begynder\nat levere noget andet end før.\n\n## Sådan ser det ud i praksis\n\nForestil dig en virksomhed, der vil vide allerede samme dag, som en faktura\nbliver udstedt, om den sandsynligvis bliver betalt for sent. Så kan en\nmedarbejder ringe til kunden før forfaldsdagen og ikke først bagefter. Et udtræk\nhar én række pr. tidligere faktura, sorteret efter udstedelsesdato, og fire\nkolonner, som alle var kendt den dag, fakturaen blev sendt: beløbet, antallet af\nkreditdage, hvor mange fakturaer kunden fik i det foregående år, og hvor mange\naf dem der blev betalt for sent. En femte kolonne fortæller, hvordan det gik: 1,\nhvis fakturaen blev betalt for sent, og 0, hvis den blev betalt til tiden.\n\nScriptet herunder er skrevet til denne artikel og gennemgået linje for linje mod\ndokumentationen til scikit-learn 1.9.1 og NumPy 2.5 i oktober 2026. Det træner\nen model på de ældste tre fjerdedele af fakturaerne og tester den på den nyeste\nfjerdedel:\n\n```python\n# invoices.csv: én række pr. faktura sorteret efter dato, kun tal.\n# Sidste kolonne er 1, hvis fakturaen blev betalt for sent, ellers 0.\nimport numpy as np\nfrom sklearn.dummy import DummyClassifier\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.metrics import balanced_accuracy_score\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.pipeline import make_pipeline\nfrom sklearn.preprocessing import StandardScaler\n\ndata = np.loadtxt(\"invoices.csv\", delimiter=\",\", skiprows=1)\nX, y = data[:, :-1], data[:, -1].astype(int)\n\n# Hold den nyeste fjerdedel tilbage: intet lærer af den.\nX_old, X_new, y_old, y_new = train_test_split(\n    X, y, test_size=0.25, shuffle=False\n)\n\nmodel = make_pipeline(StandardScaler(), LogisticRegression())\nbaseline = DummyClassifier(strategy=\"most_frequent\")\nfor name, candidate in [(\"model\", model), (\"baseline\", baseline)]:\n    candidate.fit(X_old, y_old)\n    score = balanced_accuracy_score(y_new, candidate.predict(X_new))\n    print(name, round(score, 3))\n```\n\nFire beslutninger i scriptet betyder mere end valget af algoritme.\n\n**Den nyeste fjerdedel lægges til side, før noget lærer.** Med `shuffle=False`\nbevarer `train_test_split` rækkefølgen og lægger de sidste rækker i testsættet.\nModellen lærer altså af ældre fakturaer og bliver bedømt på nyere, præcis som\nden skal bruges i virkeligheden. Lod man standardværdien `shuffle=True` stå,\nville opdelingen blive tilfældig, og modellen ville delvis blive testet på\nfakturaer, der er ældre end nogle af dem, den har lært af.\n\n**Skaleringen sidder inde i pipelinen.** `StandardScaler` trækker hver features\nmiddelværdi fra og skalerer den til enhedsvarians. Fordi `make_pipeline` kæder\nskaleringen sammen med klassifikatoren, beregnes middelværdi og varians alene ud\nfra træningsrækkerne, og intet fra den nyeste fjerdedel siver ind i modellen.\n\n**Målet er balanceret nøjagtighed.** For hver af de to klasser regnes den andel\nud, som modellen ramte rigtigt, altså de sene fakturaer, den fangede, og de\nrettidige, den genkendte, og så tages gennemsnittet. Bliver hver tiende faktura\nbetalt for sent, belønner almindelig nøjagtighed en model, der svarer »til\ntiden« hver eneste gang. Det gør balanceret nøjagtighed ikke.\n\n**Modellen skal slå en referencemodel.** `DummyClassifier` med\n`strategy=\"most_frequent\"` ser bort fra alle features og svarer altid med den\nhyppigste klasse. Målt på balanceret nøjagtighed får den 0,5, når der er to\nklasser, for den rammer hver rettidig faktura og misser hver sen. Slår modellen\nden ikke tydeligt, har den ikke lært noget brugbart, uanset hvor pæn dens\nalmindelige nøjagtighed ser ud.\n\nIntet af det redder en model fra dårlige rækker. Står den samme kunde som tre\nforskellige poster, bliver antallet af kundens sene fakturaer fordelt på tre, og\nmodellen lærer af en historik, der aldrig har fundet sted. Vores side om\n[Klargøring af data til AI](/da/services/ai-data/) handler om netop det\nforarbejde: at hver kunde kun findes én gang, at den enkelte medarbejder kun får\nadgang til det, vedkommende skal se, og at ethvert svar kan følges tilbage til\nde data, det bygger på. For en model er det sidste punkt det, der gør det muligt\nat gå baglæns fra en underlig forudsigelse til de rækker, der gav den.\n\n## Hvor det går galt\n\n**Oplysninger fra fremtiden sniger sig ind i træningen.** Vejledningen om\nalmindelige faldgruber i scikit-learn kalder det datalækage (data leakage):\nmodellen bygges med oplysninger, som ikke vil findes, når den skal forudsige. I\nfakturaeksemplet er den fristende ekstra kolonne antallet af udsendte rykkere.\nDen forudsiger forsinkelse fremragende, fordi rykkere først sendes, når en\nfaktura allerede er forfalden. Samme læk opstår mere ubemærket, når en skalering\neller en udfyldning af manglende værdier tilpasses på samtlige rækker før\nopdelingen, og vejledningens regel er, at man aldrig kalder `fit` på testdata.\nLøsningen er at skrive ned, hvornår hver kolonnes værdi bliver kendt, at dele\ndata først og at lade al forbehandling ligge i pipelinen, så den kun tilpasses\npå træningsrækkerne.\n\n**Modellen bedømmes på noget, den allerede har set.** En model, der bare gentog\nde svar, den var trænet på, ville få fuld score på sine egne træningsrækker og\nvære værdiløs over for alt nyt. Vejledningen om krydsvalidering kalder det\novertilpasning (overfitting). En mere lumsk variant er at afprøve mange\nindstillinger og beholde den, der scorer bedst på de tilbageholdte rækker, for\nså siver viden om netop de rækker ind i valget. Sammenlign i stedet\nindstillinger med krydsvalidering på træningsdelen, hvor rækkerne skæres i flere\nfold, og hver fold på skift er testsæt. De tilbageholdte rækker ser man på én\ngang, til allersidst.\n\n**Høj nøjagtighed, som en konstant kunne matche.** Når den ene klasse er\nsjælden, bliver nøjagtigheden domineret af den almindelige. Vejledningen advarer\nom, at en fold ved sjældne klasser, som ved afsløring af svindel, kan ende uden\net eneste eksempel på den sjældne klasse. Rapportér balanceret nøjagtighed eller\net andet mål pr. klasse, sammenlign med en `DummyClassifier`, og brug\nstratificerede fold, der holder klassernes andele nogenlunde ens i hver fold.\n`cross_val_score` bruger dem som standard for en klassifikator, når man giver\nden et antal fold.\n\n**En tilfældig opdeling af data, der ændrer sig over tid.** Vejledningen om\nkrydsvalidering bemærker, at antagelsen om uafhængige og identisk fordelte\nobservationer sjældent holder i praksis, og at tidsordnede data bør testes på\nobservationer, der ligger senere end dem, modellen har lært af. En tilfældig\nopdeling lader modellen kigge ind i fremtiden og giver en score, den aldrig når\ni drift. Del efter dato, som eksemplet gør, og brug ved krydsvalidering en\nopdeling, der tager hensyn til tiden, for eksempel `TimeSeriesSplit`, hvis fold\nifølge vejledningen hver bør dække et lige så langt tidsrum.\n\n**Forbehandlingen er ikke den samme i træning og drift.** Har modellen lært af\nskalerede features, og sender det kørende system rå tal, bliver forudsigelserne\nforkerte, uden at der kommer nogen fejlmeddelelse. Vejledningen om faldgruber\nkræver, at enhver transformation, der bruges under træningen, også anvendes på\ntestdata og på data i produktion. Lever den tilpassede pipeline som ét samlet\nobjekt frem for en model med en vejledning i, hvad der først skal gøres ved\ndata.\n\n**Verden ændrer sig, efter modellen er sat i drift.** En model, der er trænet på\nsidste års fakturaer, går ud fra, at kunderne stadig opfører sig som dengang.\nSculley og hans medforfattere foreslår at holde øje med forudsigelsesbias\n(prediction bias): i et system, der fungerer efter hensigten, bør fordelingen af\nde forudsagte kategorier normalt svare til fordelingen af dem, der faktisk\nobserveres, og et voksende gab mellem de to er ofte det første tegn på, at\nverden har flyttet sig. Lad den sammenligning køre fast, træn igen på nyere\ndata, og hold en fastfrosset, versioneret kopi af hvert inputsignal, som et\nandet team ejer, så en velment ændring længere oppe i kæden ikke i al stilhed\nændrer jeres model.\n\n## Læs mere\n\n- [User Guide](https://scikit-learn.org/stable/user_guide.html)\n  — scikit-learns opslagsværk om superviseret og ikke-superviseret læring og om\n  modelvalg og evaluering, kapitel for kapitel.\n- [Getting Started](https://scikit-learn.org/stable/getting_started.html)\n  — estimatorernes fælles grænseflade vist i korte eksempler: tilpasning og\n  forudsigelse, transformere, sammenkædede trin og krydsvalidering.\n- [Common pitfalls and recommended practices](https://scikit-learn.org/stable/common_pitfalls.html)\n  — inkonsekvent forbehandling, datalækage og tilfældighed, med den forkerte og\n  den rigtige fremgangsmåde side om side i kode.\n- [Cross-validation: evaluating estimator performance](https://scikit-learn.org/stable/modules/cross_validation.html)\n  — hvorfor en test på træningsdata vildleder, og hvilken opdeling der passer\n  til grupperede, skævt fordelte eller tidsordnede data.\n- [Hidden Technical Debt in Machine Learning Systems](https://papers.nips.cc/paper_files/paper/2015/hash/86df7dcfd896fcaf2674f757a2463eba-Abstract.html)\n  — Sculley og kolleger fra Google, NIPS 2015, om hvad det koster at drive en\n  model i produktion ud over selve modellen.\n\n\u003chttps://engineer.company/da/glossary/machine-learning/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hvordan maskinlæring lærer software en opgave ud fra eksempler, hvordan en første model på fakturadata ser ud, og de fejl, der får den til at se for god ud.","formats":{"gemtext":"https://engineer.company/da/glossary/machine-learning/index.gmi","gopher":"https://engineer.company/da/glossary/machine-learning/gophermap","html":"https://engineer.company/da/glossary/machine-learning/","json":"https://engineer.company/da/glossary/machine-learning/index.json","markdown":"https://engineer.company/da/glossary/machine-learning/index.md","pdf":"https://engineer.company/da/glossary/machine-learning/index.pdf"},"kind":"page","language":"da","title":"Hvad er maskinlæring?","url":"https://engineer.company/da/glossary/machine-learning/","version":1}