Målfunktion förklarad: Definition, exempel och optimering

Varje maskininlärningsmodell du tränar löser ett optimeringsproblem – och det du faktiskt försöker lösa kallas målfunktionen.

Enkelt uttryckt är det en matematisk funktion som mäter hur ”bra” en lösning är. Den tar en uppsättning indata och ger ett enda poängvärde. Målet är alltid att hitta de värden som maximerar eller minimerar det poängvärdet. Du hittar målfunktioner i allt från linjär programmering till djupinlärning. Det är en sån där sak du ser överallt när du väl förstår hur den fungerar.

I den här artikeln förklarar jag vad målfunktioner är, hur de skiljer sig från förlust- och kostnadsfunktioner och hur de används i maskininlärning och optimering.

Letar du efter en djupdykning i deep learning som fortfarande är relevant 2026? Anmäl dig till vår Deep Learning in Python-kurs för att bygga en PyTorch-portfölj.

Vad är en målfunktion?

En målfunktion är en matematisk funktion som utvärderar hur bra en lösning är.

Du matar in en uppsättning indata – modellparametrar, beslutsvariabler – och den returnerar ett enda tal. Det talet talar om hur väl din nuvarande lösning presterar. Ju högre (eller lägre) tal, desto bättre (eller sämre) är din lösning.

När vi ändå är inne på ämnet, låt oss prata om optimering i allmänhet.

Det är processen att hitta de indata som driver talet i rätt riktning. Om du minimerar vill du ha det minsta möjliga värdet. Om du maximerar vill du ha det största. Oavsett vilket är målfunktionen det du mäter mot.

I vardagliga termer kan du se den som ett poängsystem. Varje kandidatlösning får ett poäng, och din uppgift är att hitta den med bäst poäng.

Målfunktion vs. förlustfunktion vs. kostnadsfunktion

De här tre termerna används ofta omväxlande – men de betyder inte exakt samma sak.

Målfunktionen är den bredaste termen. Det är vilken funktion som helst du försöker maximera eller minimera. Den behöver inte alls involvera fel eller prediktioner – den definierar bara vad ”bättre” betyder för ditt problem.

En förlustfunktion mäter felet för ett enskilt tränings-exempel – hur långt ifrån modellens prediktion är det verkliga värdet. Medelkvadratfel för en datapunkt, till exempel, är en förlustfunktion.

En kostnadsfunktion aggregerar förlusten över hela din datamängd, oftast genom att ta medelvärdet. Så kostnadsfunktionen är det du faktiskt minimerar under träning – den sammanfattar modellens prestanda över alla exempel, inte bara ett.

I praktiken använder de flesta ML-ramverk och artiklar dessa termer ganska löst. Du kommer att se ”loss” användas där ”cost” vore mer precist, och ”objective” användas för att betyda alla tre.

Skillnaderna spelar roll när du läser forskningsartiklar. Kontexten talar om vilken författaren faktiskt syftar på.

För en mer konkret jämförelse, se tabellen nedan:

Jämförelsetabell för mål-/förlust-/kostnadsfunktion

Målfunktioner i optimering

Varje optimeringsproblem har ett mål och en uppsättning begränsningar.

Målfunktionen definierar målet – vad du försöker maximera eller minimera. Begränsningarna definierar ramarna – gränserna som din lösning måste hålla sig inom. Tillsammans ramar de in problemet.

Ta ett enkelt exempel på resursallokering.

Säg att du driver en fabrik som producerar två produkter och du vill maximera vinsten. Din målfunktion fångar den totala vinsten som en funktion av hur många enheter av varje produkt du tillverkar. Dina begränsningar fångar gränserna – tillgängliga råvaror, maskintimmar, arbetskapacitet. Målfunktionen talar om vad du ska optimera och begränsningarna talar om vad du har att jobba med.

Linjär programmering är ett av de vanligaste sammanhangen där detta är tillämpligt. Det är en metod för att optimera en linjär målfunktion under linjära begränsningar. Den används överallt, från logistik, schemaläggning, försörjningskedja till finans. Matematiken är väl förstådd och lösare kan hantera problem med tusentals variabler.

