Maskinlæring er ikke længere forbeholdt forskere og hardcore data scientists. I dag er det et værktøj, som både undervisere, studerende og professionelle i erhvervslivet kan drage nytte af. Hos Snilld oplever vi dagligt, hvordan forståelsen af nogle få grundlæggende koncepter kan gøre en stor forskel – både i undervisningslokalet, på kontoret og i ledelsesgangen. I denne artikel gør vi fem centrale machine learning-koncepter håndgribelige og viser, hvordan de kan anvendes i praksis.

Fem nøglebegreber i maskinlæring

Vi dykker ned i:

• PCA (Principal Component Analysis)
• Feature Scaling
• Confusion Matrix for binær klassifikation
• Overfitting & underfitting
• Random Shuffle af datasæt

Disse koncepter er udvalgt, fordi de går igen i alt fra gymnasieprojekter til avancerede AI-løsninger i virksomheder. Uanset om du er underviser, studerende, data scientist eller IT-chef, vil du kunne bruge dem til at forstå, forklare og forbedre dine modeller.

PCA – fra matematik til virkelighed

PCA, eller Principal Component Analysis, er en metode til at reducere antallet af variable i et datasæt uden at miste for meget information. Forestil dig, at du har et datasæt med 20 forskellige målinger pr. observation – det kan hurtigt blive uoverskueligt. PCA hjælper med at finde de kombinationer af målinger, der forklarer mest muligt af variationen i data.

Matematisk handler det om at beregne kovariansmatricen, finde eigenvalues og eigenvectors, og derefter vælge de komponenter (K), der forklarer mest varians. I praksis betyder det, at du kan visualisere eller analysere komplekse datasæt langt nemmere. Her er et simpelt Python-eksempel, som illustrerer processen:

import numpy as np
def pca(data: np.ndarray, k: int) -> np.ndarray:
    data_std = (data - np.mean(data, axis=0)) / np.std(data, axis=0)
    cov_matrix = np.cov(data_std, rowvar=False)
    eigenvalues, eigenvectors = np.linalg.eigh(cov_matrix)
    sorted_idx = np.argsort(eigenvalues)[::-1]
    eigenvectors = eigenvectors[:, sorted_idx]
    components = eigenvectors[:, :k]
    for i in range(components.shape[1]):
        if components[0, i] < 0:
            components[:, i] *= -1
    return np.round(components, 4)

Et klassisk eksempel fra undervisningen er at bruge PCA på elevdata for at identificere de vigtigste faktorer for trivsel eller karakterer. I erhvervslivet kan PCA bruges til at analysere kunde- eller produktdata, så man fokuserer på de mest betydningsfulde parametre. Men pas på: Hvis du vælger for få komponenter, mister du vigtig information – for mange, og du opnår ikke forenklingen.

Feature scaling – undgå at én feature dominerer

Feature scaling er ofte undervurderet, men det kan være afgørende. Hvis én feature har et meget større numerisk spænd end de andre, risikerer du, at modellen kun fokuserer på den. Forestil dig et datasæt med både kvadratmeter og antal værelser – uden scaling vil kvadratmeter næsten altid dominere.

De mest brugte metoder er Min-Max scaling (normaliserer til [0,1]) og standardisering (sætter middelværdi til 0 og standardafvigelse til 1). Her er et kodeeksempel, der viser begge metoder:

import numpy as np
def feature_scaling(data: np.ndarray) -> (np.ndarray, np.ndarray):
    X_min = np.min(data, axis=0)
    X_max = np.max(data, axis=0)
    X_mean = np.mean(data, axis=0)
    X_std = np.std(data, axis=0)
    normalized_data = (data - X_min) / (X_max - X_min)
    standardized_data = (data - X_mean) / X_std
    return standardized_data, normalized_data

Hvis du ikke skalerer, kan det føre til skæve resultater – især i algoritmer som k-nærmeste naboer eller PCA. En hurtig test: Prøv at træne en model med og uden scaling, og se forskellen på præcisionen.

Confusion matrix – forstå dine klassifikationer

En confusion matrix er et værktøj til at evaluere, hvordan en klassifikationsmodel klarer sig – især ved binære problemer som spam/ikke-spam. Den viser, hvor mange rigtige og forkerte forudsigelser modellen laver, opdelt på de to klasser.

Her er et Python-eksempel, der udregner confusion matrix for et sæt forudsigelser:

def confusion_matrix(data):
    TP = 0; FP = 0; FN = 0; TN = 0
    for y_test, y_pred in data:
        if y_test == 1 and y_pred == 1: TP += 1
        elif y_test == 1 and y_pred == 0: FN += 1
        elif y_test == 0 and y_pred == 1: FP += 1
        elif y_test == 0 and y_pred == 0: TN += 1
    return [[TP, FN],[FP, TN]]

Eksempel: Hvis du har y_test = [1,1,0,1,0] og y_pred = [1,0,0,1,0], får du en matrix, der hurtigt afslører, hvor modellen fejler. Det er især nyttigt, hvis du arbejder med ubalancerede datasæt, hvor accuracy alene kan være misvisende.

Overfitting & underfitting – balancen mellem læring og generalisering

Overfitting og underfitting er to klassiske faldgruber. Overfitting betyder, at modellen er for god til at huske træningsdata, men fejler på nye data. Underfitting betyder, at modellen slet ikke lærer nok – den er for simpel.

En simpel funktion til at vurdere fit kunne se sådan ud:

