Boosting

Gegeben ist ein Merkmalsraum ${\displaystyle M}$ beliebiger Dimension und darin eine Trainingsstichprobe ${\displaystyle T}$ der Größe ${\displaystyle n}$, also eine Menge von Mustervektoren ${\displaystyle x_{1},\dots ,x_{n}}$. Von jedem dieser Mustervektoren ist bekannt, in welche Klasse er gehört, das heißt zu jedem ${\displaystyle x_{i}}$ ist ein ${\displaystyle y_{i}\in {+1,-1}}$ gegeben, das angibt, in welche der beiden Klassen +1 oder −1 der Mustervektor gehört. Ferner sind ${\displaystyle m}$ primitive Klassifikatoren ${\displaystyle f_{1},f_{2},\dots ,f_{m}:M\rightarrow {+1,-1}}$ gegeben, die jeweils den Merkmalsraum in die beiden Klassen ${\displaystyle +1}$ und ${\displaystyle -1}$ aufspalten.

Gesucht sind die m Gewichtungsfaktoren ${\displaystyle w_{1},\dots ,w_{m}}$ des Klassifikators ${\displaystyle F:M\rightarrow {+1,-1}}$, der über die Vorzeichenfunktion ${\displaystyle \operatorname {sgn} }$ durch

${\displaystyle F(x):=\operatorname {sgn} \left(\sum _{i=1}^{m}w_{i}f_{i}(x)\right)}$

gegeben ist. Die Gewichtungsfaktoren sollen so optimiert werden, dass ${\displaystyle F}$ möglichst wenige Fehler macht.

Für die Optimierung bietet sich eine über die Exponentialfunktion ${\displaystyle \mathrm {e} }$ definierte, sogenannte „exponentielle Verlustfunktion“ L als Optimierungskriterium an:

${\displaystyle L:={\frac {1}{n}}\sum _{i=1}^{n}\mathrm {e} ^{-y_{i}F(x_{i})}\rightarrow {\text{min}}}$

${\displaystyle L}$ wird umso kleiner, je weniger Objekte ${\displaystyle F}$ falsch klassifiziert. Das Ziel ist also, die Gewichtungsfaktoren so zu wählen, dass ${\displaystyle L}$ minimal wird.

Diese Optimierung wird schrittweise über ${\displaystyle m}$ ausgeführt, das heißt zunächst wird nur ${\displaystyle w_{1}}$ optimiert, dann ${\displaystyle w_{2}}$, dann ${\displaystyle w_{3}}$ und so weiter, bis alle Gewichtungsfaktoren optimal sind. Die Optimierung wird im nächsten Abschnitt erläutert.

Die schrittweise Optimierung benötigt m Durchläufe, um alle Gewichtungsfaktoren für F zu optimieren. In jedem Durchlauf wird ein Klassifikator F_s erzeugt, indem zum bisher erzeugten Klassifikator F_s−1 ein schwacher Klassifikator hinzugenommen wird. Das bedeutet, dass der Benutzer die Berechnung nach jedem Durchlauf abbrechen kann, falls das Zwischenergebnis bereits seinen Ansprüchen genügt.

Vor jedem Durchlauf wird beurteilt, welche Mustervektoren mit dem bislang erstellten Klassifikator gut eingeordnet werden können und welche nicht. Diejenigen Mustervektoren, die noch nicht gut klassifiziert werden, werden im nächsten Durchlauf besonders stark berücksichtigt. Dazu werden in jedem Durchlauf s n Hilfsvariablen t_s,1, …, t_s,n benötigt. Je höher der Wert von t_s,i, desto stärker geht der Mustervektor x_i in den aktuellen Durchgang ein.

Die Nummer des Durchgangs ist s:

1. Gewichte aktualisieren.

Im ersten Durchlauf (s = 1) werden alle Hilfsvariablen auf den Wert 1/n gesetzt: t_1,1, …, t_1,n:= 1/n; somit werden im ersten Durchgang alle Mustervektoren gleich stark berücksichtigt. In allen folgenden Durchläufen (s > 1) werden die Hilfsvariablen wie folgt gesetzt:

${\displaystyle t_{s,i}:=t_{s-1,i}\mathrm {e} ^{-y_{i}w_{s-1}f_{s-1}(x_{i})}}$

