Arten des maschinellen Lernens: überwacht, unüberwacht, halbüberwacht und mehr

Gegeben seien ein Computerprogramm und diese drei Objekte:

1. T — eine Klasse von Aufgaben, die das Programm lösen soll (z. B. „entscheide bei einer E-Mail, ob sie Spam ist“);
2. P — ein Leistungsmaß: eine Regel, die dem Ergebnis des Programms bei Aufgaben aus T eine Zahl zuordnet, wobei eine größere Zahl eine bessere Leistung bedeutet (z. B. der Anteil richtig eingeordneter E-Mails);
3. E — Erfahrung: Daten oder Interaktionen, die das Programm beim Lernen bekommt (z. B. E-Mails, die schon jemand sortiert hat).

Das Programm lernt aus Erfahrung E in Bezug auf die Klasse von Aufgaben T und das Leistungsmaß P genau dann, wenn sich seine Leistung bei Aufgaben aus T, gemessen mit P, mit der Erfahrung E verbessert — d. h. ein Programm, das mehr Erfahrung aus E verarbeitet hat, erreicht auf T (im Mittel) einen höheren Wert von P.

Das ist eine begriffliche Definition, keine mathematische: T, P und E müssen für jede konkrete Aufgabe erst gewählt werden. Die formale Gestalt für überwachtes Lernen steht im nächsten Teil.

Sei 𝒳 eine nichtleere Menge (der Eingaberaum), 𝒴 eine nichtleere Menge (der Ausgaberaum) und p ∈ ℕ, p ≥ 1. Ein Modell mit Parametern θ ∈ ℝ^p ist ein System von Funktionen

f_θ : 𝒳 → 𝒴,   x ↦ f_θ(x),   θ ∈ ℝ^p,

d. h. jede Wahl des Vektors θ bestimmt eine Funktion von den Eingaben in die Ausgaben.

Sei J : ℝ^p → ℝ eine aus den Daten berechnete Zielfunktion (je kleiner J(θ), desto besser beschreibt das Modell mit den Parametern θ die Daten). Lernen (Training) ist die Suche nach Parametern

θ* ∈ argmin_{θ ∈ ℝ^p} J(θ) = {θ ∈ ℝ^p : J(θ) ≤ J(θ′) für alle θ′ ∈ ℝ^p}.

Ist J differenzierbar, sucht man typischerweise mit dem Gradientenverfahren: Wähle einen Startwert θ₀ ∈ ℝ^p und eine Lernrate η > 0 und setze für t = 0, 1, 2, …

θ_t+1 = θ_t − η ∇J(θ_t),

solange J merklich kleiner wird (oder für eine feste Anzahl von Schritten). Das Gradientenverfahren findet im Allgemeinen nur ein lokales Minimum, nicht unbedingt ein Element von argmin.

Sei 𝒳 der Eingaberaum, 𝒴 der Raum der Labels (der richtigen Antworten) und P eine unbekannte Wahrscheinlichkeitsverteilung der Paare (X, Y) auf 𝒳 × 𝒴. Weiter seien

1. n ∈ ℕ, n ≥ 1, und die Trainingsmenge D = ((x_i, y_i))_i=1ⁿ eine Folge von Paaren (x_i, y_i) ∈ 𝒳 × 𝒴, unabhängig voneinander aus P gezogen;
2. {f_θ : 𝒳 → 𝒴 : θ ∈ ℝ^p} ein Modell (siehe die Definition oben);
3. L : 𝒴 × 𝒴 → [0, ∞) eine Verlustfunktion — L(ŷ, y) ist die Strafe für die Antwort ŷ, wenn die richtige Antwort y ist.

Überwachtes Lernen ist die Suche nach Parametern, die das empirische Risiko R̂ : ℝ^p → [0, ∞) minimieren:

R̂(θ) = 1/n ∑_i=1ⁿ L(f_θ(x_i), y_i),   θ* ∈ argmin_{θ ∈ ℝ^p} R̂(θ).

