Zielfunktion einfach erklärt: Definition, Beispiele und Optimierung

Jedes Machine-Learning-Modell, das du trainierst, löst ein Optimierungsproblem – und das, was du dabei eigentlich optimierst, ist die Zielfunktion.

Einfach gesagt: Es ist eine mathematische Funktion, die misst, wie „gut" eine Lösung ist. Sie nimmt Eingaben entgegen und liefert einen einzelnen Score. Ziel ist es immer, die Werte zu finden, die diesen Score maximieren oder minimieren. Von Linearer Programmierung bis Deep Learning – überall steckt eine Zielfunktion im Kern. Wenn du einmal verstanden hast, wie sie funktioniert, wirst du sie überall wiedererkennen.

In diesem Artikel erkläre ich, was Zielfunktionen sind, wie sie sich von Loss- und Kostenfunktionen unterscheiden und wie sie in Machine Learning und Optimierung eingesetzt werden.

Du willst einen Deep-Learning-Deep-Dive, der auch 2026 noch relevant ist? Melde dich zu unserem Deep Learning in Python Kurs an und baue dir ein PyTorch-Portfolio auf.

Was ist eine Zielfunktion?

Eine Zielfunktion ist eine mathematische Funktion, die bewertet, wie gut eine Lösung ist.

Du gibst ihr eine Menge von Eingaben – Modellparameter, Entscheidungsvariablen – und sie gibt eine einzelne Zahl zurück. Diese Zahl sagt dir, wie gut deine aktuelle Lösung abschneidet. Je höher (oder niedriger) diese Zahl, desto besser (oder schlechter) deine Lösung.

Wenn wir schon dabei sind, lass uns Optimierung im Allgemeinen kurz einordnen.

Optimierung ist der Prozess, die Eingaben so zu finden, dass sich die Zahl in die gewünschte Richtung bewegt. Wenn du minimierst, willst du den kleinstmöglichen Wert. Wenn du maximierst, den größtmöglichen. So oder so: Die Zielfunktion ist das, woran du misst.

Ganz plastisch: Denk daran wie an ein Bewertungssystem. Jede mögliche Lösung bekommt einen Score – und deine Aufgabe ist es, die mit dem besten Score zu finden.

Zielfunktion vs. Loss-Funktion vs. Kostenfunktion

Diese drei Begriffe werden ständig durcheinander genutzt – sie bedeuten aber nicht genau dasselbe.

Die Zielfunktion ist der übergeordnete Begriff. Es ist jede Funktion, die du maximieren oder minimieren willst. Sie muss überhaupt nichts mit Fehlern oder Vorhersagen zu tun haben – sie definiert nur, was „besser" für dein Problem bedeutet.

Eine Loss-Funktion misst den Fehler für ein einzelnes Trainingsbeispiel – also wie weit die Vorhersage deines Modells vom wahren Wert abweicht. Die mittlere quadratische Abweichung für einen Datenpunkt ist zum Beispiel eine Loss-Funktion.

Eine Kostenfunktion aggregiert die Verluste über den gesamten Datensatz, meist als Durchschnitt. Die Kostenfunktion ist also das, was du beim Training tatsächlich minimierst – sie fasst die Modellleistung über alle Beispiele zusammen, nicht nur über eines.

In der Praxis nutzen viele ML-Frameworks und Paper diese Begriffe locker. Du wirst „Loss" dort sehen, wo „Kosten" präziser wäre, und „Objective" oft als Sammelbegriff für alle drei.

Die Unterscheidung ist wichtig, wenn du Forschungsarbeiten liest. Der Kontext verrät dir, was die Autorin oder der Autor wirklich meint.

Für einen greifbareren Vergleich sieh dir die Tabelle unten an:

Vergleichstabelle: Objective/Loss/Kostenfunktion

Zielfunktionen in der Optimierung

Jedes Optimierungsproblem hat ein Ziel und einen Satz an Grenzen.

Die Zielfunktion definiert das Ziel – was du maximieren oder minimieren willst. Die Nebenbedingungen definieren die Grenzen – den Rahmen, innerhalb dessen deine Lösung bleiben muss. Zusammen spannen sie das Problem auf.

Nehmen wir ein einfaches Ressourcenplanungsbeispiel.