Damit werden alle Mustervektoren, die vom eben betrachteten schwachen Klassifikator f_s−1 falsch klassifiziert wurden, in diesem Durchlauf mit einem besonders hohen Hilfsgewicht versehen, alle anderen mit einem besonders geringen.

2. Gewichteten Trainingsfehler bestimmen.

In diesem Durchgang wird der schwache Klassifikator f_s hinzugenommen. Der „gewichtete Trainingsfehler“ ist ein Maß dafür, wie schlecht dieser primitive Klassifikator für sich genommen abschneidet. Für jeden von f_s falsch klassierten Mustervektor x_i summiert er die zugehörige Hilfsvariable t_s,i auf:

${\displaystyle err_{s}:=\sum _{i:f_{s}(x_{i})\neq y_{i}}t_{s,i}}$

Ist der gewichtete Trainingsfehler 0, so klassifiziert f_s alle Mustervektoren richtig, ist er 1, so klassifiziert f_s alles falsch. Ist err_s = 1/2, so klassifiziert f_s genauso gut, als würde er bei jedem Mustervektor bloß raten oder eine Münze werfen.

3. Nächsten Gewichtungsfaktor optimieren.

Der Gewichtungsfaktor w_s des in diesem Durchgang hinzugenommenen primitiven Klassifikators f_s wird aus der folgenden Formel bestimmt:

${\displaystyle w_{s}={\frac {1}{2}}\log \left({\frac {1-err_{s}}{err_{s}}}\right)}$

Nach der Formel wird f_s genau dann mit positivem Gewicht zum Endergebnis hinzugenommen, wenn err_s < ½ gilt, das heißt der schwache Klassifikator besser ist als bloßes Raten. Gilt exakt err_s = ½, so folgt w_s = 0, das heißt f_s wird ignoriert. Gilt hingegen err_s > ½, so ist der schwache Klassifikator durchaus brauchbar, er ist nur „falsch gepolt“, das heißt, er klassifiziert genau falsch herum; indem er mit einem negativen Gewicht hinzugenommen wird, kann dieser Formfehler ausgeglichen werden und der umgedrehte Klassifikator mit verstärkendem Effekt hinzugenommen werden.

4. Zwischenergebnis aufstellen.

Das Zwischenergebnis F_s ergibt sich aus der Formel:

${\displaystyle F_{s}(x):=\sum _{i=1}^{s}w_{i}f_{i}(x)}$

Es wird also genauso berechnet wie das eigentliche Ziel F, nur dass statt aller m schwachen Klassifikatoren nur die ersten s bereits optimierten berücksichtigt werden.

Diese Schritte werden in dieser Reihenfolge wiederholt, bis alle schwachen Klassifikatoren berücksichtigt wurden, also s = m ist, oder der Benutzer den Fortgang abbricht.

Typische schwache Klassifikatoren sind sogenannte decision stumps (engl. „Entscheidungsstümpfe“). Diese Funktionen vergleichen den Wert einer einzelnen Koordinate j mit einem Schwellwert l und begründen damit ihre Entscheidung für +1 oder −1. Ist x:= (x₁, …, x_d) ∈ M ein Mustervektor im d-dimensionalen Merkmalsraum M, so hat ein solcher primitiver Klassifikator f im Allgemeinen die Form:

${\displaystyle f(x)=f((x_{1},x_{2},\dots ,x_{d})):={\begin{cases}+1&{\text{falls }}x_{j}\geqslant l\\-1&{\text{falls }}x_{j}<l\end{cases}}}$

Genauer gesagt unterteilt f den Merkmalsraum mit einer Hyperebene in zwei Klassen.

Der Name spielt auf die Analogie zu Entscheidungsbäumen an: Der erzeugte Gesamtklassifikator F kann als Entscheidungsbaum angesehen werden. Jeder schwache Klassifikator ist ein innerer Knoten dieses Baumes, an dem ein Unterbaum (vgl. engl. stump, „(Baum)Stumpf“) hängt. Die endgültige Klassifizierung in einem der Blätter des Baums wird als Folge binärer Entscheidungen (engl. decision) erreicht.

Solche decision stumps sind als Grundlage für Boosting sehr beliebt, denn sie sind einfach zu handhaben und können extrem schnell ausgewertet werden. Zudem müssen sie nicht von Anfang an vorgegeben sein, sondern können erstellt werden, während der Algorithmus läuft.