Das Ziel ist aber nicht die Trainingsmenge — das Modell soll ein kleines tatsächliches Risiko R(θ) = E_{(X, Y) ∼ P}[L(f_θ(X), Y)] haben, d. h. auf neuen Daten aus derselben Verteilung gut funktionieren (Generalisierung). R kennen wir nicht, deshalb wird es durch den mittleren Verlust auf einer zurückgehaltenen Testmenge geschätzt, die beim Lernen nicht verwendet wurde.

Klassifikation ist überwachtes Lernen, bei dem der Raum der Labels eine endliche Menge von Klassen 𝒴 = {1, …, K} ist, K ∈ ℕ, K ≥ 2. Das Modell gibt zur Eingabe x ∈ 𝒳 eine Schätzung der Verteilung über die Klassen zurück, d. h. Zahlen p_θ(k | x) ≥ 0 für k = 1, …, K mit ∑_k=1^K p_θ(k | x) = 1.

Ein üblicher Verlust ist die Kreuzentropie: Für x ∈ 𝒳 mit dem Label y ∈ 𝒴 ist

L = −∑_k=1^K [y = k] log p_θ(k | x) = −log p_θ(y | x),

wobei [y = k] genau dann 1 ist, wenn y = k, und sonst 0.

Logistische Regression für zwei Klassen 𝒴 = {0, 1}: Sei 𝒳 = ℝ^d, die Parameter seien w ∈ ℝ^d und b ∈ ℝ, und σ : ℝ → (0, 1) sei die logistische Funktion

σ(z) = 1/1 + e^−z.

Das Modell ist p(y = 1 | x) = σ(w^⊤x + b) und p(y = 0 | x) = 1 − σ(w^⊤x + b). Den Punkt x ordnet es genau dann der Klasse 1 zu, wenn σ(w^⊤x + b) ≥ 0,5, d. h. genau dann, wenn w^⊤x + b ≥ 0. Die Entscheidungsgrenze ist die Menge

{x ∈ ℝ^d : w^⊤x + b = 0}

— für w ≠ 0 eine Hyperebene, in der Ebene (d = 2) eine Gerade.

Die Ableitung der mittleren Kreuzentropie J nach den Gewichten fällt überraschend einfach aus (dank σ′ = σ(1 − σ) kürzt sich einiges):

∂J/∂w = 1/n ∑_i=1ⁿ (p_i − y_i) x_i,   ∂J/∂b = 1/n ∑_i=1ⁿ (p_i − y_i),

wobei p_i = σ(w^⊤x_i + b).

w, b ← Startwerte
wiederhole E Epochen:                 # Epoche = ein Durchlauf durch alle Daten
    g_w, g_b ← 0, 0
    für jedes Beispiel (x, y):
        p ← σ(w·x + b)                # geschätzte Wahrscheinlichkeit der Klasse 1
        g_w ← g_w + (p − y)·x         # Schätzfehler mal Eingabe
        g_b ← g_b + (p − y)
    w ← w − η·g_w / n                 # Schritt gegen den Gradienten
    b ← b − η·g_b / n
Klasse(x) = 1, falls σ(w·x + b) ≥ 0,5, sonst 0

Die Genauigkeit (accuracy) ist der Anteil richtig eingeordneter Beispiele: |{i ∈ {1, …, n} : Klasse(x_i) = y_i}|/n.

Start: w = (0,4; 1,2), b = −0,9, Lernrate η = 2,5. Der erste Punkt hat die Koordinaten (0,604; 0,673) und die Klasse 0:

z = 0,4 · 0,604 + 1,2 · 0,673 − 0,9 = 0,148,   p = σ(0,148) = 1/1 + e^−0,148 = 0,537.