def model_fit_quality(training_accuracy, test_accuracy):
    if training_accuracy - test_accuracy > 0.2:
        return 1  # overfitting
    elif training_accuracy < 0.7 and test_accuracy < 0.7:
        return -1  # underfitting
    else:
        return 0  # god fit

I praksis ser vi ofte overfitting, hvis datasættet er lille eller modellen for kompleks. Underfitting opstår typisk, hvis modellen er for simpel eller data ikke er tilstrækkeligt forarbejdet. Best practice: Brug cross-validation, regularisering og sørg for at have nok data.

Random shuffle – undgå bias i dine modeller

At shuffle datasættet betyder, at du blander rækkerne, før du splitter til træning og test. Det lyder banalt, men det er afgørende for at undgå bias – især hvis data er sorteret på en eller anden måde (fx kronologisk eller efter kategori).

Her er et eksempel på, hvordan du kan shuffle med og uden seed i Python:

import numpy as np
def shuffle_data(X, y, seed=None):
    np.random.seed(seed)
    indices = np.arange(len(X))
    np.random.shuffle(indices)
    return X[indices], y[indices]

Hvis du ikke shuffler, risikerer du, at trænings- og testdata ikke repræsenterer hele datasættet – og så bliver dine resultater misvisende. Husk: Ved tidsserier skal du ikke shuffle, da rækkefølgen er vigtig.

Fra teori til forretning og undervisning

De fem teknikker er ikke kun relevante for kodere. I undervisningen kan PCA og feature scaling gøre det lettere at forklare komplekse datasæt. For virksomheder kan confusion matrix og fit-vurdering give bedre beslutningsgrundlag, når nye modeller skal vælges. Og random shuffle er et must for alle, der vil undgå bias – uanset om det gælder elevdata eller kundedata.

Det kræver dog ressourcer og kompetencer at implementere ML korrekt. Typiske faldgruber er manglende dataforståelse, for lidt tid til datavask og for stor tillid til automatiske resultater. Hos Snilld hjælper vi med at bygge bro mellem teori og praksis, så både undervisere og virksomheder får reel værdi ud af ML.

Konklusion og næste skridt

Vi har gennemgået fem centrale koncepter, der kan løfte både undervisning, forskning og forretning. Næste skridt? Prøv selv kræfter med kodeeksemplerne – eller kontakt os i Snilld, hvis du vil have sparring om, hvordan du får mere ud af dine data. Vi anbefaler også at udforske Deep-ML og andre åbne ressourcer for at styrke din forståelse og praksis.

Maskinlæring er ikke magi – men med de rette værktøjer og lidt snilde kan alle komme i gang.

Kilder:

• https://towardsai.net/p/machine-learning/solve-deep-ml-problems-part-1-machine-learning-fundamentals-with-python
• https://www.reddit.com/r/learnmachinelearning/comments/13y4rzn/are_there_any_books_i_should_read_to_learn/
• https://towardsai.net/search/81/page/399/
• https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/
• https://developer.ibm.com/tutorials/awb-confusion-matrix-python/
• https://towardsai.net/p/machine-learning/solve-deep-ml-problems-part-1-machine-learning-fundamentals-with-python

Målgruppens mening om artiklen

Anders, Gymnasielærer i matematik og informatik:
Jeg giver artiklen 85. Den er rigtig god til at forklare centrale begreber på en måde, der er tilgængelig for både undervisere og elever. Kodeeksemplerne gør det let at omsætte teori til praksis, hvilket jeg sætter stor pris på i min undervisning. Dog kunne jeg godt have ønsket lidt flere konkrete undervisningseksempler og måske en smule mere dybde på de enkelte koncepter.

Maria, IT-chef i mellemstor virksomhed:
Jeg giver artiklen 70. Den rammer plet med at forklare de vigtigste begreber, som vi ofte støder på i virksomhedsprojekter. Sproget er letforståeligt, og eksemplerne er relevante. Jeg savner dog mere fokus på forretningsmæssige konsekvenser og cases fra erhvervslivet, så det bliver endnu mere anvendeligt for ledere og beslutningstagere.

Jonas, Data Scientist:
Jeg giver artiklen 60. Den er fin til begyndere, men for mig som arbejder professionelt med ML, er det meget overfladisk. Jeg havde gerne set mere om avancerede faldgruber, hyperparameter tuning og konkrete performance-metrics. Artiklen er dog god som introduktion for ikke-specialister.

Camilla, Studerende på datalogi:
Jeg giver artiklen 90. Jeg synes, den er super brugbar, især fordi den forklarer tingene med kodeeksempler og gør det let at følge med. Den rammer mit niveau godt, og jeg kan bruge den både til opgaver og eksamensforberedelse. Det eneste minus er, at den måske er lidt for overfladisk på nogle punkter, men det er til at leve med.

Henrik, Udviklingskonsulent i kommune:
Jeg giver artiklen 75. Jeg kan bruge den til at forklare ML-begreber for kolleger, der ikke har teknisk baggrund. Den er pædagogisk og praktisk, men jeg savner nogle eksempler, der er mere målrettet den offentlige sektor, fx social- eller sundhedsdata. Ellers rigtig fin og anvendelig.

*Denne artiklen er skrevet af en redaktion bestående af kunstig intelligenser, der har skrevet artiklen på baggrund af automatiseret research og oplysninger om de seneste teknologi nyheder fra internettet.

Billederne i artiklen er lavet af FLUX.1.1 Pro fra Black Forest Labs.