Angenommen, du betreibst eine Fabrik mit zwei Produkten und willst den Gewinn maximieren. Deine Zielfunktion bildet den Gesamtgewinn als Funktion der Stückzahlen ab. Deine Nebenbedingungen erfassen die Limits – verfügbare Rohstoffe, Maschinenstunden, Personalkapazitäten. Die Zielfunktion sagt dir, was zu optimieren ist, die Nebenbedingungen, womit du arbeiten kannst.

Lineare Programmierung ist einer der gängigsten Anwendungsfälle. Es ist eine Methode, um eine lineare Zielfunktion unter linearen Nebenbedingungen zu optimieren. Sie wird überall genutzt – von Logistik, Scheduling, Lieferkette bis Finance. Die Mathematik ist gut verstanden, und Solver können Probleme mit Tausenden Variablen bewältigen.

Wichtig: Die Zielfunktion ändert nicht die Nebenbedingungen – sie sagt dem Solver nur, worauf er zielen soll. Änderst du die Zielfunktion, bekommst du mit denselben Nebenbedingungen eine komplett andere Lösung.

Zielfunktionen im Machine Learning

Im Machine Learning definiert die Zielfunktion, was dein Modell tatsächlich lernt.

Jedes Training läuft als Optimierungsalgorithmus (denk an Gradient Descent, Adam, RMSProp), der die Modellparameter so anpasst, dass die Zielfunktion minimiert oder maximiert wird. Das Modell weiß nichts über dein Fachproblem. Es kennt nur den Score der Zielfunktion und versucht, ihn mit jedem Update zu verbessern.

Das heißt: Deine Wahl der Zielfunktion formt das Ergebnis. Es lohnt sich, mehrere Varianten auszuprobieren und zu sehen, was für deinen Fall am besten funktioniert.

Mean Squared Error (Regression)

Mean Squared Error (MSE) ist die Standard-Zielfunktion für Regressionsprobleme. Sie misst die durchschnittliche quadratische Abweichung zwischen den Vorhersagen deines Modells und den tatsächlichen Zielwerten.

MSE-Formel

Durch das Quadrieren werden alle Fehler positiv und große Fehler stärker bestraft als kleine. Eine Vorhersage, die um 10 danebenliegt, trägt 100 zur Summe bei – nicht nur 10. Dadurch ist MSE empfindlich gegenüber Ausreißern – etwas, das du bei unordentlichen Realweltdaten im Blick haben solltest.

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

Cross-Entropy-Loss (Klassifikation)

Cross-Entropy-Loss ist die Standard-Zielfunktion für Klassifikationsprobleme. Sie misst, wie weit die vorhergesagte Wahrscheinlichkeitsverteilung deines Modells von der wahren Klassenverteilung entfernt ist.

Cross-Entropy-Loss-Funktion

Weist dein Modell der korrekten Klasse eine hohe Wahrscheinlichkeit zu, ist der Loss gering. Ist es zuversichtlich, aber falsch, ist der Loss hoch – das wird bestraft. Genau das drückt das Modell dahin, die richtige Klasse vorherzusagen und dabei selbstbewusst zu sein.

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

Cross-Entropy-Ausgabe

Log-Likelihood

Log-Likelihood ist in probabilistischen und statistischen Modellen üblich. Die Funktion maximiert die Wahrscheinlichkeit, dass die Parameter deines Modells die beobachteten Daten erzeugt haben.

Log-Likelihood-Formel

Man arbeitet mit dem Logarithmus der Likelihood statt mit der Likelihood selbst, weil sich so ein Produkt von Wahrscheinlichkeiten in eine Summe verwandelt – viel einfacher zu berechnen und zu optimieren.

In der Praxis minimieren die meisten Frameworks die Negative Log-Likelihood (NLL) statt die Log-Likelihood zu maximieren. Das ist dasselbe – nur gedreht, damit Gradient Descent damit arbeiten kann.

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

Log-Likelihood-Ausgabe

Training ist im Kern schlicht Optimierung. Jeder Forward-Pass berechnet den Wert der Zielfunktion. Jeder Backward-Pass berechnet Gradienten. Und jedes Parameterupdate bewegt das Modell in die Richtung, die den Score verbessert.