Das Modell schreibt dem Punkt der Klasse 0 also die Klasse 1 mit der Wahrscheinlichkeit 0,537 zu — ein Fehler. Der Verlust (y = 0, also bleibt von der Formel der Kreuzentropie oben nur der zweite Summand) ist −ln(1 − 0,537) = 0,770 (Farben wie in der Formel oben), und der Beitrag zum Gradienten (p − y) x = 0,537 · (0,604; 0,673) zieht beide Gewichte nach unten.

Auf allen Daten: Genauigkeit am Start 15 %, nach 5 Epochen 95 %, ab der 16. Epoche 100 %. Die mittlere Kreuzentropie (natürlicher Logarithmus) sinkt von 0,780 auf 0,175 nach 60 Epochen; auch wenn schon alle Punkte richtig sind, vergrößert das Modell die Gewichte weiter, um sich sicherer zu sein.

Regression ist überwachtes Lernen, bei dem die Labels reelle Zahlen sind: 𝒴 = ℝ. Seien (x_i, y_i) ∈ 𝒳 × ℝ, i = 1, …, n, die Trainingspaare und f : 𝒳 → ℝ ein Modell. Ein üblicher Verlust ist der mittlere quadratische Fehler

MSE(f) = 1/n ∑_i=1ⁿ (f(x_i) − y_i)².

Lineare Regression mit einer Eingabe: Sei 𝒳 = ℝ, n ≥ 2, und x₁, …, x_n seien nicht alle gleich. Das Modell ist f(x) = ax + b mit den Parametern a, b ∈ ℝ. Bezeichne die Mittelwerte x̄ = 1/n ∑_i=1ⁿ x_i und ȳ = 1/n ∑_i=1ⁿ y_i. Dann hat der MSE ein einziges Minimum (Methode der kleinsten Quadrate) im Punkt

a = ∑_i=1ⁿ (x_i − x̄)(y_i − ȳ)/∑_i=1ⁿ (x_i − x̄)²,   b = ȳ − ax̄.

(Die Annahme, dass die x_i nicht alle gleich sind, garantiert einen von null verschiedenen Nenner.)

MSE(a, b) ist eine quadratische Funktion von zwei Variablen, also liegt das Minimum dort, wo beide partiellen Ableitungen null sind:

∂/∂b: 2/n ∑ (ax_i + b − y_i) = 0  ⇒  b = ȳ − ax̄ (die Gerade geht durch den Schwerpunkt der Daten),

∂/∂a: 2/n ∑ (ax_i + b − y_i) x_i = 0; nach Einsetzen von b ergibt sich die Formel für a aus der Definition oben.

Für die 24 Wohnungen im Diagramm: a = 0,797, b = 0,083, MSE = 0,0046, also eine typische senkrechte Abweichung (die gestrichelten Strecken) √MSE ≈ 0,068. Die Daten haben wir als y = 0,12 + 0,72 x + Rauschen mit der Standardabweichung 0,06 erzeugt — die Methode hat aus 24 Punkten die tatsächliche Steigung und das Rauschen ungefähr getroffen, nicht genau.

Sei 𝒳 der Eingaberaum, P_X eine unbekannte Verteilung auf 𝒳 und D = (x_i)_i=1ⁿ, x_i ∈ 𝒳, unabhängig voneinander aus P_X gezogene Eingaben — ohne Labels. Unüberwachtes Lernen sucht aus D die Struktur der Verteilung P_X. Typische Aufgaben:

1. Clustering — eine Zerlegung der Indizes {1, …, n} in k nichtleere, paarweise disjunkte Mengen C₁, …, C_k (Cluster), sodass sich die Punkte in einem Cluster ähnlich sind;
2. Dimensionsreduktion — für 𝒳 = ℝ^d eine Abbildung g : ℝ^d → ℝ^m, m < d, die möglichst viel Information über die Daten erhält;
3. Dichteschätzung — eine Funktion p̂ : 𝒳 → [0, ∞), die die Dichte p(x) der Verteilung P_X approximiert.