Det är viktigt att notera att målfunktionen inte ändrar vilka begränsningar som finns – den talar bara om för lösaren vad som ska eftersträvas. Om du ändrar målfunktionen får du en helt annan lösning, även med samma begränsningar.

Målfunktioner i maskininlärning

I maskininlärning definierar målfunktionen vad din modell faktiskt lär sig att göra.

Varje gång du tränar en modell kör du en optimeringsalgoritm (tänk gradientnedstigning, Adam, RMSProp) som justerar modellparametrar för att minimera eller maximera målfunktionen. Modellen vet ingenting om ditt problem. Den känner bara till poängen som målfunktionen ger den, och försöker förbättra den poängen vid varje uppdatering.

Det betyder att ditt val av målfunktion formar utfallet. Det är en god idé att prova några olika för att se vad som fungerar bäst i ditt fall.

Medelkvadratfel (regression)

Mean Squared Error (MSE), medelkvadratfel, är standardmålfunktionen för regressionsproblem. Den mäter den genomsnittliga kvadrerade skillnaden mellan modellens prediktioner och de faktiska målvärdena.

MSE-formel

Att kvadrera skillnaderna gör alla fel positiva och straffar stora fel mer än små. En prediktion som missar med 10 bidrar med 100 till summan – inte bara 10. Det gör MSE känsligt för avvikare, något att se upp med i stökiga data från verkligheten.

import numpy as np

y_true = np.array([3.0, 5.0, 2.5, 7.0])
y_pred = np.array([2.8, 5.2, 2.0, 6.5])

mse = np.mean((y_true - y_pred) ** 2)
print(f"MSE: {mse:.4f}")

MSE-utdata

Korsentropiförlust (klassificering)

Korsentropiförlust (Cross-Entropy Loss) är standardmålfunktionen för klassificeringsproblem. Den mäter hur långt modellens förutsagda sannolikhetsfördelning ligger från den sanna klassfördelningen.

Korsentropins förlustfunktion

Om din modell tilldelar en hög sannolikhet till rätt klass blir förlusten låg. Om den är självsäker men har fel blir förlusten hög, och det straffas. Det är det som driver modellen att förutsäga rätt klass och vara säker på den.

import numpy as np

# True labels (one-hot encoded)
y_true = np.array([1, 0, 0])

# Model's predicted probabilities
y_pred = np.array([0.7, 0.2, 0.1])

cross_entropy = -np.sum(y_true * np.log(y_pred))
print(f"Cross-Entropy Loss: {cross_entropy:.4f}")

Korsentropi-utdata

Log-likelihood

Log-likelihood är vanligt i probabilistiska och statistiska modeller. Funktionen maximerar sannolikheten att dina modellparametrar gav upphov till de data du observerat.

Formel för log-likelihood

Du arbetar med logaritmen av likelihood i stället för likelihood i sig eftersom det omvandlar en produkt av sannolikheter till en summa, vilket är mycket enklare att beräkna och optimera.

I praktiken minimerar de flesta ramverk den negativa log-likelihooden (NLL) i stället för att maximera log-likelihood. Det är samma sak – bara inverterat så att gradientnedstigning kan användas.

import numpy as np
from scipy.stats import norm

# Observed data
data = np.array([1.2, 2.3, 1.8, 2.1, 1.9])

# Assumed model parameters
mu, sigma = 2.0, 0.5

# Compute negative log-likelihood
nll = -np.sum(norm.logpdf(data, loc=mu, scale=sigma))
print(f"Negative Log-Likelihood: {nll:.4f}")

Utdata för log-likelihood

Träning är i grunden bara optimering. Varje framåtriktad pass beräknar värdet av målfunktionen. Varje bakåtriktad pass beräknar gradienter. Och varje parameteruppdatering flyttar modellen i riktning mot en bättre poäng.

Konvexa vs. icke-konvexa målfunktioner