Konvexe vs. nicht-konvexe Zielfunktionen

Nicht alle Zielfunktionen sind gleich. Ihre Form bestimmt, wie schwer sie zu optimieren sind und wie sehr du der gefundenen Lösung trauen kannst.

Lineare Zielfunktionen

Eine lineare Zielfunktion liefert eine lineare Beziehung zwischen Eingaben und Ausgabe. Änderst du eine Eingabe um einen festen Betrag, ändert sich die Ausgabe um einen festen Betrag.

Lineare Funktionen kommen in der linearen Programmierung zum Einsatz, bei der sowohl Ziel als auch Nebenbedingungen linear sind. Das macht sie zur einfachsten Klasse von Zielfunktionen – Solver finden zuverlässig das globale Optimum, selbst bei großen Problemen.

Nichtlineare Zielfunktionen

Eine nichtlineare Zielfunktion hat eine komplexere Beziehung zwischen Eingaben und Ausgabe. Die meisten Realweltprobleme – und nahezu alle ML-Modelle – fallen in diese Kategorie.

MSE ist nichtlinear. Cross-Entropy ist nichtlinear. Loss-Landschaften von Neuronalen Netzen sind nichtlinear. Die zusätzliche Komplexität erlaubt es, komplexe Zusammenhänge in Daten abzubilden – macht die Optimierung aber schwerer.

Konvex versus nicht-konvex

Hier wird es spannend.

Eine konvexe Funktion hat die Form einer Schüssel. Jede Verbindungsstrecke zwischen zwei Punkten auf der Kurve liegt über oder auf der Kurve. Das garantiert: Jedes lokale Minimum ist auch das globale Minimum – wenn dein Optimierer einen Boden findet, ist es der echte Boden.

Eine nicht-konvexe Funktion hat eine unregelmäßigere Form – mehrere Täler, Plateaus und Sattelpunkte. Optimierer können in einem lokalen Minimum steckenbleiben – einem Tal, das wie der Boden aussieht, es aber nicht ist. Tiefe Neuronale Netze haben stark nicht-konvexe Loss-Landschaften – deswegen erfordern sie sorgfältiges Tuning von Lernrate, Optimierer und Initialisierung.

Konvexe Probleme werden exakt gelöst, nicht-konvexe nur näherungsweise. Die Qualität deiner Lösung hängt von deiner Optimierungsstrategie ab.

Für visuelle Typen hier ein Vergleich zwischen linearen, nichtlinearen, konvexen und nicht-konvexen Zielfunktionen:

Vergleich der Typen von Zielfunktionen

Wie Zielfunktionen optimiert werden

Sobald du eine Zielfunktion hast, brauchst du eine Methode, sie zu minimieren oder zu maximieren. Hier kommen Optimierungsalgorithmen ins Spiel.

Der gängigste Ansatz ist der Gradient Descent. Die Idee: den Gradienten der Zielfunktion bezüglich der Modellparameter berechnen und dann einen kleinen Schritt in die Richtung machen, die den Funktionswert senkt. Dann wiederholen, bis sich der Wert nicht mehr verbessert.

Der Gradient ist einfach die Ableitung der Zielfunktion.

Er sagt dir die Steigung an deiner aktuellen Position und in welche Richtung es „bergauf" geht. Um zu minimieren, gehst du in die Gegenrichtung. Um zu maximieren, mit der Steigung.

Der Prozess ist iterativ: Mit einer Folge kleiner Updates bewegst du die Parameter schrittweise zum Optimum. Die Schrittweite steuert die Lernrate. Ist sie zu groß, schießt du übers Ziel hinaus, ist sie zu klein, dauert das Training länger.

In der Praxis verwenden die meisten ML-Frameworks Abwandlungen, die schneller und stabiler sind als die Basisversion:

• Stochastic Gradient Descent (SGD) berechnet den Gradienten pro Schritt an einem zufälligen Beispiel statt am gesamten Datensatz
• Mini-Batch Gradient Descent nutzt pro Schritt einen kleinen Batch – der Mittelweg zwischen SGD und Full-Batch
• Adam passt die Lernrate pro Parameter an – das macht das Tuning verzeihender