Was genau „ähnlich“ oder „möglichst viel Information“ heißt, legt erst die konkrete Methode durch ihre Zielfunktion fest — wie k-Means unten.

Seien x₁, …, x_n ∈ ℝ^d Punkte, k ∈ ℕ, 1 ≤ k ≤ n, und ‖·‖ die euklidische Norm. Für eine Zerlegung der Punkte in k paarweise disjunkte Cluster C₁, …, C_k (jeder Punkt gehört zu genau einem) und Zentren μ₁, …, μ_k ∈ ℝ^d ist die Quadratsumme innerhalb der Cluster

J(C₁, …, C_k, μ₁, …, μ_k) = ∑_j=1^k ∑_{x ∈ Cj} ‖x − μ_j‖².

Die Aufgabe k-Means besteht darin, Cluster und Zentren zu finden, für die J minimal ist.

Lloyd-Algorithmus (Näherungslösung). Eingabe: Punkte x₁, …, x_n ∈ ℝ^d, die Anzahl der Cluster k und Startzentren μ₁, …, μ_k ∈ ℝ^d. Ausgabe: Cluster C₁, …, C_k und Zentren μ₁, …, μ_k. Wiederhole:

1. Zuordnung: Ordne jeden Punkt x_i dem Cluster C_j mit j ∈ argmin_{j′ ∈ {1, …, k}} ‖x_i − μ_j′‖² zu (nächstes Zentrum);
2. Verschieben der Zentren: Setze für jedes j = 1, …, k mit C_j ≠ ∅ μ_j = 1/|C_j| ∑_{x ∈ Cj} x (Mittelwert der Punkte des Clusters).

Abbruch: wenn sich in Schritt 2 kein Zentrum ändert. Kein Schritt erhöht J, und es gibt nur endlich viele mögliche Zerlegungen, also terminiert der Algorithmus — im Allgemeinen aber nur in einem lokalen Minimum von J.

μ₁, …, μ_k ← Startzentren
wiederhole:
    für jeden Punkt x:                   # Schritt 1: Zuordnung
        c(x) ← argmin_j ‖x − μ_j‖²
    für jedes j = 1, …, k:               # Schritt 2: Verschieben der Zentren
        μ_j ← Mittelwert der Punkte mit c(x) = j
solange sich die Zentren bewegen

Warum J nicht wächst. Schritt 1 ändert nur die Zuordnung, und jeder Punkt wechselt zu einem näheren Zentrum, also wächst sein Summand ‖x − μ_j‖² nicht. Schritt 2 ändert nur die Zentren, und der Mittelwert ist der Punkt, der die Summe der quadrierten Abstände zu einer Gruppe von Punkten minimiert (die Ableitung von ∑ ‖x − μ‖² nach μ ist −2 ∑ (x − μ), null genau für den Mittelwert). Es gibt nur endlich viele mögliche Zuordnungen, also terminiert der Algorithmus.

In unserem Diagramm (66 Punkte) hat J in den einzelnen Iterationen die Werte 19,330 → 2,937 → 1,048 → 0,655 — den größten Teil der Arbeit erledigt gleich das erste Verschieben der Zentren vom schlechten Start weg.

Sei 𝒳 der Eingaberaum, 𝒴 der Raum der Labels, P eine unbekannte Verteilung auf 𝒳 × 𝒴 und l, u ∈ ℕ, l ≥ 1. Gegeben sind

1. eine kleine gelabelte Menge D_L = ((x_i, y_i))_i=1^l, (x_i, y_i) ∈ 𝒳 × 𝒴, unabhängig aus P gezogen;
2. eine große ungelabelte Menge D_U = (x_j)_j=l+1^l+u, x_j ∈ 𝒳, unabhängig aus der Verteilung der Eingaben X allein gezogen (die Labels y_j existieren, aber wir kennen sie nicht), wobei u ≫ l.