Alla målfunktioner är inte likadana. Deras form avgör hur svåra de är att optimera och om du kan lita på lösningen du hittar.

Linjär målfunktion

En linjär målfunktion ger ett linjärt samband mellan indata och utdata. När du ändrar en indata med en fast mängd förändras utdata med en fast mängd.

Linjär funktion används i linjär programmering, där både målfunktionen och begränsningarna är linjära. Det gör dem till den enklaste klassen av målfunktioner att optimera, eftersom lösare pålitligt kan hitta det globala optimumet, även för stora problem.

Ickelinjär målfunktion

En ickelinjär målfunktion har ett mer komplext samband mellan indata och utdata. De flesta problem i verkligheten – och nästan alla maskininlärningsmodeller – faller i denna kategori.

MSE är ickelinjär. Korsentropi är ickelinjär. Neurala nätverks förlustytor är ickelinjära. Den extra komplexiteten låter dessa funktioner fånga komplexa samband i data, men gör också optimeringen svårare.

Konvexa kontra icke-konvexa funktioner

Det är här det blir intressant.

En konvex funktion har en skålform. Varje linjesegment draget mellan två punkter på kurvan ligger över eller på kurvan. Detta garanterar att varje lokalt minimum också är det globala minimumet – vilket betyder att om din optimerare hittar en botten, så är det den riktiga botten.

En icke-konvex funktion har en mer oregelbunden form – flera dalar, platåer och sadelpunkter. Optimerare kan fastna i ett lokalt minimum, en dal som ser ut som botten men inte är det. Djupa neurala nätverk har starkt icke-konvexa förlustytor, vilket är varför träningen kräver noggrann inställning av inlärningshastigheter, optimerare och initialisering.

Konvexa problem löses exakt, och icke-konvexa problem löses approximativt. Kvaliteten på din lösning beror på din optimeringsstrategi.

För visuella typer, här är en jämförelse mellan linjära, ickelinjära, konvexa och icke-konvexa målfunktioner:

Jämförelse av målfunktionstyper

Hur målfunktioner optimeras

När du har en målfunktion behöver du ett sätt att minimera eller maximera den. Det är där optimeringsalgoritmer kommer in.

Det vanligaste tillvägagångssättet är gradientnedstigning. Idén är att beräkna gradienten av målfunktionen med avseende på modellens parametrar och sedan ta ett litet steg i riktning som minskar värdet. Därifrån upprepar du tills värdet slutar förbättras.

Gradienten är helt enkelt derivatan av målfunktionen.

Den berättar om lutningen på din nuvarande position och vilket håll som är ”uppför”. För att minimera funktionen rör du dig i motsatt riktning. För att maximera den rör du dig med den.

Denna process är iterativ, vilket betyder att du når lösningen genom en serie små uppdateringar, där varje steg för parametrarna närmare optimum. Storleken på varje steg styrs av inlärningshastigheten. Ett för stort värde kan göra att du överskjuter optimum, och ett för litet gör att träningen tar längre tid.

I praktiken använder de flesta ML-ramverk varianter av gradientnedstigning som är snabbare och stabilare än grundversionen:

• Stokastisk gradientnedstigning (SGD) beräknar gradienten på ett enda slumpmässigt exempel per steg i stället för hela datamängden
• Mini-batch gradientnedstigning använder en liten batch av exempel per steg – en medelväg mellan SGD och full-batch
• Adam anpassar inlärningshastigheten för varje parameter, vilket gör den mer förlåtande att ställa in

Målfunktionen måste vara deriverbar, eller åtminstone mestadels deriverbar, för att gradientbaserade metoder ska fungera. Ingen derivata betyder ingen gradient, vilket betyder att optimeraren inte har något att följa. Det är en viktig sak att komma ihåg.

Exempel på en målfunktion

Låt oss göra detta konkret med ett enkelt linjärt regressionsproblem.