Die Zielfunktion muss differenzierbar sein – oder zumindest weitgehend –, damit gradientenbasierte Methoden funktionieren. Keine Ableitung bedeutet kein Gradient – der Optimierer hat dann nichts, dem er folgen kann. Das ist ein zentraler Merksatz.

Beispiel für eine Zielfunktion

Machen wir es konkret mit einer einfachen Linearen Regression.

Angenommen, du sagst Hauspreise anhand der Quadratmeterzahl voraus. Du hast einen Datensatz mit bekannten Preisen und willst eine Gerade finden, die den Vorhersagefehler minimiert. Deine Zielfunktion ist die Mean Squared Error (MSE) – die Formel kennst du bereits.

Die Eingaben sind die Modellparameter – Steigung und Achsenabschnitt der Geraden. Die Ausgabe ist eine einzelne Zahl – der durchschnittliche quadratische Fehler über alle Vorhersagen. In diesem Fall gilt: Je kleiner, desto besser.

So könnte eine Python-Implementierung aussehen:

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: gutes vs. schlechtes Fit

Das erste Parameterset ergibt einen deutlich niedrigeren MSE – es passt die Daten besser. Genau solche Signale nutzt der Optimierer, um die Richtung für das nächste Update zu wählen.

Für visuelle Typen hilft die folgende Grafik:

MSE-Beispiel

Links siehst du beide Fits gegen die Daten, rechts die MSE-Fläche über verschiedene Steigungswerte – also die Zielfunktion als Kurve.

Der linke Plot zeigt, wie die beiden Parametersets zu den Daten passen. Der rechte zeigt die MSE-Fläche über den Steigungswerten – die Zielfunktion als Kurve mit einem klaren Minimum, das der Optimierer finden will. Jeder Schritt von Gradient Descent bewegt sich auf dieser Kurve in Richtung Minimum.

Nebenbedingungen und Zielfunktionen

Eine Zielfunktion sagt dir, was zu optimieren ist. Nebenbedingungen sagen dir, was erlaubt ist.

In den meisten realen Problemen kannst du nicht einfach grenzenlos maximieren oder minimieren. Du arbeitest innerhalb von Limits wie Budget, Zeitfenster oder physischer Kapazität. Diese Limits heißen Nebenbedingungen und definieren die Menge gültiger Lösungen, aus denen der Optimierer wählen kann.

Ein Fertigungsbeispiel:

Du willst den Gewinn über zwei Produktlinien maximieren. Ohne Nebenbedingungen wäre die Antwort: so viel produzieren wie möglich. Tatsächlich hast du aber 500 Maschinenstunden und 1.000 Einheiten Rohmaterial. Das sind deine Nebenbedingungen. Die Zielfunktion bleibt (Gewinn maximieren), aber der Optimierer darf nur im von den Nebenbedingungen erlaubten Bereich suchen.

Veränderst du die Nebenbedingungen, ändert sich auch die optimale Lösung – selbst wenn die Zielfunktion gleich bleibt.

Diese Struktur aus Zielfunktion plus Nebenbedingungen ist die Grundlage der beschränkten Optimierung. So funktioniert Lineare Programmierung, so funktioniert Portfolio-Optimierung – und so sind viele Planungsprobleme der Realwelt formuliert.

Fazit

Jedes Optimierungsproblem – ob du ein Neuronales Netz trainierst, Ressourcen verteilst oder ein Regressionsmodell anpasst – läuft auf eins hinaus: eine Funktion, die du minimieren oder maximieren willst.

Diese Funktion ist die Zielfunktion. Sie definiert, was „besser" bedeutet, lenkt jedes Parameterupdate und bestimmt, was dein Modell lernt. Triffst du die richtige Wahl, kann dein Modell dein Problem lösen. Triffst du die falsche, löst es ein anderes – oft ohne offensichtliche Fehlermeldung.

Die Wahl der Zielfunktion ist eine Gestaltungsentscheidung in der Datenwissenschaft – sie prägt alles, was folgt. Probier ruhig aus – es gibt viele Zielfunktionen zur Auswahl.

Du weißt nicht, wo du anfangen sollst? Unsere Kurse Model Validation in Python und Hyperparameter Tuning in Python sind hervorragende Einstiege für angehende und fortgeschrittene Data Scientists.