Halbüberwachtes Lernen hat dasselbe Ziel wie überwachtes Lernen — ein Modell f_θ : 𝒳 → 𝒴 mit kleinem tatsächlichem Risiko —, nutzt aber, um es zu erreichen, D_L und D_U.

Ungelabelte Daten können nur dann helfen, wenn die Verteilung der Eingaben etwas über die Labels aussagt. Verwendet werden diese Annahmen (jede Methode beruht auf mindestens einer davon):

1. Glattheit — liegen zwei Eingaben x, x′ ∈ 𝒳 in einem Bereich mit vielen Daten nahe beieinander, haben sie (mit großer Wahrscheinlichkeit) dasselbe Label;
2. Cluster — Eingaben aus einem Cluster haben (mit großer Wahrscheinlichkeit) dasselbe Label, die Klassengrenze verläuft also durch Bereiche mit geringer Datendichte;
3. Mannigfaltigkeit — die Daten in 𝒳 = ℝ^d liegen nahe einer Fläche (Mannigfaltigkeit) der Dimension m < d, und der Abstand der Punkte ist entlang dieser Fläche zu messen, nicht auf gerader Linie in ℝ^d.

Eingabe: Punkte x₁, …, x_N ∈ ℝ^d, von denen einige ein Label aus 𝒴 = {0, 1} haben, und eine Anzahl von Nachbarn k ∈ ℕ (hier k = 4). Ausgabe: ein Label für jeden Punkt, der von gelabelten Punkten aus entlang der Kanten des Graphen erreichbar ist.

1. Konstruiere einen ungerichteten Graphen: Verbinde die Punkte x_i und x_j (i ≠ j) genau dann mit einer Kante, wenn x_j zu den k nächsten Nachbarn von x_i gehört oder x_i zu den k nächsten Nachbarn von x_j (nach euklidischem Abstand).
2. Gehe in einer Runde alle ungelabelten Punkte durch; jeder, der mindestens einen gelabelten Nachbarn hat, bekommt das Label, das die Mehrheit seiner gelabelten Nachbarn hat (bei Stimmengleichheit das Label 0). In einer Runde vergebene Labels gelten erst ab der nächsten Runde.
3. Abbruch: Wiederhole Schritt 2, solange es ungelabelte Punkte gibt und in der letzten Runde mindestens ein Label hinzugekommen ist.

Seien D = (x_i)_i=1ⁿ, x_i ∈ 𝒳, ungelabelte Daten und sei g eine fest gewählte (gegebenenfalls zufällige) Regel, die aus jeder Eingabe x ∈ 𝒳 automatisch, ohne menschliche Arbeit, ein Paar

g(x) = (x̃, t)

erzeugt, wobei x̃ ein Teil oder eine beschädigte Version der Eingabe x ist und t das, was in x̃ fehlt. Selbstüberwachtes Lernen ist überwachtes Lernen auf der Trainingsmenge (g(x_i))_i=1ⁿ: Das Modell bekommt x̃ und soll t vorhersagen. Diese künstlich erzeugte Aufgabe heißt Hilfsaufgabe (pretext task).

Vorhersage des nächsten Tokens — so werden große Sprachmodelle vortrainiert. Sei V ein endliches Vokabular von Tokens und ein Text eine Folge x₁, …, x_T ∈ V, T ≥ 1. Das Modell gibt für jedes t = 1, …, T eine Verteilung p_θ(· | x₁, …, x_t−1) auf V zurück (für t = 1 ohne Bedingung), und die Parameter θ werden so gewählt, dass

∑_t=1^T log p_θ(x_t | x₁, …, x_t−1)

möglichst groß ist. Hier ist x̃ = (x₁, …, x_t−1) und das t-te Token das Label.

Ein Markov-Entscheidungsprozess (die Umgebung) ist ein Fünftupel (S, A, P, R, γ), wobei