Säg att du förutspår huspriser baserat på boyta. Du har en datamängd med hus och kända priser, och du vill passa en linje genom data som minimerar prediktionsfelet. Din målfunktion är Mean Squared Error (MSE) vars formel du redan känner till.

Indata är din modells parametrar – lutningen och skärningen för linjen. Utdata är ett enda tal – det genomsnittliga kvadrerade felet över alla prediktioner. I det här fallet betyder lägre bättre.

Här är hur en möjlig Python-implementering kan se ut:

import numpy as np

np.random.seed(42)

# Generate some fake housing data
square_footage = np.random.uniform(500, 3000, 100)
true_price = 150 * square_footage + 50000 + np.random.normal(0, 15000, 100)

def predict(x, slope, intercept):
    return slope * x + intercept

def mse(y_true, y_pred):
    return np.mean((y_true - y_pred) ** 2)

# Try two different parameter sets
slope_a, intercept_a = 150, 50000  # good fit
slope_b, intercept_b = 80, 100000  # bad fit

pred_a = predict(square_footage, slope_a, intercept_a)
pred_b = predict(square_footage, slope_b, intercept_b)

print(f"MSE (good fit):  {mse(true_price, pred_a):,.2f}")
print(f"MSE (poor fit):  {mse(true_price, pred_b):,.2f}")

MSE: bra kontra dålig passning

Den första parameteruppsättningen ger ett mycket lägre MSE, vilket betyder att den passar datan bättre. Det är precis det optimeraren använder för att avgöra åt vilket håll den ska röra sig.

För visuella typer, betrakta följande bild:

MSE-exempel

Du kan se båda passningarna mot datan och även MSE-ytan över ett intervall av lutningsvärden för att se själva målfunktionen.

Plottningen till vänster visar hur de två parameteruppsättningarna passar datan. Plottningen till höger visar MSE-ytan över lutningsvärden – målfunktionen som en kurva, med ett tydligt minimum som optimeraren försöker hitta. Varje steg i gradientnedstigning rör sig längs denna kurva mot det minimumet.

Begränsningar och målfunktioner

En målfunktion talar om vad du ska optimera. Begränsningar talar om vad du får göra.

I de flesta verkliga problem kan du inte bara maximera eller minimera som du vill. Du arbetar inom ramar, såsom en budget, en tidsram eller en fysisk kapacitet. Dessa ramar kallas begränsningar, och de definierar mängden giltiga lösningar som din optimerare kan välja bland.

Ta ett tillverknings-exempel.

Säg att du vill maximera vinst över två produktlinjer. Utan begränsningar är svaret att producera så mycket som möjligt. Men du har 500 maskintimmar och 1 000 enheter råmaterial tillgängliga. Det är dina begränsningar. Målfunktionen är densamma (maximera vinst), men optimeraren kan bara söka inom det område som begränsningarna tillåter.

När du ändrar begränsningarna ändras också den optimala lösningen, även om målfunktionen inte gör det.

Denna struktur – en målfunktion med en uppsättning begränsningar – är grunden för begränsad optimering. Det är så linjär programmering fungerar, hur portföljoptimering fungerar och hur många planeringsproblem i verkligheten formuleras.

Slutsats

Varje optimeringsproblem – oavsett om du tränar ett neuralt nätverk, allokerar resurser eller anpassar en regressionsmodell – kokar ner till en sak: en funktion du försöker minimera eller maximera.

Målfunktionen är den funktionen. Den definierar vad ”bättre” betyder, vägleder varje parameteruppdatering och avgör vad din modell faktiskt lär sig. Om du väljer rätt kan din modell lösa problemet du har. Men om du väljer fel löser den ett helt annat problem – ofta utan någon tydlig varning om att något är fel.

Att välja rätt målfunktion är ett designbeslut i data science, eftersom det formar allt som följer. Som praktiker kan du gärna experimentera – det finns många målfunktioner att välja bland.

Osäker på var du ska börja? Våra kurser Model Validation in Python och Hyperparameter Tuning in Python är båda utmärkta startpunkter för data scientists på nybörjar- till medelnivå.