1. S eine nichtleere Menge von Zuständen ist (bei uns endlich — die Felder des Gitters);
2. A eine nichtleere endliche Menge von Aktionen ist;
3. P die Übergangswahrscheinlichkeit ist: Für jedes s ∈ S und a ∈ A ist P(· | s, a) eine Wahrscheinlichkeitsverteilung auf S, d. h. P(s′ | s, a) ≥ 0 und ∑_{s′ ∈ S} P(s′ | s, a) = 1 (P(s′ | s, a) ist die Wahrscheinlichkeit, dass die Aktion a im Zustand s in den Zustand s′ führt);
4. R : S × A × S → ℝ die Belohnung für den Übergang von s mit der Aktion a nach s′ ist;
5. γ ∈ [0, 1) der Diskontfaktor ist.

Die Strategie (Policy) des Agenten ist eine Regel π, die jedem Zustand s ∈ S eine Verteilung π(· | s) auf A zuordnet. Der Agent beginnt im Zustand s₀ und wählt für t = 0, 1, 2, … eine Aktion a_t gemäß π(· | s_t), die Umgebung wählt den nächsten Zustand s_t+1 gemäß P(· | s_t, a_t), und der Agent bekommt die Belohnung r_t = R(s_t, a_t, s_t+1). Der Return ist

G = ∑_t=0^∞ γ^t r_t

(in einem Endzustand endet die Episode, und alle weiteren Belohnungen sind 0), und das Ziel ist, eine Strategie zu finden, die seinen Erwartungswert E[G] maximiert.

Der Wert einer Aktion Q(s, a) ist der erwartete Return, wenn der Agent im Zustand s die Aktion a ausführt und danach bestmöglich spielt. Q-Learning schätzt ihn mit einer Tabelle Q : S × A → ℝ (anfangs z. B. lauter Nullen): Nach jedem Schritt (s, a, r, s′) führt es mit der Lernrate α ∈ (0, 1]

Q(s, a) ← Q(s, a) + α [r + γ max_{a′ ∈ A} Q(s′, a′) − Q(s, a)]

aus, wobei für einen Endzustand s′ max_a′ Q(s′, a′) = 0 gesetzt wird.

Sei A eine endliche nichtleere Menge von Aktionen, Q : S × A → ℝ eine Tabelle der Aktionswerte und ε ∈ [0, 1]. Für einen Zustand s ∈ S wählen wir a*(s) ∈ argmax_{a ∈ A} Q(s, a) (bei Gleichstand eine beliebige der besten). Die ε-gierige Strategie wählt im Zustand s die Aktion a ∈ A mit der Wahrscheinlichkeit

π(a | s) = ε/|A| + (1 − ε) · [a = a*(s)],

wobei [a = a*(s)] genau dann 1 ist, wenn a = a*(s), sonst 0. Mit anderen Worten: Mit der Wahrscheinlichkeit ε wählt sie eine zufällige Aktion (gleichverteilt aus allen), sonst die Aktion mit dem größten Q(s, a). Bei uns ist ε = 0,2.

Der erste Schritt. Am Anfang ist die ganze Tabelle Q null. Der Agent macht einen Schritt auf ein gewöhnliches Feld: r = −1 und max_a′ Q(s′, a′) = 0, also

Q(s, a) ← 0 + 0,5 · [−1 + 0,95 · 0 − 0] = −0,5

(Farben wie in der Formel des Q-Learnings oben). Ein Schritt ins Ziel ist ein Endschritt, also ist der Term max_a′ Q(s′, a′) gleich 0: Q ← 0 + 0,5 · [10 − 0] = 5. Bei weiteren Besuchen rückt die Fünf in Richtung 10 und breitet sich entlang des Weges weiter zurück aus, jeweils mit 0,95 multipliziert und um die Kosten eines Schritts verringert.

Der Wert des Starts. Der kürzeste Weg hat 10 Schritte: neun gewöhnliche zu −1 und den letzten ins Ziel zu +10. Der nicht diskontierte Return ist 9 · (−1) + 10 = 1, der diskontierte

G = −(1 + 0,95 + … + 0,95⁸) + 0,95⁹ · 10 = −1 − 0,95⁹/1 − 0,95 + 10 · 0,95⁹ = −7,395 + 6,302 = −1,093.

Die gelernte Tabelle hat am Start max_a Q(Start, a) = −1,093 — Q-Learning hat diesen Wert des optimalen Weges genau gefunden.

Seien J_Quelle, J_Ziel : ℝ^p → ℝ die Zielfunktionen einer Quellaufgabe (meist mit vielen Daten) und einer Zielaufgabe (meist mit wenigen Daten) für ein Modell mit denselben Parametern θ ∈ ℝ^p, und seien θ₀ die auf der Quellaufgabe gelernten Parameter, d. h. (näherungsweise) θ₀ ∈ argmin_θ J_Quelle(θ). Transferlernen sucht

θ* ∈ argmin_θ J_Ziel(θ)

mit dem Gradientenverfahren, das in θ₀ beginnt (statt bei zufälligen Werten). Beim Feintuning (fine-tuning) ändern sich oft nur die Parameter mit Indizes aus einer kleinen Menge I ⊂ {1, …, p}; die übrigen bleiben gleich den Werten in θ₀.

Sei D_L eine gelabelte und D_U eine ungelabelte Menge (wie beim halbüberwachten Lernen), 𝒴 = {1, …, K} und p_θ(· | x) ein auf D_L trainiertes Modell. Aktives Lernen wiederholt diese Schritte:

1. das Modell wählt selbst eine Eingabe x* ∈ D_U, bei der es am unsichersten ist — zum Beispiel mit der höchsten Entropie: x* ∈ argmax_{x ∈ DU} H(p_θ(· | x));
2. ein Mensch (der Lehrer) ergänzt das Label y*; das Paar (x*, y*) wandert von D_U nach D_L;
3. das Modell wird auf D_L neu trainiert;

bis das Budget für das Labeln aufgebraucht ist.

Sei p eine Verteilung auf {1, …, K}, d. h. p(k) ≥ 0 und ∑_k=1^K p(k) = 1. Ihre Entropie (in Bit) ist

H(p) = −∑_k=1^K p(k) log₂ p(k),   wobei 0 · log₂ 0 = 0 gesetzt wird.

Für zwei Klassen: Die Schätzung 50 : 50 hat H = −2 · 0,5 · log₂ 0,5 = 1 Bit (das größtmögliche), die Schätzung 90 : 10 H = −0,9 log₂ 0,9 − 0,1 log₂ 0,1 ≈ 0,137 + 0,332 = 0,469 Bit, die Schätzung 99 : 1 nur 0,081 Bit. Zum Labeln geht als Erstes das Beispiel, bei dem das Modell 50 : 50 schwankt.

Sei 𝒳 der Eingaberaum und 𝒴 der Raum der Labels.

1. Ein diskriminatives Modell lernt direkt die bedingte Verteilung p_θ(y | x) für x ∈ 𝒳, y ∈ 𝒴, oder gleich eine Entscheidungsfunktion f_θ : 𝒳 → 𝒴 (und damit eine Entscheidungsgrenze). Darüber, wie die Eingaben x selbst verteilt sind, sagt es nichts.
2. Ein generatives Modell lernt die Verteilung der Daten p_θ(x) auf 𝒳 bzw. die gemeinsame Verteilung p_θ(x, y) auf 𝒳 × 𝒴 und kann daraus neue Daten ziehen. Aus der gemeinsamen Verteilung lässt sich auch die bedingte berechnen (für endliches 𝒴): p_θ(y | x) = p_θ(x, y)/∑_{y′ ∈ 𝒴} p_θ(x, y′).