WEBVTT

00:06.530 --> 00:12.530
Wir waren letztes Mal stehen geblieben mitten in der Normalverteilung.

00:14.450 --> 00:21.590
Als wichtiges Werkzeug für die stochastische Modellierung, wenn wir

00:21.590 --> 00:26.390
ein parametrisches Lernverfahren anwenden wollen, sind Gauss

00:26.390 --> 00:30.230
-Verteilungen sehr beliebt, weil sich viele Prozesse in der Natur

00:30.230 --> 00:31.490
annähernd Gauss verteilen.

00:31.490 --> 00:35.050
Und Gauss-Verteilung bestimmt durch ihren Mittelwert sowie die

00:35.050 --> 00:36.170
Kovarianz.

00:38.250 --> 00:40.490
Und die Formeln kennt wahrscheinlich auch jeder.

00:40.690 --> 00:43.370
Den Mittelwert kann man, wenn man Trainingsdaten hat, die

00:43.370 --> 00:49.110
repräsentativ sind für diese Wahrscheinlichkeitsverteilung, kann man

00:49.110 --> 00:52.750
messen als arithmetisches oder schätzen als arithmetisches Mittel der

00:52.750 --> 00:53.950
Trainingsdaten.

00:53.950 --> 00:58.410
Und die Kovarianzmatrix eben als das arithmetische Mittel des

00:58.410 --> 01:03.390
Quadrates der Abweichung der einzelnen Trainingsdaten vom Mittelwert.

01:03.710 --> 01:07.790
Jeweils erstes und zweites... Moment.

01:08.710 --> 01:12.050
Jetzt schon mal als Vorgriff auf eine der noch folgenden Vorlesungen,

01:12.110 --> 01:13.190
wo wir das genauer machen werden.

01:13.310 --> 01:14.030
Aber einfach mal so.

01:14.690 --> 01:16.410
Weiß jemand, warum man das so schätzen darf?

01:19.110 --> 01:23.290
Die Formeln kennt jeder, wie man jetzt Mittelwert schätzt und wie man

01:23.290 --> 01:25.890
eine Kovarianz schätzt, wenn ich so Trainingsdaten gegeben habe.

01:26.510 --> 01:27.790
Aber warum darf ich das so machen?

01:29.650 --> 01:33.590
Wieso ist es legitim zu sagen, naja, ich habe da eine Zufallsvariable,

01:33.710 --> 01:36.230
die spuckt da halt Zeug raus und jetzt will ich die

01:36.230 --> 01:40.970
Wahrscheinlichkeitsdichte -Funktion schätzen, die dieser

01:40.970 --> 01:45.190
Zufallsvariable zugrunde liegt und ich weiß oder ich nehme an, dass

01:45.190 --> 01:48.810
das ganze Gauss verteilt ist und dann sage ich, naja, der Mittelwert

01:48.810 --> 01:51.010
ist das und die Kovarianz ist das.

01:51.110 --> 01:52.150
Warum darf ich das so machen?

02:14.390 --> 02:14.670
Genau.

02:15.770 --> 02:18.050
Das heißt also, was heißt erwartungstreu?

02:26.120 --> 02:26.400
Okay.

02:27.060 --> 02:27.960
Das ist eine Möglichkeit.

02:28.160 --> 02:29.200
Und was macht man bei der Varianz?

02:29.280 --> 02:31.600
Warum kann man sagen, bei der Varianz kann man das so machen?

02:31.680 --> 02:34.600
Jetzt kann man sagen, der ist variantstreu, der Schätzer.

02:42.010 --> 02:42.410
Okay.

02:42.830 --> 02:45.990
Aber warum kann man wirklich zeigen, dass das, wenn ich das x gegen

02:45.990 --> 02:48.290
unendlich gehen lasse, dass da wirklich dann der richtige Mittelwert

02:48.290 --> 02:48.750
rauskommt?

02:53.440 --> 02:53.780
Ja.

02:53.960 --> 02:56.260
Und wenn ich das jetzt, das Trainingsdaten gegen unendlich gehen

02:56.260 --> 02:56.580
lasse?

03:01.660 --> 03:02.220
Weiß ich nicht.

03:02.400 --> 03:05.520
Kann es nicht, also zumindest für jede endliche Menge von n ist das ja

03:05.520 --> 03:06.520
nun erstmal nicht der Fall.

03:07.100 --> 03:11.280
Weil bei einer Zufallsvariable, da weiß man nie, was bei rauskommt.

03:28.480 --> 03:33.260
Aber angenommen, ich habe eine Gauss-Verteilung, die hat einen

03:33.260 --> 03:36.620
Mittelwert von 0,5 und eine Varianz von 2.

03:37.580 --> 03:39.840
Und jetzt lasse ich Trainingsdaten generieren von dieser

03:39.840 --> 03:40.160
Zufallsvariable.

03:41.240 --> 03:45.300
Und es kommt immer raus 1, 1, 1, 1, 1, 1, 1, 1, 1 und es geht die

03:45.300 --> 03:46.120
ganze Zeit so weiter.

03:47.940 --> 03:51.360
Ist das eine mögliche Folge, die rauskommen kann?

03:52.440 --> 03:54.080
Ja, sie ist halt nur sehr unwahrscheinlich.

03:56.340 --> 03:58.840
Das heißt, wenn ich mir das anschaue, und das ist schon der Trick,

03:58.900 --> 04:01.420
würde ich sagen, dass das jetzt der Mittelwert davon ist.

04:01.760 --> 04:02.580
Das ist eher unwahrscheinlich.

04:04.180 --> 04:06.620
Und dass das die Varianz ist, ist eher unwahrscheinlich.

04:19.620 --> 04:21.020
Oder jetzt mal andersrum gedacht.

04:21.160 --> 04:23.780
Also es geht mir nicht darum, dass die Wahrscheinlichkeit gegen 0

04:23.780 --> 04:27.060
geht, wenn ich da halt den Falschen nehme, sondern wie wähle ich die

04:27.060 --> 04:29.260
andersrum, wie wähle ich denn die?

04:45.120 --> 04:46.900
Okay, also das ist ein Maximum-Likelihood-Schätzer.

04:46.960 --> 04:48.980
Das ist schon mal der richtige Griff.

04:49.460 --> 04:51.200
Aber welche Likelihood wird denn da maximiert?

04:53.940 --> 04:56.700
Du sagst jetzt, da wird die Likelihood maximiert, dass das wirklich

04:56.700 --> 04:58.300
der Mittelwert der Verteilung ist.

04:59.520 --> 05:00.900
Das ist eigentlich umgekehrt.

05:07.490 --> 05:09.830
Und was passiert dann, wenn ich die Wahrscheinlichkeit nehme?

05:10.950 --> 05:13.250
Das ist eigentlich bei allen Maximum-Likelihood-Verfahren dann

05:13.250 --> 05:15.050
passiert, jetzt bezogen auf die Trainingsdaten.

05:16.990 --> 05:22.470
Was ich damit maximiere ist, wenn ich den Mittelwert und die Varianz

05:22.470 --> 05:28.570
so nehme, dann maximiere ich die Wahrscheinlichkeit, mit der diese

05:28.570 --> 05:31.390
geschätzte Wahrscheinlichkeitsdichte-Funktion die Trainingsdaten

05:31.390 --> 05:32.150
produziert hat.

05:33.090 --> 05:37.030
Wenn ich also ausrechne, wie hoch ist die Wahrscheinlichkeit, dass

05:37.030 --> 05:40.230
diese Trainingsdaten produziert wurden von dieser Gauss-Mixtur

05:40.230 --> 05:44.710
-Verteilung, dann ist das, was dabei rauskommt, maximal genau an den

05:44.710 --> 05:45.570
beiden Punkten.

05:45.630 --> 05:47.990
Das sind die beiden Variablen, die ich variieren kann.

05:48.570 --> 05:51.550
Also in anderen Worten, angenommen, ich habe 100 Trainingsdaten, dann

05:51.550 --> 05:55.910
schätze ich meine Myo und meine Sigma und würde dann ausrechnen mit

05:55.910 --> 05:59.530
der Gauss-Verteilung Wahrscheinlichkeit von Trainingsdatum 1 unter

05:59.530 --> 06:03.750
dieser Gauss-Verteilung, mal Wahrscheinlichkeit Trainingsdatum 2, mal

06:03.750 --> 06:05.270
3, mal 4 und so weiter bis 100.

06:05.270 --> 06:09.190
Dann ist der Wert, der rauskommt, der höchstmögliche Wert für jede

06:09.190 --> 06:12.110
beliebige Gauss-Verteilung, die es da an der Stelle gibt.

06:12.370 --> 06:15.130
Dann ist das die Gauss-Verteilung, die diesen Wert maximiert.

06:15.490 --> 06:18.230
Deswegen nennt man das den Maximum-Likelihood-Schätzer, weil die

06:18.230 --> 06:22.470
Wahrscheinlichkeit, dass die Trainingsdaten von der so geschätzten

06:22.470 --> 06:25.150
Gauss -Verteilung produziert werden, maximiert wird.

06:37.540 --> 06:38.340
Nicht notwendigerweise.

06:47.050 --> 06:48.290
Ja, aber nicht notwendigerweise.

06:48.410 --> 06:50.510
Ich glaube nicht, dass die Varianz minimiert wird.

06:51.270 --> 06:54.410
Weil es ist ja kein diskriminatives Training in dem Sinne.

06:56.570 --> 06:59.650
Man guckt also nicht danach, wenn man jetzt damit klassifiziert, wie

06:59.650 --> 07:00.990
häufig liegt man richtig oder falsch.

07:05.580 --> 07:11.400
Sondern das Kriterium selber sorgt erstmal nur dafür, dass die

07:11.400 --> 07:14.940
Wahrscheinlichkeit, mit der die Daten produziert werden, maximal wird.

07:15.160 --> 07:20.600
Das ist die zugrunde liegende Zielrichtung des Maximum-Likelihood

07:20.600 --> 07:23.460
-Verfahrens, wenn man es als Trainingskriterium aufnimmt.

07:25.220 --> 07:28.240
Weil das ist ja letztendlich auch nichts anderes als ein Lernen,

07:28.360 --> 07:31.940
maschinelles Lernen, wenn ich den Mittelwert und die Varianz rechne.

07:32.060 --> 07:34.180
Das ist ein maschinelles Lernverfahren, das auf die Art und Weise zu

07:34.180 --> 07:34.440
rechnen.

07:35.280 --> 07:38.580
Und das Kriterium, nachdem ich halt meine Parameter hier, die beiden

07:38.580 --> 07:42.960
optimiere, ist eben, dass sie die Trainingsdaten mit höchster

07:42.960 --> 07:44.320
Wahrscheinlichkeit produzieren sollen.

07:44.540 --> 07:46.260
Und das nennt man das Maximum-Likelihood-Verfahren.

07:46.260 --> 07:50.800
Ob da jetzt wirklich die Varianz... Welche Varianz willst du denn da

07:50.800 --> 07:51.380
minimieren?

07:51.500 --> 07:54.740
Die Abweichung von...

07:59.380 --> 08:02.360
Ja, aber das Schlimme ist ja, den wahren Wert kennen wir ja nicht.

08:08.030 --> 08:10.990
Ja, aber da müsste ich sie nicht lernen.

08:12.350 --> 08:16.130
Bei der Sache ist es halt immer so, dass ich hier nicht weiß, was die

08:16.130 --> 08:19.430
wahre Verteilung ist, die der Sache zugrunde liegt.

08:19.710 --> 08:21.250
Ich kann nur meine Trainingsdaten beobachten.

08:23.970 --> 08:26.590
Und wenn das dann dabei herauskommt, weiß ich halt, dass meine

08:26.590 --> 08:29.770
Trainingsdaten, die Wahrscheinlichkeit, dass die produziert wurden,

08:29.810 --> 08:30.370
maximiert wurde.

08:30.710 --> 08:33.490
Nur wenn ich halt Pech habe, und es kann durchaus sein, dass ich Pech

08:33.490 --> 08:33.610
habe.

08:33.710 --> 08:36.490
Vielleicht sind ja bei den ersten 100 Zahlen, die ich halt bekomme,

08:36.730 --> 08:38.330
sind halt zufälligerweise alle eins.

08:38.870 --> 08:41.690
Und ab da passiert wieder was völlig anderes.

08:42.970 --> 08:45.710
Dann habe ich was gelernt, was halt auf die eigentliche wahre

08:45.710 --> 08:46.930
Verteilung gar nicht passt.

08:47.430 --> 08:51.070
Und das kann ja im Prinzip unendlich lange so passieren.

08:51.270 --> 08:53.630
Oder zumindest für jede endliche Folge kann das sein.

08:53.730 --> 08:58.530
Deswegen, wenn man da jetzt das N gegen unendlich gehen lässt, ist es,

08:58.730 --> 09:00.990
glaube ich, auch nicht notwendigerweise garantiert, dass man den

09:00.990 --> 09:03.930
korrekten Mittelwert rausbekommt.

09:05.450 --> 09:09.690
Weil es verbietet keiner, dass auch eine jede beliebige

09:09.690 --> 09:12.270
Wahrscheinlichkeitsdichte -Funktion, die da irgendwie parametrisiert

09:12.270 --> 09:15.990
ist, so langsam eine echte Gauss-Verteilung ist, immer eins ist eine

09:15.990 --> 09:18.430
völlig zulässige Beobachtung, die produziert wird.

09:18.850 --> 09:20.150
Das ist eine sehr, sehr, sehr unwahrscheinliche.

09:20.190 --> 09:22.370
Und die Wahrscheinlichkeit, dass das produziert wird, wird

09:22.370 --> 09:24.910
wahrscheinlich mit N gegen unendlich gegen 0 gehen.

09:25.070 --> 09:27.510
Aber es wird nie 0...

09:31.760 --> 09:32.940
wie wir halt nicht kennen.

09:42.080 --> 09:48.200
Das ist nicht schätztreu, aber es ist trotzdem so gewählt, dass es die

09:48.200 --> 09:50.860
Wahrscheinlichkeit, die Trainingsdaten zu produzieren, maximiert.

09:53.060 --> 09:55.820
Also das Maximum-Likelihood-Kriterium erfüllt es auf alle Fälle.

09:57.360 --> 10:00.880
Das ist genau das Sigma-Quadrat, wenn man es so ausrechnet, das dafür

10:00.880 --> 10:05.100
sorgt, dass hinterher eine Gauss-Funktion rauskommt, die

10:05.100 --> 10:07.700
Trainingsdaten mit höchster Wahrscheinlichkeit produziert.

10:13.590 --> 10:14.070
Gut.

10:14.690 --> 10:18.470
Das Ganze hatten wir uns dann halt auch angeschaut im multivariaten

10:18.470 --> 10:18.970
Fall.

10:19.670 --> 10:26.830
Sprich, statt einer eindimensionalen Wahrscheinlichkeitsvariable haben

10:26.830 --> 10:28.910
wir jetzt eine mehrdimensionale Variable.

10:29.910 --> 10:33.270
Bei uns typischerweise aus dem R auch N, also das, was hinterher

10:33.270 --> 10:36.850
rauspurzelt aus der Vorverarbeitung des Spracherkennungssystems.

10:38.370 --> 10:43.850
Und man sieht der Sache im eindimensionalen Fall sehr ähnlich, außer

10:43.850 --> 10:48.870
dass man hier oben natürlich jetzt Vektoren voneinander subtrahiert

10:48.870 --> 10:53.370
und anstelle der Kovarianz selber tritt die Kovarianz Matrix.

10:57.100 --> 11:00.440
Auch die Parameter können wieder geschätzt werden.

11:00.540 --> 11:03.920
Jetzt steht hier natürlich die falsche Formel.

11:04.780 --> 11:07.720
Achso, das ist natürlich die falsche Formel.

11:08.580 --> 11:09.660
Das muss ich noch korrigieren.

11:10.060 --> 11:14.240
Auch die Parameter kann man schätzen gemäß Maximum Likelihood.

11:14.360 --> 11:16.100
Für den Mittelwert ist es wieder genau das gleiche.

11:16.220 --> 11:22.140
Da kann man den Mittelwert entsprechend schätzen und bei der Kovarianz

11:22.140 --> 11:27.680
Matrix muss man nochmal was anderes machen.

11:27.680 --> 11:28.500
Das muss ich noch rausholen.

11:28.600 --> 11:36.200
Die Kovarianz Matrix da ist... äh... nee.

11:40.860 --> 11:42.960
Du musst ja da zu einer Matrixschätzung kommen.

11:43.060 --> 11:45.020
Das heißt, du brauchst eine Schätzung für die einzelnen Elemente

11:45.020 --> 11:46.120
deiner Matrix.

11:46.260 --> 11:49.880
Das kannst du nicht als Summe über Vektoren hinschreiben.

11:49.980 --> 11:52.340
Also die Formel da ist falsch.

11:52.340 --> 11:53.820
Beim Mittelwert kannst du das machen.

11:53.940 --> 11:56.580
Da kannst du einfach, wenn du dimensionsweise immer den Mittelwert

11:56.580 --> 11:58.520
bildest, kommst du beim richtigen Mittelwert raus.

11:58.620 --> 12:02.100
Bei der Kovarianz Matrix muss eine andere Formel hin, damit man die

12:02.100 --> 12:05.500
einzelnen Elemente der Matrix auch ausrechnet.

12:08.700 --> 12:12.160
Und dazu, zu dieser Kovarianz Matrix kann man ein paar Eigenschaften

12:12.160 --> 12:16.440
festhalten.

12:16.440 --> 12:23.700
Das erste ist, dass die Werte auf der Diagonalen immer größer gleich 0

12:23.700 --> 12:24.300
sein werden.

12:25.840 --> 12:28.940
Und wenn man eine echte Normalverteilung haben, werden diese Werte auf

12:28.940 --> 12:30.980
der Diagonalen sogar echt größer 0 sein.

12:31.680 --> 12:36.880
Was würde es denn bedeuten, hätte man auf der Diagonale eine 0 stehen?

12:38.100 --> 12:45.080
Das bedeutet, dass man in dieser Dimension, also der Ente-Index, auf

12:45.080 --> 12:47.220
der Diagonalen ist dann die Ente-Dimension.

12:47.620 --> 12:50.900
Das würde bedeuten, dass man da eine Varianz hätte, die 0 wäre.

12:52.360 --> 12:57.380
Sprich, die Gauss-Glocke würde an der Stelle sozusagen unendlich

12:57.380 --> 12:59.740
gehen, würde unendlich schmal und unendlich hoch.

13:01.180 --> 13:04.940
Und dann hätte man da in dem Fall gar keine Gauss-Verteilung, sondern

13:04.940 --> 13:06.840
man hätte einfach nur einen Mittelwert.

13:07.100 --> 13:10.580
Und die Werte würden immer genau aus diesem Mittelwert bestehen,

13:10.660 --> 13:13.560
würden in dieser Dimension um den Mittelwert herum variieren.

13:15.060 --> 13:18.960
Dann ist die Matrix symmetrisch und positiv semidefinit.

13:19.540 --> 13:22.540
Und wenn man die aufmalt, malt man die in der Regel immer als

13:22.540 --> 13:23.160
Ellipsoiden.

13:30.180 --> 13:34.060
Das heißt, wenn man jetzt so eine schematisch darstellt, eine Gauss

13:34.060 --> 13:36.380
-Mixtur -Verteilung und man das irgendwie im Zweidimensionalen

13:36.380 --> 13:37.080
darstellen will,

13:40.380 --> 13:46.020
dann kann man sich immer zwei Dimensionen hernehmen, den Mittelwert

13:46.020 --> 13:50.220
einzeichnen und dann würde man die Covarianzmatrix als einen

13:50.220 --> 13:53.720
Ellipsoiden darstellen.

13:53.720 --> 14:01.520
Wobei dieser Ellipsoide, das ist eine Linie von gleichem Wert.

14:02.400 --> 14:09.020
Also alle Werte, die aus der Gauss-Verteilung da rauskommen, haben den

14:09.020 --> 14:12.580
gleichen Wert und entsprechen halt genau in der Regel einmal

14:12.580 --> 14:13.420
Standardabweichung.

14:14.540 --> 14:19.980
Kann man natürlich definieren, wie man will, aber alle Punkte mit

14:19.980 --> 14:22.220
gleichen Werten, wenn man die halt entsprechend verbindet, bekommt man

14:22.220 --> 14:24.240
immer so einen Ellipsoiden bei raus.

14:26.900 --> 14:30.100
Jetzt ist es so, man kann sich das so vorstellen, dass man halt auf

14:30.100 --> 14:33.440
der Diagonalen im Großen und Ganzen die Varianz stehen hat.

14:33.440 --> 14:37.860
Und dann werden diese Varianzen in die verschiedenen Dimensionen

14:37.860 --> 14:44.600
hinaus gedreht durch die Werte außerhalb der Diagonalen.

14:46.060 --> 14:51.060
Also allgemein kann so ein Ellipsoid irgendwie schräg im Raum liegen.

14:52.500 --> 14:56.480
Außer wenn ich jetzt eine Matrix habe, wo alle Werte außerhalb der

14:56.480 --> 15:00.860
Diagonalen Null sind, dann ist es so, dass diese Hauptachsen des

15:00.860 --> 15:04.680
Ellipsoiden immer parallel sind zu den Achsen meines

15:04.680 --> 15:05.060
Koordinatensystems.

15:10.730 --> 15:12.430
Sieht dann so aus.

15:20.820 --> 15:28.640
So, jetzt habe ich eigentlich ein Applet, jetzt muss ich mal gucken.

15:32.400 --> 15:39.140
Also das ist so eine Gaussglocke mit Mittelwert XY, wie er hier steht,

15:39.220 --> 15:39.980
bei der Stelle 00.

15:39.980 --> 15:46.020
Ich habe in A und D eine Varianz von 1, B ist gleich 0, dann habe ich

15:46.020 --> 15:49.060
diesen schönen Ellipsoiden, der, wenn ich da jetzt einen Schnitt durch

15:49.060 --> 15:53.720
diesen Hügel durchliege, da wo alle Punkte einmal Standardabweichung

15:53.720 --> 15:58.560
hoch sind oder alle Punkte einmal Standardabweichung vom Mittelwert

15:58.560 --> 16:01.680
entfernt hoch sind, dann erhalte ich da sogar einen Kreis, da ich

16:01.680 --> 16:03.640
jetzt in beide Richtungen die gleiche Varianz habe.

16:04.220 --> 16:07.660
Wenn ich jetzt in eine Dimension die Varianz mal erhöhe,

16:12.680 --> 16:15.520
sieht man, ist das hier so ein bisschen breiter geworden.

16:15.920 --> 16:16.900
Machen wir es mal extrem.

16:20.700 --> 16:21.480
Passiert da was?

16:25.600 --> 16:27.660
Das meinte ich vorhin, ich habe gekämpft.

16:38.260 --> 16:40.080
Vorhin noch so schön funktioniert.

16:42.360 --> 16:44.680
Warum sehe ich das eigentlich nicht auf dem Monitor?

16:47.840 --> 16:51.820
So, wie wir sehen funktioniert das nicht.

16:57.750 --> 17:01.030
Blöd, da muss ich nochmal gucken, dass ich das zum Laufen bekomme.

17:01.610 --> 17:03.610
Irgendwie haben sich die Java-Versionen wieder geändert.

17:04.110 --> 17:06.270
Ich stelle das dann entsprechend in den Vorlesungs-Arbeitsbereich,

17:06.390 --> 17:08.090
wenn da einer mal ein bisschen mit rumspielen will.

17:08.090 --> 17:12.270
Was nämlich normalerweise jetzt sehen würde, wenn ich jetzt hier zum

17:12.270 --> 17:15.090
Beispiel ein kleines Drehkästchen einfüge,

17:21.980 --> 17:25.380
würde man sehen, wie sich die Gauss-Glocke, je nachdem wie das Begel

17:25.380 --> 17:30.400
eingestellt wird, um seine eigene Achse mit den Varianzen hinweg

17:30.400 --> 17:30.760
dreht.

17:31.080 --> 17:33.080
Nur damit man halt was sieht, braucht man in die eine Richtung eine

17:33.080 --> 17:35.980
andere Varianz als in die andere Richtung, dass das also so eine

17:35.980 --> 17:39.880
breite, dünne Gauss-Glocke wird und dann kann man die schön mit diesem

17:39.880 --> 17:44.040
B wie so ein Drehkästchen dann entsprechend drehen lassen.

17:47.720 --> 17:52.700
Jetzt ist es so, Gauss-Verteilungen sind zwar prinzipiell sehr schön,

17:52.860 --> 17:55.120
verhalten sich sehr gutmütig, haben schöne mathematische

17:55.120 --> 18:00.220
Eigenschaften, kann man gut mit arbeiten, man kann insbesondere die

18:00.220 --> 18:02.620
Parameter gut auf Trainingsdaten schätzen.

18:03.300 --> 18:06.780
Und es gibt auch viele natürliche Prozesse, zumindest einfache

18:06.780 --> 18:09.220
natürliche Prozesse, die annähernd Gauss-Verteilt sind.

18:10.020 --> 18:13.620
Unglücklicherweise ist menschliche Sprache und die Merkmalsvektoren,

18:13.680 --> 18:17.280
die so aus der Vorverarbeitung rauskommen, ein dieser vielen Prozesse,

18:17.380 --> 18:18.780
die leider nicht Gauss-Verteilt sind.

18:19.240 --> 18:21.340
Die entsprechen leider nicht dieser schönen Gauss-Verteilung.

18:23.500 --> 18:25.180
Jetzt kann man was dagegen machen.

18:25.620 --> 18:29.120
Und zwar möchte man nicht vollständig von diesen Gauss-Glocken

18:29.120 --> 18:29.540
abrücken.

18:30.380 --> 18:35.580
Und zum anderen ist es so, ich kenne keine bessere Verteilung als die

18:35.580 --> 18:38.300
Gauss -Verteilung, der jetzt menschliche Sprache besser entsprechen

18:38.300 --> 18:38.580
würde.

18:39.080 --> 18:44.200
Also es gibt jetzt nicht die Mathematiker-Willi-Müller-Dichtefunktion,

18:44.280 --> 18:47.560
von der man sagen kann, okay, da kann ich annehmen, dass menschliche

18:47.560 --> 18:49.840
Sprache, wie sie bei mir aus der Vorverarbeitung rauskommt,

18:49.940 --> 18:53.460
entsprechend dieser Wahrscheinlichkeitsdichtefunktion verteilt ist,

18:53.980 --> 18:56.540
sondern ich kenne einfach keine Wahrscheinlichkeitsdichtefunktion.

18:57.740 --> 19:01.540
Und da gibt es den Trick, dass man sich behelfen kann, indem man

19:01.540 --> 19:06.500
mehrere verschiedene Gauss-Glocken zusammenaddiert, gewichtet und

19:06.500 --> 19:07.220
zusammenaddiert.

19:07.800 --> 19:10.220
Das heißt, aus meiner einzelnen Gauss-Glocke ist jetzt entsprechend

19:10.220 --> 19:13.640
hier eine Summe geworden, von k Gauss-Glocken.

19:13.800 --> 19:17.160
Und jede Gauss-Glocke hat ihre eigene Kovarianz-Matrix und ihren

19:17.160 --> 19:17.960
eigenen Mittelwert.

19:18.640 --> 19:21.500
Und ich summiere dann die Werte, die jeweils aus der Gauss-Glocke

19:21.500 --> 19:25.920
herauskommen, mit gewichtet, mit so einem Gewichts-C auf.

19:28.400 --> 19:33.520
Worauf müssen sich die c summieren, wenn ich die cs aufsummiere?

19:34.240 --> 19:35.460
Genau, die müssen sich auf 1 summieren.

19:35.560 --> 19:36.900
Und warum müssen die sich auf 1 summieren?

19:57.200 --> 20:03.460
Also das Integral über x, über alle x, der muss nach wie vor 1

20:03.460 --> 20:06.720
ergeben, damit das Ganze eine Wahrscheinlichkeitsdichtefunktion ist.

20:07.180 --> 20:09.320
Und was wird auch sichergestellt, wenn sich die cs auf...

20:09.960 --> 20:11.560
Und was muss die cs noch haben?

20:11.640 --> 20:12.600
Die müssen sich auf 1 summieren.

20:12.740 --> 20:14.960
Und was dürfen die cs noch sein, aus welchem Wertebereich?

20:15.540 --> 20:19.400
Kann ich sagen, c1 ist gleich minus 10 und c2 ist gleich 1?

20:19.640 --> 20:21.060
Dann summieren sie sich auf 1 auf.

20:21.860 --> 20:22.920
Und warum darf ich das nicht?

20:24.160 --> 20:26.300
Also das Integral über das ganze Ding muss 1 sein.

20:26.380 --> 20:27.580
Und was muss noch garantiert sein?

20:29.980 --> 20:32.620
Genau, also die Werte, die aus der Dichtefunktion herauskommen, müssen

20:32.620 --> 20:33.580
zwischen 0 und 1 liegen.

20:34.820 --> 20:38.720
Und das muss halt, da das bei der Gaussverteilung einer einzelnen

20:38.720 --> 20:40.840
Gaussglocke der Fall ist, müssen dann halt, wenn ich jetzt mehrere

20:40.840 --> 20:43.580
zusammenaddiere, eben diese Gewichte auch zwischen 0 und 1 liegen.

20:43.920 --> 20:46.900
Und insgesamt darf ihre Summe auch nur 1 ergeben.

21:09.260 --> 21:12.540
Ja, kann man machen, bei einer Gaussglocke ist das sogar der Fall.

21:15.640 --> 21:17.500
Eine Gaussglocke nimmt nie den Wert 0 ein.

21:24.170 --> 21:25.350
Also größer gleich 0.

21:25.810 --> 21:26.650
0 darf auch sein.

21:27.610 --> 21:31.510
Also ci darf auch nicht kleiner als 0 sein, genau.

21:35.830 --> 21:38.430
Jetzt ist das Schöne, wie groß soll ich denn mein k wählen?

21:39.630 --> 21:41.630
Wie viele Gaussglocken will ich denn zusammenaddieren?

21:42.090 --> 21:43.090
Was wäre denn sinnvoll?

21:50.000 --> 21:52.440
Macht das einen Unterschied, ob ich 100 oder ob ich 1000 nehme?

21:56.640 --> 21:58.660
Ich will mal vermuten, ja, was macht das denn für einen Unterschied?

22:00.680 --> 22:01.040
Genau.

22:03.900 --> 22:06.440
Ja, aber prinzipiell wird es immer präziser.

22:06.860 --> 22:10.440
Und jetzt ist das Schöne, man kann sogar zeigen, dass es beliebig

22:10.440 --> 22:11.360
genau wird.

22:11.740 --> 22:15.440
Also angenommen, ich habe irgendeine, ich wüsste, es gibt da eine

22:15.440 --> 22:18.700
Dichteverteilung, Wahrscheinlichkeitsdichteverteilung, von der weiß

22:18.700 --> 22:19.680
ich genau, wie sie aussieht.

22:20.120 --> 22:22.720
Die ist nicht parametrisch oder so, ich weiß aus irgendeinem magischen

22:22.720 --> 22:25.040
Grund genau, an welcher Stelle sie welchen Wert annimmt.

22:25.040 --> 22:28.580
Und die will ich jetzt eben genau approximieren mit einer

22:28.580 --> 22:29.040
Gaussmixturverteilung.

22:29.700 --> 22:32.800
Mit einer Gaussmixturverteilung.

22:32.840 --> 22:37.560
Das heißt, ich will so ein GMM nehmen, das diese beliebig gewählte

22:37.560 --> 22:40.040
Wahrscheinlichkeitsdichteverteilung approximiert.

22:41.140 --> 22:43.400
Und dann kann ich zeigen, dass ich für jede beliebige

22:43.400 --> 22:47.420
Wahrscheinlichkeitsdichteverteilung ich diese beliebig genau

22:47.420 --> 22:54.380
approximieren kann, wenn ich nur hinreichend viele endliche Anzahl an

22:54.380 --> 22:55.040
Gaussglocken nehme.

22:55.660 --> 22:58.840
In anderen Worten, wenn ich mir also einen Fehler vorgebe, dann gibt

22:58.840 --> 23:01.980
es irgendeine endliche Zahl an Gaussglocken, die dafür sorgt, dass ich

23:01.980 --> 23:04.800
diesen Fehler habe oder sogar kleiner bin als dieser Fehler.

23:05.780 --> 23:09.380
Das heißt also, das ist prinzipiell ein sehr gutes Werkzeug, um

23:09.380 --> 23:13.820
beliebige Wahrscheinlichkeitsdichtefunktionen zu repräsentieren.

23:14.220 --> 23:17.020
Ich muss nur die Anzahl der Gaussglocken halt hoch genug wählen.

23:17.780 --> 23:20.720
Einziger Nachteil natürlich ist, je mehr Gaussglocken ich nehme, desto

23:20.720 --> 23:22.760
mehr Parameter habe ich hinterher, die ich schätzen muss.

23:23.380 --> 23:29.600
Wenn ich nicht genügend Trainingsdaten habe, dann kann ich unter

23:29.600 --> 23:32.720
Umständen nicht so viele Gaussglocken schätzen, wie ich vielleicht

23:32.720 --> 23:33.200
gerne hätte.

23:38.020 --> 23:38.800
Nächste Frage.

23:40.340 --> 23:41.580
Bei der Gaussglocke war es schön.

23:42.880 --> 23:45.660
Auch bei der multidimensionalen, da kann ich den Mittelwert schätzen,

23:45.760 --> 23:50.380
da kann ich die Go-Varianz-Matrix schätzen von so einer einzelnen

23:50.380 --> 23:51.240
Gaussglocke.

23:52.100 --> 23:53.780
So geht das auch hier bei der Gaussmixtur-Verteilung.

23:56.320 --> 23:59.400
Gibt es da eine einfache geschlossene Formel, mit der ich die

23:59.400 --> 24:04.640
Mittelwerte, die Go-Varianz-Matrixen schätzen kann, wenn ich

24:04.640 --> 24:05.720
Trainingsdaten gegeben habe?

24:07.900 --> 24:09.620
Hat da schon mal jemand eine Formel gesehen?

24:12.620 --> 24:14.740
Kann sich jemand so auf die schnellere Formel denken?

24:16.760 --> 24:19.840
Gut, wenn hier 20 Informatiker sitzen, die noch nie eine Formel

24:19.840 --> 24:23.060
gesehen haben, für so ein offensichtliches Problem, und sich auf die

24:23.060 --> 24:26.160
Schnelle auch keine denken können, dann liegt die Vermutung nahe, dass

24:26.160 --> 24:27.340
so eine Formel nicht existiert.

24:28.280 --> 24:30.900
Dass sich bisher noch niemand so eine Formel ausgedacht hat.

24:30.960 --> 24:32.500
Und das ist in der Tat auch der Fall.

24:33.040 --> 24:37.040
Bei so einer Gaussmixtur-Verteilung, wenn ich jetzt Trainingsdaten

24:37.040 --> 24:41.580
habe, kann ich aus den Trainingsdaten nicht sofort sagen, okay, das

24:41.580 --> 24:44.600
ist jetzt mein Mittelwert und das ist die Go-Varianz-Matrix für

24:44.600 --> 24:50.000
jeweils die einzelnen Gaussglocken, die dafür sorgt, dass meine

24:50.000 --> 24:52.340
Gaussmixtur -Verteilung diese Trainingsdaten mit höchster

24:52.340 --> 24:54.200
Wahrscheinlichkeit imitiert.

24:55.440 --> 24:58.300
Kann man sich vielleicht ungefähr vorstellen, wo da das Problem liegen

24:58.300 --> 24:58.580
könnte?

24:58.700 --> 25:00.080
Warum das nicht geht?

25:02.480 --> 25:04.500
Welche Information fehlt uns vielleicht?

25:05.640 --> 25:08.240
Angenommen, ich habe so jede Menge Trainingsdaten, ich weiß, welche

25:08.240 --> 25:12.460
Werte da rauskommen, oder ich weiß, dass diese Gaussmixtur diese

25:12.460 --> 25:17.000
Trainingsdaten so produziert hat, wo könnte da das Problem liegen,

25:17.100 --> 25:20.060
jetzt da Mittelwerte und Go-Varianz-Matrizen zu errechnen?

25:20.820 --> 25:24.220
Plus, es kommt ja noch ein zusätzlicher Satz an Parametern dazu, ich

25:24.220 --> 25:26.880
muss ja auch noch die Gewichte irgendwie schätzen können.

25:27.800 --> 25:29.000
Wo könnte da das Problem liegen?

25:29.080 --> 25:30.980
Wo ist da jetzt der Unterschied zur einzelnen Gaussglocke?

25:45.440 --> 25:45.820
Nee?

25:47.860 --> 25:50.640
Ja klar, ich will ja nicht irgendeine, also eine beliebige

25:50.640 --> 25:52.580
Wahrscheinlichkeitsdichte -Funktion gibt es immer, aber ich will die

25:52.580 --> 25:55.960
Wahrscheinlichkeitsdichte -Funktion finden, die mir die Trainingsdaten

25:55.960 --> 25:58.280
mit höchster Wahrscheinlichkeit produziert hat.

25:58.800 --> 26:03.180
Und ich will die Gaussmixtur-Verteilung finden, die mir jetzt die

26:03.180 --> 26:05.900
Trainingsdaten mit höchster Wahrscheinlichkeit produziert hat.

26:06.980 --> 26:12.360
Aber wo ist das fehlende Glied zwischen den Trainingsdaten und den Go

26:12.360 --> 26:14.280
-Varianz -Matrizen und Mittelwerten?

26:15.420 --> 26:16.520
Was passt da nicht zusammen?

26:18.540 --> 26:21.020
Naja, da passt nicht zusammen, auf der einen Seite habe ich jeweils

26:21.020 --> 26:25.400
hier so ein Trainingsdatum, und hier habe ich ganz viele Gaussglocken

26:25.400 --> 26:25.660
stehen.

26:27.520 --> 26:30.280
Und welche Gaussglocke hatte denn jetzt welchen Anteil an der

26:30.280 --> 26:33.400
Produktion dieses Trainingsdatums?

26:34.180 --> 26:37.400
Bei einer einzelnen Gaussglocke weiß ich immer, nicht nur die habe,

26:37.780 --> 26:40.360
das hat das Ding produziert, da nehme ich ganz viele davon, Mittelwert

26:40.360 --> 26:42.640
und Go-Varianz-Matrix ausgerechnet, wunderbar.

26:43.400 --> 26:48.280
Hier habe ich jetzt das Problem, dass ich da viele verschiedene

26:48.280 --> 26:51.560
Gaussglocken habe, K-Gaussglocken, die jetzt irgendeinen mir nicht

26:51.560 --> 26:55.000
bekannten Anteil daran hatten, dieses Ding zu imitieren.

26:57.180 --> 27:00.200
Angenommen, da wäre irgendein magischer Mechanismus, der mir sagen

27:00.200 --> 27:03.980
würde, für mein fünftes Trainingsdatum, das ich gesehen habe, mein

27:03.980 --> 27:06.700
fünftes Trainingsbeispiel, das ist von der dritten Gaussglocke

27:06.700 --> 27:07.540
produziert worden.

27:08.280 --> 27:12.940
Und ich wüsste für jedes Trainingsbeispiel, welche Gaussglocke dieses

27:12.940 --> 27:16.540
Trainingsbeispiel produziert hat, könnte ich dann was machen?

27:22.170 --> 27:23.070
Klar, was ich will?

27:23.610 --> 27:26.210
Also ich habe meine Trainingsdaten und für jedes Trainingsdatum weiß

27:26.210 --> 27:30.310
ich, welche Gaussglocke in dieser Gaussmixturverteilung dieses

27:30.310 --> 27:31.490
Trainingsdatum produziert hat.

27:32.390 --> 27:34.050
Könnte ich dann was machen für die Schätzung?

27:36.130 --> 27:39.850
Ja, dann könnte ich einfach mir meine Trainingsdaten partitionieren.

27:40.010 --> 27:45.210
Ich weiß einfach jeder Gaussglocke ihr zugehörigen Trainingsdaten zu,

27:45.290 --> 27:47.330
kann dann für jede Gaussglocke wieder Mittelwert ausrechnen,

27:47.330 --> 27:48.310
Kovarianz, Matrix.

27:49.230 --> 27:50.190
Und was mache ich mit den Gewichten?

28:05.550 --> 28:07.310
Ja, oder ich mache nochmal was viel Einfacheres.

28:08.190 --> 28:10.830
Ich gucke mir einfach an, die Aufteilung der Trainingsdaten in die

28:10.830 --> 28:11.530
einzelnen Gaussglocke.

28:11.870 --> 28:14.850
Also welche Gaussglocke hat wie viel Prozent der Trainingsdaten

28:14.850 --> 28:17.290
produziert und das ist dann das Gewicht.

28:19.110 --> 28:20.590
Und das funktioniert dann am Ende auch.

28:24.070 --> 28:27.830
Also das wäre dann, wenn ich das wüsste, dummerweise weiß ich das

28:27.830 --> 28:28.050
nicht.

28:28.590 --> 28:32.890
Und das ist etwas, was die Schätzung da jetzt sehr schwierig macht.

28:32.970 --> 28:35.130
Es gibt dann keine geschlossene Formel, sondern ich habe hier

28:35.130 --> 28:37.130
plötzlich noch einen zweiten Wahrscheinlichkeitsprozess.

28:38.590 --> 28:39.950
Mache da so eine Modellannahme.

28:40.070 --> 28:43.450
Erstmal, dass überhaupt ein Datum nur von einer Gaussglocke produziert

28:43.450 --> 28:43.670
wurde.

28:43.750 --> 28:45.290
Das ist ja erstmal nur eine gedankliche Krücke.

28:45.950 --> 28:48.030
Gibt ja jetzt nicht irgendwas, wo man sagen könnte, ja offensichtlich

28:48.030 --> 28:50.310
ist das so, sondern ich stelle mir da einfach sowas vor.

28:50.930 --> 28:56.490
Und dann basierend darauf muss ich mir dann was zurechtzimmern.

28:56.930 --> 28:59.050
Aber diese Zuordnung, wie gesagt, die kenne ich nicht, die ist in den

28:59.050 --> 29:01.210
Trainingsdaten nicht annotiert, die muss ich auch noch irgendwo

29:01.210 --> 29:01.650
herkriegen.

29:01.710 --> 29:04.270
Das ist dann letztendlich auch eine Zufallsgröße, mit der ich

29:04.270 --> 29:04.810
hantieren muss.

29:06.250 --> 29:09.530
Und weil das halt nicht funktioniert so auf die Schnelle, werden wir

29:09.530 --> 29:12.570
später eine komplett eigene Vorlesung haben zu einem Verfahren, das

29:12.570 --> 29:14.450
sich Expectation Maximization nennt.

29:15.290 --> 29:18.510
Das so vorgeht, dass es halt sagt, ja da gibt es anscheinend eine

29:18.510 --> 29:22.330
zweite Zufallsgröße, die kann ich nicht mal beobachten und muss dann

29:22.330 --> 29:25.770
entsprechend da nochmal zusätzlich mit Wahrscheinlichkeiten rechnen.

29:26.170 --> 29:29.070
Und dann gibt es halt keine geschlossene Formel mehr, das mir die

29:29.070 --> 29:32.470
Parameter rausspuckt, sondern dann gibt es nur noch ein iteratives

29:32.470 --> 29:37.470
Verfahren, das ich beliebig häufig durchlaufen kann, um gegen eine

29:37.470 --> 29:40.210
mögliche Lösung zu konvergieren.

29:40.830 --> 29:43.910
Und das machen wir dann später einmal für Gauss-Mixtur-Verteilung und

29:43.910 --> 29:46.670
das machen wir später auch dann, wenn wir mit den sogenannten Hidden

29:46.670 --> 29:47.730
Markov -Modellen arbeiten.

29:47.990 --> 29:49.490
Da haben wir nämlich genau das gleiche Problem.

29:49.630 --> 29:52.310
Da müssen wir auch Parameter schätzen und da gibt es bestimmte

29:52.310 --> 29:56.650
Informationen, die wir haben müssen, die wir aber nicht kennen, die

29:56.650 --> 29:58.070
wir als Zufallsgröße benutzen müssen.

30:00.010 --> 30:04.530
Jetzt macht man in der Praxis noch ein, zwei kleinere Tricks, um mit

30:04.530 --> 30:07.430
Gauss -Glocken und Gauss-Mixtur-Verteilung besser arbeiten zu können.

30:07.770 --> 30:10.290
Wir haben einmal das Problem, je mehr Gauss-Glocken ich hineinfüttere,

30:10.370 --> 30:11.490
desto mehr Parameter habe ich.

30:12.150 --> 30:15.350
Wenn ich jetzt die Parameter sparen möchte, aber trotzdem viele Gauss

30:15.350 --> 30:20.310
-Glocken haben will und um Rechenzeit zu sparen, ist einer der Tricks,

30:20.690 --> 30:23.410
dass ich nur mit diagonalen Kovarianz-Matrizen arbeite.

30:24.510 --> 30:27.690
Warum spart mir das denn Rechenzeit, wenn ich nur diagonale Kovarianz

30:27.690 --> 30:28.390
-Matrizen habe?

30:29.630 --> 30:30.850
Warum ist das schneller?

30:33.070 --> 30:34.170
Wo spare ich da Rechenzeit?

30:37.380 --> 30:40.060
Und ich sage, okay, ich nehme Kovarianz-Matrizen, die auch nur auf der

30:40.060 --> 30:42.500
Diagonale Elemente haben, manchmal abseits der Diagonalen.

30:43.220 --> 30:45.660
Warum wird das Ausrechnen dieses Dings dann schneller?

30:52.810 --> 30:54.670
Ich muss ja irgendwas da oben sparen.

30:56.770 --> 30:59.150
Und was wird da aus meiner schönen Matrix-Multiplikation?

31:07.450 --> 31:09.130
Die sind dekorreliert, ja?

31:18.670 --> 31:22.070
Aber jetzt auch noch ganz, ganz profan gesprochen.

31:22.610 --> 31:28.210
Wenn ich mir sowas hier angucke, Vektor mal Matrix mal Vektor.

31:29.650 --> 31:32.490
Und jetzt habe ich hier eine Matrix, auf der nur noch Null-Elemente

31:32.490 --> 31:32.710
stehen.

31:37.180 --> 31:41.320
Auf der Diagonalen sind die einzigen Werte, die nicht Null sind.

31:41.420 --> 31:43.600
Neben der Diagonalen sind nur noch Null.

31:44.420 --> 31:45.960
Was passiert da rein rechnerisch?

31:46.980 --> 31:50.060
Ich meine, das ist ja immer eine Summe, so Vektor mal Matrix.

31:53.320 --> 31:53.600
Genau.

31:55.420 --> 31:57.980
Na gut, hängt davon ab, wie viel dimensional das ist.

31:58.540 --> 31:59.620
Hängt davon ab von der Dimensionalität.

31:59.760 --> 32:02.620
Aber anstatt, dass ich jetzt die komplette Matrix mit den vielen

32:02.620 --> 32:06.600
Multiplikationen und Aufsummieren komplett durchrechnen muss, werden

32:06.600 --> 32:11.820
die meisten Summanden in dieser langen Summe aus der Vektormalspalte

32:11.820 --> 32:12.640
werden Null.

32:13.120 --> 32:17.160
Und ich muss nur noch jeweils die Werte auf der Diagonalen

32:17.160 --> 32:21.540
multiplizieren mit diesem x-µi und dann aufaddieren.

32:22.260 --> 32:23.100
Fertig ist die Sache.

32:23.760 --> 32:24.160
Karstgebissen.

32:24.720 --> 32:26.760
Und dann halt noch quadrieren, weil ich mache es ja auch nochmal mit

32:26.760 --> 32:29.640
der transponierten Funktion.

32:29.760 --> 32:31.820
Aber da spare ich mir dann jede Menge Rechenzeit.

32:32.400 --> 32:34.420
Plus, ich spare mir natürlich jede Menge Parameter.

32:35.060 --> 32:40.860
Statt hier n mal n halbe Parameter zu haben, habe ich dann nur noch n

32:40.860 --> 32:42.840
Parameter.

32:45.580 --> 32:47.080
Das ist der eine Trick.

32:47.940 --> 32:48.920
Und dann der andere Trick.

32:49.440 --> 32:50.560
Jetzt denken wir mal an den Rechner.

32:51.820 --> 32:54.620
Angenommen, ich will jetzt nur mal so eine Gauss-Glocke ausrechnen.

32:54.820 --> 32:58.120
Also hier oben, da muss ich immer multiplizieren und addieren, um

32:58.120 --> 33:02.340
diese Mahanalobes-Distanz hier oben in dem Exponenten ausrechnen zu

33:02.340 --> 33:02.560
können.

33:03.640 --> 33:07.180
Aber was ist so richtig teuer und fies an dieser Form, wenn ich die

33:07.180 --> 33:08.780
auf dem Prozessor ausrechnen möchte?

33:09.700 --> 33:10.880
Was ist daran so richtig blöd?

33:14.320 --> 33:16.320
Ja, wobei, was mache ich da?

33:17.960 --> 33:21.960
Ich meine, ich habe die Parameter irgendwo im Rechner gespeichert und

33:21.960 --> 33:26.360
will jetzt das Ding ausrechnen und bekomme da immer wieder

33:27.540 --> 33:29.500
Merkmalsvektoren x rein und will einfach den Wert der

33:29.500 --> 33:31.680
Wahrscheinlichkeitsfunktion an der Stelle x ausrechnen.

33:32.220 --> 33:34.000
Gehe ich da jedes Mal hin und invertiere die Matrix?

33:36.120 --> 33:37.160
Ne, die invertiere ich einmal.

33:37.280 --> 33:38.980
Ich speichere mir gleich die invertierte Matrix ab.

33:39.040 --> 33:39.860
Der Rest ist völlig egal.

33:40.560 --> 33:41.740
Aber was speichere ich mir noch ab?

33:42.400 --> 33:44.280
Ich speichere mir natürlich auch die Determinante ab.

33:44.360 --> 33:46.900
Also ich gehe nicht jedes Mal hin und rechne jedes Mal die Inverse aus

33:46.900 --> 33:47.720
und dann die Determinante.

33:47.780 --> 33:50.400
Das kann ich mir vorher einmal ausrechnen und abspeichern.

33:50.460 --> 33:51.620
Das hängt ja nicht ab von dem x.

33:52.660 --> 33:56.660
Aber was ist so aus numerischer Sicht, wenn man numerische Mathematik

33:56.660 --> 33:59.500
denkt und ausrechnet, was ist da so richtig fies an der Formel?

33:59.740 --> 34:01.060
Was kostet so richtig Rechenzeit?

34:01.980 --> 34:02.800
Genau, die E-Funktion.

34:03.480 --> 34:06.760
Die E-Funktion auszurechnen, das muss ich irgendwie numerisch machen.

34:06.900 --> 34:13.860
Das muss ich irgendwie als Summe hinschreiben, die ich nach einer

34:13.860 --> 34:15.020
gewissen Länge ausrechnen muss.

34:15.380 --> 34:16.920
Das auszurechnen ist so richtig fies.

34:17.620 --> 34:20.700
Wenn ich das loswerden könnte, wäre doch super.

34:25.240 --> 34:29.300
Für eine einzelne Gauss-Verteilung geht das relativ einfach.

34:29.620 --> 34:34.260
Oder auch für eine Multivariate-Gauss-Verteilung geht das relativ

34:34.260 --> 34:34.600
einfach.

34:36.680 --> 34:40.520
Ehe kann ich da relativ weit einfach loswerden, wenn ich sage, mir

34:40.520 --> 34:42.560
kommt es ja nicht auf die eigentliche Wahrscheinlichkeit an.

34:43.220 --> 34:46.360
Ich meine, ich ziehe ja keine Freude daraus, dass ich jetzt weiß, die

34:46.360 --> 34:49.340
Wahrscheinlichkeitsdichte -Funktion an dieser Stelle hat jetzt diesen

34:49.340 --> 34:49.600
Wert.

34:50.420 --> 34:52.000
Sondern was will ich in Wirklichkeit hinterher machen?

34:52.200 --> 34:54.360
Wo setze ich sowas ein?

34:59.690 --> 35:02.190
Gut, wenn ich für den Datensatz will ich die Dichte maximieren oder

35:02.190 --> 35:03.230
hinterher, was mache ich denn?

35:03.350 --> 35:05.410
Was betreibe ich bei der Spracherkennung oder bei den ganzen

35:05.410 --> 35:07.050
Lernverfahren, die wir da kennengelernt haben?

35:08.030 --> 35:08.530
Was machen die?

35:11.930 --> 35:13.250
Genau, wir klassifizieren.

35:13.350 --> 35:17.630
Wir interessieren uns dafür, welche Klasse, die jetzt durch so eine

35:17.630 --> 35:19.950
Gauss -Glocke repräsentiert wird, welche ist es, die mit der höchsten

35:19.950 --> 35:20.590
Wahrscheinlichkeit?

35:21.190 --> 35:23.570
Mich interessiert nicht genau, welche Wahrscheinlichkeit das ist,

35:23.650 --> 35:26.070
sondern mich interessiert nur davon, zu wissen, dass es die höchste

35:26.070 --> 35:26.290
ist.

35:27.270 --> 35:30.010
Das heißt, ich kann mit dieser Funktion relativ viel machen.

35:30.710 --> 35:33.890
Ich kann jede streng monotone Funktion auf so ein Ding anwenden.

35:34.790 --> 35:37.650
Und wenn ich da eine streng monotone Funktion drauf anwende und dann

35:37.650 --> 35:40.690
das Ergebnis ausrechne und dann das Maximum suche, dann weiß ich immer

35:40.690 --> 35:43.270
noch, welche Gauss-Glocke das Maximum hatte.

35:44.070 --> 35:48.310
Und was ist eine ganz einfache, jederzeit allen bekannten monotone

35:48.310 --> 35:51.010
Operation, Funktion, wenn ich die auf das Ding anwende?

35:51.330 --> 35:53.870
Dann wäre ich die E-Funktion los.

35:54.690 --> 35:56.850
Dann kann man einfach den Logarithmus Naturalis auf das Ding rechnen.

35:57.910 --> 36:00.610
Wenn ich da jetzt nochmal einen Logarithmus Naturalis drauf rechne,

36:01.810 --> 36:05.870
dann wird hier raus plötzlich eine Summe und der Logarithmus Naturalis

36:05.870 --> 36:10.290
einer festen Größe, die nicht von x abhängt, kann ich also einmal

36:10.290 --> 36:12.470
vorher ausrechnen und gut ist.

36:13.030 --> 36:17.830
Und dann hier bleibt nur noch übrig die meiner Logis-Distanz, aber die

36:17.830 --> 36:18.630
E -Funktion ist weg.

36:19.730 --> 36:22.750
Und dann redet man in der Regel nicht mehr von Wahrscheinlichkeiten,

36:22.890 --> 36:24.430
sondern sowas nennt man dann einen Score.

36:26.610 --> 36:30.350
Gibt mir nur noch an, ob wie gut oder schlecht das jetzt ist.

36:30.490 --> 36:32.670
Aber ich weiß halt erstmal nicht direkt die aktuelle

36:32.670 --> 36:34.350
Wahrscheinlichkeit.

36:38.380 --> 36:42.360
Tja, also für eine Gauss-Glocke ganz einfach, Logarithmus drauf und E

36:42.360 --> 36:43.780
-Funktion ist verschwunden.

36:44.780 --> 36:46.220
Geht das auch bei Gauss-Mischverteilung?

36:48.700 --> 36:50.980
Kann ich da auch einfach Logarithmus drauf und ich bin glücklich?

37:00.670 --> 37:02.870
Logarithmus drauf rechnen und alles ist gut?

37:06.530 --> 37:08.710
Was passiert, wenn ich da einen Logarithmus drauf anwende?

37:09.770 --> 37:10.630
Wo knallt es?

37:12.710 --> 37:13.830
Wo laufe ich in Schwierigkeiten?

37:15.150 --> 37:19.310
Ich meine klar, Logarithmus von dem Produkt, das ist Logarithmus davon

37:19.310 --> 37:20.550
plus Logarithmus davon.

37:22.170 --> 37:24.510
Aber ich muss ja den Logarithmus da vorne draufhängen.

37:24.890 --> 37:25.590
Und was steht dann da?

37:25.790 --> 37:27.110
Logarithmus von der Summe.

37:27.930 --> 37:30.710
Also Taschenbuch der Mathematik rausholen und was steht da drin, was

37:30.710 --> 37:31.870
der Logarithmus einer Summe ist?

37:38.200 --> 37:41.360
Einmal Taschenbuch Mathematik von vorne nach hinten durchblättern und

37:41.360 --> 37:45.800
man wird finden, dass da dummerweise nichts drinsteht.

37:46.580 --> 37:50.120
Bei Logarithmus einer Summe gibt es eigentlich so eine schöne

37:50.120 --> 37:54.940
Umformung oder einfache Rechenregel für.

37:55.540 --> 38:01.000
Das heißt, bei Gauss-Mischverteilung geht diese schöne Idee, dass man

38:01.000 --> 38:05.900
den Logarithmus verwendet, kaputt.

38:07.180 --> 38:08.120
Funktioniert leider nicht so.

38:09.300 --> 38:10.160
Tja, blöd.

38:10.660 --> 38:12.480
Man hätte mal so schön Rechenzeit sparen können.

38:12.560 --> 38:15.080
Jetzt muss ich wieder die ganze Zeit diese blöden E-Funktionen

38:15.080 --> 38:15.600
ausrechnen.

38:16.620 --> 38:18.460
Und da ist jetzt halt die Frage, ihr könnt jetzt schon mal im

38:18.460 --> 38:20.840
Hintergrund ein bisschen anfangen zu überlegen.

38:21.520 --> 38:22.600
Da will man natürlich was dran ändern.

38:22.760 --> 38:23.500
Das will man nicht so hinlegen.

38:23.600 --> 38:26.740
Da will man irgendwas machen, dass man da auch bei Gauss

38:26.740 --> 38:29.260
-Mischverteilung schön mit Logarithmus irgendwie rechnen kann.

38:29.580 --> 38:30.680
Im logarithmischen Bereich.

38:33.360 --> 38:38.260
Und da muss man sich was ein bisschen überlegen.

38:39.440 --> 38:42.240
Und bevor wir dazu kommen, bevor ihr euch das überlegt, erzähle ich

38:42.240 --> 38:46.140
euch vorher noch was anderes, was damit relativ verwandt ist und was

38:46.140 --> 38:48.820
früher erstmal entwickelt wurde und verwendet wurde.

38:49.540 --> 38:52.520
Aber wenn man da geschafft hinguckt und ein bisschen so im Hinterkopf

38:52.520 --> 38:55.580
behält, ich will ja auch irgendwie den Logarithmus in solche Gauss

38:55.580 --> 38:58.660
-Mischverteilungen reinfummeln, um möglichst schneller zu rechnen,

38:58.660 --> 39:00.660
vielleicht kann ich mir da ja was abgucken.

39:01.520 --> 39:03.920
Vielleicht kann man sich da was hernehmen, was einem hinterher hilft.

39:06.620 --> 39:11.740
Vorher noch ganz schnell, der Logarithmus hat noch einen anderen

39:11.740 --> 39:12.600
Vorteil.

39:13.020 --> 39:16.800
Außer dass jetzt das Rechnen im Rechner schneller geht, sondern im

39:16.800 --> 39:18.440
Rechner passiert noch was anderes Schönes.

39:19.420 --> 39:21.800
Ich hatte ja vorhin schon gesagt, man will zum Beispiel die

39:21.800 --> 39:26.500
Wahrscheinlichkeit maximieren, dass so eine Gauss-Glocke

39:29.240 --> 39:30.240
Trainingsdaten produziert hat.

39:30.720 --> 39:33.740
Und genauso will man hinterher die Wahrscheinlichkeit ausrechnen, dass

39:33.740 --> 39:36.500
zum Beispiel irgendwelche Gauss-Glocken so eine Folge von

39:39.680 --> 39:42.360
Referenzvektoren, Merkmalsvektoren produziert hat, die zum Beispiel

39:42.360 --> 39:43.740
bei der Sprache aufgenommen wurden.

39:44.520 --> 39:45.340
Was muss ich denn machen?

39:45.460 --> 39:48.020
Angenommen, ich habe da jetzt 1000 so Merkmalsvektoren, ich habe eine

39:48.020 --> 39:50.020
Gauss -Glocke und ich will wissen, mit welcher Wahrscheinlichkeit hat

39:50.020 --> 39:53.500
die Gauss-Glocke diese Trainingsdaten produziert.

39:54.920 --> 39:55.880
Was mache ich?

39:56.900 --> 40:01.860
Ersten Vektor nehmen, in die Gauss-Glocke rein, Wert raus, mal zweiten

40:01.860 --> 40:04.980
Vektor nehmen, in die Gauss-Glocke rein, Wert raus, die beiden Werte

40:04.980 --> 40:09.120
aufmultiplizieren, dritten Wert her, wieder kommt ein Wert raus aus

40:09.120 --> 40:11.580
der Gauss-Glocke, wird wieder aufmultipliziert und das Ganze mache ich

40:11.580 --> 40:12.100
1000 Mal.

40:13.940 --> 40:16.080
Wenn ich das jetzt im Rechner mache und sagen wir mal, ich habe sowas

40:16.080 --> 40:19.260
wie 10.000 Vektoren, was passiert da Blödes?

40:20.500 --> 40:22.620
Wo werde ich da ganz schnell in Schwierigkeiten laufen?

40:22.720 --> 40:26.460
Einfach rein numerisch, wenn man sowas im Rechner ausrechnet.

40:26.940 --> 40:28.000
Das muss man sich immer überlegen.

40:28.060 --> 40:30.340
Das eine ist, was wir an Formeln hinschreiben, das andere ist, was wir

40:30.340 --> 40:31.780
eigentlich im Rechner überhaupt rechnen können.

40:36.580 --> 40:38.060
Ja, dann wird es verdammt klein.

40:38.620 --> 40:41.140
Und noch schlimmer, die Wahrscheinlichkeiten liegen meistens sogar

40:41.140 --> 40:43.940
eher näher bei 0, als dass sie bei 1 liegen bei meinen Gauss-Glocken,

40:44.040 --> 40:47.200
weil die meistens schon eine relativ hohe Varianz haben.

40:47.760 --> 40:49.740
Das heißt also, es wird ganz schnell ganz, ganz, ganz klein.

40:50.360 --> 40:51.660
Und warum ist das beim Logarithmus besser?

40:58.160 --> 40:59.820
Muss ich dann immer auch nochmal aufmultiplizieren.

41:04.940 --> 41:08.300
Genau, dann addiere ich Logarithmus auf ein Produkt von ganz vielen

41:08.300 --> 41:09.380
Werten an oder wird daraus eine Summe.

41:09.840 --> 41:12.700
Und dann addiere ich Werte, die in einem halbwegs vernünftigen Bereich

41:12.700 --> 41:12.940
liegen.

41:13.620 --> 41:16.240
Und dann komme ich einfach numerisch im Rechner viel besser damit

41:16.240 --> 41:16.780
klar.

41:20.200 --> 41:25.940
Dieses exponentielle Abfallen immer kleiner werden dieser Werte beim

41:25.940 --> 41:28.640
Aufmultiplizieren wird sozusagen durch den Logarithmus auch schön

41:28.640 --> 41:30.900
geglättet dann entsprechend.

41:34.220 --> 41:39.060
Gut, also bevor wir uns jetzt überlegen, was können wir denn jetzt

41:39.060 --> 41:41.480
machen mit dem Logarithmus-Trick und den Gauss-Mixtur-Verteilungen,

41:42.420 --> 41:44.880
kommen wir zu etwas, das nennt sich Vektorquantisierung.

41:47.880 --> 41:50.940
Bisher haben wir das Problem, wir haben ja immer Merkmale, die aus der

41:50.940 --> 41:52.060
Vorverarbeitung rauskommen.

41:52.220 --> 41:53.620
Das sind Vektoren aus dem R auch N.

41:56.540 --> 41:58.620
Und davon gibt es unendlich viele.

41:58.780 --> 42:02.180
Also ich habe eine unendlich große Menge von möglichen

42:02.180 --> 42:04.180
Merkmalsvektoren, mit denen ich hinterher arbeiten muss.

42:07.040 --> 42:10.800
Was ich jetzt machen möchte ist, dass ich von dieser unendlichen

42:10.800 --> 42:14.460
Mengen an Merkmalsvektoren wegkommen will und eigentlich nur noch eine

42:14.460 --> 42:17.560
endliche Menge von Merkmalsvektoren haben will.

42:18.900 --> 42:21.240
Wo hatte man sowas in der Vorverarbeitung schon mal gesehen?

42:21.540 --> 42:24.820
Wo hatte ich das Problem, dass ich da einen unendlichen Wertebereich

42:24.820 --> 42:27.260
hatte, der aus einer reellen Zahl bestand?

42:28.480 --> 42:33.020
Und ich wollte nicht beliebig viele mögliche reelle Zahlen da haben,

42:33.080 --> 42:37.620
sondern ich wollte nur noch eine endliche Menge von einzelnen

42:37.620 --> 42:38.940
natürlichen Zahlen da haben.

42:38.940 --> 42:41.200
Da gab es einen Schritt in der Vorverarbeitung, wenn ich

42:41.200 --> 42:43.220
Vorverarbeitung mache, wo das genauso gemacht wurde.

42:47.320 --> 42:48.420
Ja, noch viel weiter vorher.

42:49.300 --> 42:52.120
Ich muss ja erstmal zur diskreten irgendwas hinkommen.

42:52.440 --> 42:53.180
Wo komme ich da hin?

42:54.600 --> 42:56.200
Genau, bei der Abtastung und bei der Quantisierung.

42:56.320 --> 43:03.380
Bei der Abtastung der Wertebereich, also ich hatte vorher eine reelle

43:03.380 --> 43:06.560
Zahl oder eine Funktion über eine reelle Zahl über die Zeit hinweg.

43:06.620 --> 43:07.660
Jetzt habe ich abgetastet.

43:08.160 --> 43:10.380
Da habe ich zwar die Zeit diskret gemacht, aber der Wertebereich

43:10.380 --> 43:11.560
selber, der war noch so.

43:12.220 --> 43:16.000
Aber dann bin ich hingegangen und habe das ganze Ding quantisiert

43:16.000 --> 43:16.380
genommen.

43:16.480 --> 43:17.780
Deswegen heißt es Vektorquantisierung.

43:17.920 --> 43:21.540
Ich habe da auch den Wertebereich eines jenen Audio-Samples, das ich

43:21.540 --> 43:25.080
für einen Zeitbereich habe, quantisiert, eingestellt in

43:25.080 --> 43:27.880
unterschiedliche Quantisierungsstufen und müsste mir eigentlich jetzt

43:27.880 --> 43:31.220
nur noch den Index der Quantisierungsstufe jeweils merken.

43:31.600 --> 43:32.880
Und genau das Gleiche will ich hier auch.

43:33.000 --> 43:35.880
Statt den R auch N will ich jetzt nur noch haben eine Menge von

43:35.880 --> 43:43.380
Indizes und alle reellen Vektoren, alle Vektoren aus dem R auch N, die

43:43.380 --> 43:45.760
in einem bestimmten Bereich fallen, werden einfach auf diesen

43:45.760 --> 43:49.900
einzelnen Index abgebildet und der Merkmalsvektor wird ersetzt nur

43:49.900 --> 43:52.140
noch durch diesen Index aus dem R auch N.

43:55.300 --> 43:56.780
Hat folgende Vorteile.

43:56.860 --> 44:00.360
Das erste ist, wenn es nur noch so eine kleine Menge von

44:00.360 --> 44:04.420
Merkmalsvektoren, Indizes gibt, statt beliebiger aussehender

44:05.180 --> 44:07.420
Merkmalsvektoren, kann ich sehr viele Sachen vorbereiten.

44:08.220 --> 44:11.660
Zum Beispiel, wenn ich meine Gauss-Glocke habe, dann kann ich für alle

44:11.660 --> 44:15.220
möglichen auftretenden Indizes, die ich habe, auf die ich quantisieren

44:15.220 --> 44:17.500
kann, vorher schon mal die Wahrscheinlichkeit ausrechnen.

44:17.600 --> 44:21.220
Speichere ich mir nur noch in der Tabelle ab, brauche dann gar nicht

44:21.220 --> 44:23.160
mehr groß irgendwas auszurechnen.

44:23.640 --> 44:25.420
Dann kann ich das auch mit Gauss-Mixtur-Verteilungen machen.

44:25.660 --> 44:28.400
Da kann ich einfach vorher einmal in aller Ruhe alles ausrechnen,

44:28.520 --> 44:30.820
speichere mir das in der großen Tabelle und hinterher, wenn ein

44:30.820 --> 44:33.900
Merkmalsvektor kommt, von dem ich wissen will, was ist denn der Wert

44:33.900 --> 44:37.480
der Gauss-Mixtur von diesem Merkmalsvektor, dann wird er erst

44:37.480 --> 44:40.940
quantisiert, vorher bestimmt auf seinen Index abgebildet und dann

44:40.940 --> 44:43.980
gucke ich nur noch nach in der Tabelle, was ist denn der Wert dieses

44:43.980 --> 44:47.860
Quantisierungsindex und der wird dann ausgebildet.

44:53.180 --> 44:55.240
Also, ich kann Wahrscheinlichkeiten vorberechnen und ich kann auch

44:55.240 --> 44:58.520
einfach nur die Distanzen, monologes Distanzen vorberechnen.

44:58.860 --> 45:02.240
Und das Ganze hat dann einen großen Vorteil, wenn ich sehr

45:02.240 --> 45:07.000
rechenschwachen Geräte habe und das ist häufig bei Dingen, die keine

45:07.000 --> 45:10.240
Floating -Point-Unit haben, also zum Beispiel Mobiltelefone.

45:11.780 --> 45:15.440
Ich weiß gar nicht, wie das inzwischen ist, ich glaube, hat der Arm

45:15.440 --> 45:17.080
inzwischen eine Floating-Point-Unit?

45:17.160 --> 45:21.060
Inzwischen hat er eine, aber bis vor gar nicht allzu langer Zeit, so

45:21.060 --> 45:23.760
vor drei, vier Jahren, hatten die ganzen Smartphones alle noch keine

45:23.760 --> 45:24.620
Floating -Point-Unit.

45:25.320 --> 45:28.340
Und was dann gemacht wurde ist, wenn man Gleitkummerzahlen berechnen

45:28.340 --> 45:32.520
wollte, musste man das Ganze aufwendig mithilfe von Integer-Arithmetik

45:32.520 --> 45:33.800
machen.

45:34.820 --> 45:38.640
Oder wenn die Floating-Point-Unit oder der Prozessor nicht sonderlich

45:38.640 --> 45:41.960
fix ist, oder man Aufgaben hat, die den schnell überlasten können,

45:42.300 --> 45:44.520
dann kann man damit auch sehr viel Rechenzeit sparen.

45:47.160 --> 45:48.020
Was ist der Nachteil?

45:48.080 --> 45:48.920
Was handelt man sich ein?

45:49.260 --> 45:53.900
Genauso wie bei der Quantisierung von Audiodaten handelt man sich hier

45:53.900 --> 45:54.520
Fehler ein.

45:55.200 --> 45:57.980
Der Wert, der hinterher rauskommt aus der Gauss-Glocke, wenn ich den

45:57.980 --> 46:01.980
Quantisierungsindex reinstecke, der ist natürlich nicht genau derselbe

46:01.980 --> 46:04.060
Wert, der herauskommen müsste, wenn ich den ursprünglichen Vektor

46:04.060 --> 46:04.520
reinstecke.

46:04.940 --> 46:06.320
Ich mache irgendeine Art von Fehler.

46:07.320 --> 46:07.780
Gut.

46:09.100 --> 46:13.880
Was wir jetzt machen wollen ist, wir wollen diese Referenzvektoren

46:13.880 --> 46:14.600
finden.

46:14.960 --> 46:16.920
Die muss ich ja irgendwie finden.

46:17.540 --> 46:20.380
Ich will so eine Menge geeigneter Referenzvektoren finden.

46:20.860 --> 46:25.140
Mein ganz billiger Ansatz wäre natürlich, naja, ich lege einfach ein

46:25.140 --> 46:28.020
Gitter über meinen Bereich, ich mache eine Abschätzung, was ist der

46:28.020 --> 46:32.180
kleinste oder größte Wert, was so vorkommen kann, lege ein Gitter

46:32.180 --> 46:37.560
drüber von Referenzvektoren und teile den Raum gleich auf.

46:38.480 --> 46:40.560
Das ist natürlich relativ stupide.

46:41.320 --> 46:44.540
Wir hatten gesehen, wenn wir ein Audiosignal quantisieren, kann man

46:44.540 --> 46:48.700
das so machen, gleiche Stufen, man muss eine bestimmte Menge an Stufen

46:48.700 --> 46:52.280
finden und dann kann man zeigen, wenn man eine bestimmte Menge an

46:52.280 --> 46:55.000
linearen Stufen findet, dann kann man das rauschen, das durch das

46:55.000 --> 46:57.240
Quantisieren drauf modelliert wird und eine bestimmte Schwelle

46:57.240 --> 46:57.520
bringen.

46:58.080 --> 47:00.620
Aber es gab auch intelligentere Verfahren, zum Beispiel sowas wie

47:00.620 --> 47:04.200
Eyler und Müller, die in dem Rechnung getragen haben, dass die

47:04.200 --> 47:07.480
Wellenformen der menschlichen Sprache halt sich nicht überall

47:07.480 --> 47:10.360
gleichmäßig verteilt, sondern in bestimmten Reichen dichter verteilt

47:10.360 --> 47:11.700
ist als in anderen Bereichen.

47:12.460 --> 47:16.300
Und davon kann man jetzt zum Beispiel auch ausgehen, dass man, wenn

47:16.300 --> 47:21.040
man so eine Menge aus dem RhoN quantisieren möchte, dass da dann auch

47:21.880 --> 47:25.020
es sinnvoll wäre, die nicht gleich verteilt reinzulegen, die

47:25.020 --> 47:28.460
Referenzvektoren, sondern dass es wahrscheinlich sinnvoll wäre, die so

47:28.460 --> 47:32.140
reinzulegen, dass der Quantifisierungsfehler minimiert wird.

47:36.720 --> 47:40.320
Und ein schönes Beispiel davon ist zum Beispiel die Verwendung von

47:40.320 --> 47:42.020
Voronoi -Diagrammen.

47:42.500 --> 47:45.620
Also angenommen, wir nehmen die euclidische Distanz als unsere Distanz

47:45.620 --> 47:50.840
zum Referenzvektor und wir ordnen zu jedem möglichen Punkt, den wir

47:50.840 --> 47:55.340
bekommen können aus dem RhoN, ordnen wir den Referenzvektor zu, der

47:55.340 --> 47:58.160
von der euclidischen Distanz her am kleinsten ist.

47:58.960 --> 48:04.240
Was dann passiert, ist, dass die Welt, der Merkmalsraum in diese

48:04.240 --> 48:06.700
Voronoi -Region aufgeteilt wird.

48:07.220 --> 48:18.430
Jetzt machen wir wieder den Versuch, ob das funktioniert hier.

48:27.160 --> 48:28.180
Irgendwann muss man ja Glück haben.

48:31.780 --> 48:34.100
Also das rote Kästchen ist unser Bereich.

48:34.960 --> 48:39.920
Und wenn ich da jetzt ein Referenzvektor reinlege, dann erhalte ich

48:39.920 --> 48:41.460
sogenannte Voronoi-Regionen.

48:42.160 --> 48:46.180
Zum Beispiel für diesen Punkt hier, alle Vektoren, die in diesen

48:46.180 --> 48:50.240
Bereich reinfallen, werden diesem Punkt bei der Quantisierung

48:50.860 --> 48:53.160
zugewiesen, wenn ich denn euclidische Distanz verwende.

48:53.880 --> 48:59.580
Und so kann ich dann anfangen, hier beliebig Referenzvektoren

48:59.580 --> 49:05.420
reinzulegen und mein Raum unterteilt sich dann entsprechend in die

49:05.420 --> 49:06.660
sogenannten Voronoi-Regionen.

49:10.000 --> 49:15.720
Jetzt hat die euclidische Distanz da einen gewissen Nachteil.

49:17.040 --> 49:20.980
Da schaut man sich zum Beispiel mal dieses Beispiel an.

49:21.600 --> 49:24.380
Die Kreise da, die entsprechen Referenzvektoren.

49:25.280 --> 49:28.200
Ich habe hier dann entsprechend die Voronoi-Regionen, die von so einem

49:28.200 --> 49:30.740
jeweiligen Referenzvektor abgedeckt werden.

49:31.460 --> 49:35.020
Und ich will jetzt dieses x quantisieren.

49:35.220 --> 49:37.820
Dieses x soll jetzt einem Referenzvektor zugeordnet werden.

49:38.720 --> 49:40.060
Wo würde man das als Mensch hin tun?

49:40.960 --> 49:43.520
Würde ich sagen, zu welchem Referenzvektor scheint dieses x zu

49:43.520 --> 49:43.780
gehören?

49:46.080 --> 49:51.540
Wenn man da so guckt, was wäre wohl ein sinnvoller Referenzvektor, wo

49:51.540 --> 49:53.020
ich das Ding hinpacken würde?

50:06.070 --> 50:07.690
Würde man das als Mensch wirklich so machen?

50:08.630 --> 50:11.130
Wenn du dir jetzt anguckst, wie da so die Daten liegen, würdest du es

50:11.130 --> 50:13.710
wirklich einfach sturen nach der euclidischen Distanz gehen?

50:16.210 --> 50:20.530
Also ich meine, nach der euclidischen Distanz, hier ist die Voronoi

50:20.530 --> 50:21.910
-Region, die zu dem Vektor gehört.

50:22.630 --> 50:25.210
Das x liegt in dieser Voronoi-Region drin.

50:25.790 --> 50:27.730
Also wird es dazu gepackt.

50:28.850 --> 50:30.110
Aber ist das wirklich sinnvoll?

50:34.830 --> 50:36.810
Ja, aber wir müssen es jetzt quantisieren.

50:37.050 --> 50:38.870
Wir sind gezwungen, es zu quantisieren.

50:41.770 --> 50:44.430
Aber wird es eher nach links gehören, oder wird es eher nach rechts

50:44.430 --> 50:44.730
gehören?

50:57.950 --> 51:00.290
Man könnte also schon sagen, da ist ein Vektor links, die scheinen

51:00.290 --> 51:01.530
alle relativ kompakt zu liegen.

51:02.250 --> 51:05.510
Das heißt, die Voronoi-Region von dem Ding, die erschreckt sich nicht

51:05.510 --> 51:08.650
sonderlich weit, und die Voronoi von dem Ding streckt sich auch nicht

51:08.650 --> 51:09.390
besonders weit.

51:09.930 --> 51:12.730
Warum sollte dann die Region von dem, das da irgendwie oben in dem

51:12.730 --> 51:17.390
Cluster liegt, auch so weit in die Breite reinstreuen, um da alle

51:17.390 --> 51:20.930
Merkmalsvektoren aufzusaugen, die da ranliegen?

51:21.430 --> 51:24.670
Während hier hinten, da gibt es so Merkmalsvektoren, die liegen

51:24.670 --> 51:28.110
relativ weit voneinander entfernt und decken dementsprechend auch

51:28.110 --> 51:29.470
relativ große Regionen ab.

51:30.550 --> 51:33.370
Und deswegen würde man eigentlich vom Gefühl her eher sagen, naja, das

51:33.370 --> 51:37.010
wird ja wohl anscheinend eher mehr so in die Richtung gehören, weil

51:37.010 --> 51:40.990
die liegen ja eher kompakt, also die Merkmale, die zu so einem Punkt

51:40.990 --> 51:43.310
gehören, die scheinen nicht sonderlich weit drum herum zu streuen.

51:45.490 --> 51:49.030
Und deswegen wäre es eigentlich hier sinnvoller zu sagen, naja, wenn

51:49.030 --> 51:51.130
ich jetzt die Linie nicht gesehen hätte, würde ich eher sagen, naja,

51:51.190 --> 51:53.950
das Ding muss irgendwie nach da rechts rein, das scheint da irgendwie

51:53.950 --> 51:54.710
dazuzugehören.

51:55.810 --> 51:58.470
Und das will man halt machen, man will halt die Varianz der Daten

51:58.470 --> 51:59.990
jetzt noch zusätzlich mit hinzunehmen.

52:00.470 --> 52:02.870
Das heißt, man geht einfach nicht mehr nach der euclidischen Distanz

52:02.870 --> 52:07.790
des jeweiligen Referenzvektors, sondern man nimmt die Manalovis

52:07.790 --> 52:08.250
-Distanz.

52:08.650 --> 52:10.250
Da haben wir schon letztes Mal drüber gesprochen.

52:10.830 --> 52:14.350
Man versucht also die Varianz noch mit hinzuzunehmen bei der

52:14.350 --> 52:16.070
Berechnung der Distanz.

52:17.970 --> 52:22.030
Einziger Nachteil ist natürlich bei so Vor- und Neudiagrammen, wenn

52:22.030 --> 52:25.330
ich jetzt angenommen, ich habe meine Menge von Beispielvektoren und

52:25.330 --> 52:28.630
will die als Referenzvektoren nehmen, dann kann ich die einfach so

52:28.630 --> 52:30.750
direkt nehmen und das Vor- und Neudiagramm aufspannen.

52:31.170 --> 52:34.450
Wenn ich jetzt die Manalovis-Distanz nehmen möchte, dann muss ich halt

52:34.450 --> 52:37.870
noch die Varianz der jeweiligen Punkte um diesen Referenzvektor hin

52:37.870 --> 52:38.750
schätzen.

52:39.910 --> 52:43.110
Das heißt, ich brauche also so eine Trainingsmenge, wo bereits die

52:43.110 --> 52:46.830
einzelnen Merkmale oder die einzelnen Merkmalsvektoren ihrem

52:46.830 --> 52:49.390
jeweiligen Referenzvektor verbunden sind.

52:49.670 --> 52:53.030
Wenn ich das habe, kann ich dann die Varianz der Daten um einen

52:53.030 --> 52:56.410
jeweiligen Referenzvektor herum schätzen und kann dann die Manalovis

52:56.410 --> 52:58.950
-Distanz ausrechnen.

53:01.330 --> 53:06.290
Man kann jetzt Vektorquantisierung auch als ein Klassifikationsproblem

53:06.290 --> 53:08.050
betrachten.

53:08.890 --> 53:12.210
Also das eine ist, dass ich sage, ich möchte einfach die Anzahl der

53:12.210 --> 53:14.510
verschiedenen Merkmalsvektoren, die es gibt, reduzieren durch

53:14.510 --> 53:16.290
Quantifizierung.

53:16.810 --> 53:19.690
Oder ich kann sagen, ich möchte dieses Vektorquantisierungsverfahren

53:20.730 --> 53:24.190
als ein Musterklassifikationsproblem betrachten.

53:25.030 --> 53:28.990
Und die Fragestellung lautet dort, ich habe einen Vektor X gegeben und

53:28.990 --> 53:33.170
möchte das jetzt dem passenden Referenzvektor zuordnen.

53:33.530 --> 53:37.030
Das heißt, der Referenzvektor ist jetzt die Klasse, dem er zugeordnet

53:37.030 --> 53:37.530
werden will.

53:39.290 --> 53:45.150
Was ich bisher auch immer relativ falsch gemacht habe, ist, für jede

53:45.150 --> 53:49.330
Quantisierungsstufe, die ich bisher hatte, hatte ich immer nur einen

53:49.330 --> 53:50.090
Referenzvektor.

53:51.010 --> 53:53.530
Und hatte halt geschaut, okay, für jede Quantisierungsstufe ein

53:53.530 --> 53:54.250
Referenzvektor.

53:54.410 --> 53:55.770
Was ist der nächste Referenzvektor?

53:56.570 --> 54:00.770
Und packe dann das Ding in genau diese Quantisierungsstufe raus.

54:01.950 --> 54:06.010
Wenn ich jetzt in meinen Trainingsdaten Ausreiße habe und ich die

54:06.010 --> 54:09.690
Quantisierungsstufen auf meinen Trainingsdaten finde, dann können

54:10.410 --> 54:15.290
Ausreißer die ganze schöne Quantisierung ziemlich verfälschen, unschön

54:15.290 --> 54:16.070
verformen.

54:16.670 --> 54:21.690
Und damit ich gegen solche Ausreißer resistent sein kann, kann ich

54:21.690 --> 54:27.110
anfangen, jetzt nicht einen Referenzvektor pro Quantisierungsstufe

54:27.110 --> 54:30.930
oder pro Schrägstrichklasse zu verwenden, sondern ich kann anfangen,

54:31.430 --> 54:34.350
mehrere Referenzvektoren pro Quantisierungsstufe zu verwenden.

54:35.210 --> 54:40.310
Und wenn ich das mache, komme ich zu einem ganz simplen Verfahren, das

54:40.310 --> 54:42.750
alle wahrscheinlich schon mal gehört haben, das k-nächste

54:42.750 --> 54:43.630
Nachbarverfahren.

54:44.310 --> 54:49.150
Kann man jetzt verwenden, zum Beispiel für Klassifizierung, Vektor x

54:49.150 --> 54:51.290
einer Klasse zuordnen.

54:52.050 --> 54:56.170
Und da Quantifizierung auch nichts anderes ist als eine

54:57.430 --> 55:00.730
Klassifikation, kann ich es auch zum Quantisieren sozusagen verwenden.

55:01.410 --> 55:07.810
Und die Idee ist da halt, für einen Vektor x schaue ich halt nach, was

55:07.810 --> 55:10.910
sind denn die fünf nächsten Nachbarn, die fünf nächsten

55:10.910 --> 55:13.630
Referenzvektoren, die jetzt bei dem x dran liegen.

55:14.370 --> 55:17.070
Und dann gucke ich unter diesen fünf Referenzvektoren nach, wie viele

55:17.070 --> 55:19.310
gehören zu Quantisierungsstufe a und wie viele gehören zu

55:19.310 --> 55:20.350
Quantisierungsstufe b.

55:21.190 --> 55:27.490
Und das, wo dann die meisten Vektoren von kommen, das ist dann meine

55:29.650 --> 55:30.090
Quantisierungsstufe.

55:30.090 --> 55:33.090
Oder allgemeiner gesprochen, das ist dann die Klasse, zu der ich es

55:33.090 --> 55:33.470
zuordne.

55:33.890 --> 55:37.790
Und dann kann ich da alle möglichen Klassifikationsprobleme damit

55:37.790 --> 55:38.190
lösen.

55:40.410 --> 55:45.670
Was mache ich, wenn ich jetzt nach meinen nächsten sechs Nachbarn

55:45.670 --> 55:48.750
geguckt habe und ich finde drei von Klasse a und drei von Klasse b?

55:51.980 --> 55:53.120
Was könnte ich da machen?

55:58.380 --> 56:00.360
Ich nehme also 7k.

56:01.200 --> 56:04.780
Bekomme ich zwei aus Klasse a, zwei aus Klasse b, einen aus Klasse c,

56:04.900 --> 56:07.360
einen aus Klasse d, einen aus Klasse e und einen aus Klasse f.

56:12.240 --> 56:14.420
Nein, es waren zwei zweien und der Rest ist alles eins.

56:15.960 --> 56:16.620
Was mache ich dann?

56:18.660 --> 56:19.280
Bringt auch nichts.

56:25.570 --> 56:28.570
Zum Beispiel, ich habe ja da irgendwie schon mal Distanz ausgerechnet,

56:28.650 --> 56:30.270
damit ich meine nächsten Nachbarn finde.

56:30.950 --> 56:33.730
Dann kann ich ja zum Beispiel auch die summierte Distanz nehmen, um

56:33.730 --> 56:34.310
sowas zu machen.

56:34.310 --> 56:37.830
Und dann könnte man dann entweder das als Tiebreaker nehmen, um halt

56:37.830 --> 56:40.110
so unklare Sachen aufzulösen.

56:40.190 --> 56:43.670
Oder ich könnte halt versuchen, damit gleich mit der Distanz zu

56:43.670 --> 56:43.950
arbeiten.

56:47.390 --> 56:51.310
Man soll es jetzt nicht meinen, auch das k-nächste-Nachbar-Problem

56:51.310 --> 56:52.310
möchte man gerne beschleunigen.

56:53.430 --> 56:56.550
Weil kann durchaus sein, dass wenn man das macht, dass man relativ

56:56.550 --> 56:59.730
viele Referenzvektoren pro Klasse hat, vielleicht sowas wie 1024.

57:00.590 --> 57:03.170
Und dann werden wir hintersehen, in der Spracherkennung haben wir

57:03.170 --> 57:08.970
unter Umständen sowas wie 10.000 oder noch mehr Klassen, zu der wir

57:08.970 --> 57:11.290
hinzu klassifizieren wollen.

57:11.450 --> 57:14.850
Plus, dass es nicht so ungewöhnlich ist, dass ich da sowas 16- bis 48

57:14.850 --> 57:16.730
-dimensionalen Merkmalsraumvektor habe.

57:17.290 --> 57:20.350
Und wenn ich das habe und muss dann erstmal die fünf nächsten Nachbarn

57:20.350 --> 57:24.350
finden und so weiter und so fort, bei vielleicht, wenn ich jetzt auch

57:24.350 --> 57:27.670
noch, sagen wir mal, fünf Repräsentanten pro Klasse habe, dann habe

57:27.670 --> 57:32.170
ich sowas wie 5.000 Vektoren und dann muss ich, oder gut, ich hätte

57:32.170 --> 57:39.910
sowas wie 10.000 Vektoren oder sowas, dann bin ich da relativ viel

57:39.910 --> 57:41.570
beschäftigt.

57:41.930 --> 57:44.670
Und unter Umständen muss ich sowas für jeden Zeitschritt machen, also

57:44.670 --> 57:47.210
wenn ich Pech habe, muss ich das alle 10 Millisekunden machen.

57:47.350 --> 57:49.190
Das heißt, ich muss das sehr, sehr häufig ausrechnen.

57:50.070 --> 57:53.450
Und das möchte ich halt irgendwie beschleunigen, diesen Rechenaufwand.

57:54.270 --> 57:57.110
Und wenn wir irgendwas beschleunigen, irgendwelche Algorithmen

57:57.110 --> 58:00.930
beschleunigen wollen in ihrer Berechnung, dann gibt es immer zwei

58:00.930 --> 58:02.010
Möglichkeiten, das zu machen.

58:03.270 --> 58:06.750
Also außer, dass ich jetzt direkt am Algorithmus selber rumfummel,

58:06.830 --> 58:09.890
sondern mir geht es jetzt darum, dass ich an dem Verfahren was ändere.

58:10.790 --> 58:13.930
Ich kann es entweder so ändern und so ausrechnen, dass ich dann immer

58:13.930 --> 58:17.370
noch das korrekte Ergebnis finde, aber meine Beschleunigung ist nicht

58:17.370 --> 58:17.850
garantiert.

58:18.090 --> 58:21.050
Ich kann also irgendwo meine Berechnung so umändern, dass ich mit

58:21.050 --> 58:24.970
hoher Wahrscheinlichkeit weniger rechnen muss, aber es kann mir nicht

58:24.970 --> 58:26.930
garantiert sein, dass ich hier eine Beschleunigung bekomme.

58:27.050 --> 58:29.090
Wenn ich Pech habe, kann es sogar sein, dass es langsamer ist.

58:30.050 --> 58:33.550
Oder ich kann Verfahren so machen, dass meine Beschleunigung

58:33.550 --> 58:37.270
garantiert ist, also ich garantiere, egal in welchem Fall, werde ich

58:37.270 --> 58:40.650
immer schneller rechnen, aber es kann sein, dass ich nicht das

58:40.650 --> 58:43.790
korrekte oder das optimale Ergebnis rausbekomme.

58:44.890 --> 58:47.730
Einfaches Beispiel wäre zum Beispiel, dass man einfaches Distanzmaß

58:47.730 --> 58:47.930
nimmt.

58:48.250 --> 58:53.110
Also statt meiner Lobesdistanz nimmt man nur noch euklidische Distanz.

58:53.230 --> 58:56.010
Dann habe ich da das Problem, dass das Ergebnis nicht mehr so optimal

58:56.010 --> 58:56.170
ist.

58:56.310 --> 58:58.730
Statt euklidischer Distanz nehme ich Cityblockmetrik.

58:59.310 --> 59:01.870
Dann wird es unter Umständen noch ungenauer, mein

59:01.870 --> 59:03.970
Klassifikationsergebnis am Ende.

59:08.250 --> 59:13.270
Oder, was es auch eine Möglichkeit gibt zur Beschleunigung, ich rechne

59:13.270 --> 59:17.750
da ja immer Distanzen aus und ich suche immer die fünf Vektoren, die

59:17.750 --> 59:18.530
am nächsten dran liegen.

59:18.630 --> 59:22.030
Oder ich suche zumindest den Referenzvektor, der am nächsten dran

59:22.030 --> 59:22.270
liegt.

59:22.930 --> 59:25.710
Und wenn ich so Distanzen ausrechne, die meisten Distanzberechnungen

59:25.710 --> 59:28.850
sehen dann halt so aus, jetzt hier am Beispiel der euklidischen

59:28.850 --> 59:31.870
Distanz, dass ich immer erste Dimension, zweite Dimension, dritte

59:31.870 --> 59:32.810
Dimension usw.

59:32.970 --> 59:33.210
usf.

59:33.510 --> 59:37.570
und ich addiere über die Dimensionen hinweg Werte auf und je mehr ich

59:37.570 --> 59:43.950
dazu addiere, desto höher wird immer meine Distanz.

59:45.770 --> 59:51.150
Und wenn ich jetzt irgendwann feststelle, dass ich hier bei der i-ten

59:51.150 --> 59:55.310
Dimension, bei einem d-dimensionalen Vektor, bereits einen höheren

59:55.310 --> 01:00:00.210
Wert hatte als bei einem vorhergehenden Beispiel, dann brauche ich von

01:00:00.210 --> 01:00:03.230
der i-ten Dimension bis zur d-ten Dimension gar nicht mehr zu rechnen.

01:00:03.250 --> 01:00:05.750
Weil dann addiere ich nur noch Zeug drauf und die Distanz kann nur

01:00:05.750 --> 01:00:06.350
noch schlimmer werden.

01:00:06.450 --> 01:00:07.410
Sie kann nur noch größer werden.

01:00:07.470 --> 01:00:10.390
Sie kann auf keinen Fall mehr kleiner werden als irgendwas, was ich

01:00:10.390 --> 01:00:11.550
vorher schon mal gefunden hatte.

01:00:12.650 --> 01:00:14.990
Und wenn man das so macht, das ganze Verfahren nennt sich dann Early

01:00:14.990 --> 01:00:20.750
Abortion, dann spart man sich hier hinten halt die Aufaddiererei der

01:00:20.750 --> 01:00:23.510
zusätzlichen Dimensionen, die es nur noch schwieriger machen werden.

01:00:26.050 --> 01:00:29.850
Jetzt habe ich geschrieben, also garantiert korrektes Ergebnis, aber

01:00:29.850 --> 01:00:34.850
wieso garantiert mir das nicht, dass meine Rechnerei beschleunigt

01:00:34.850 --> 01:00:35.050
wird?

01:00:39.840 --> 01:00:45.240
Genau, kann blöd laufen, dann ist der beste Vektor, den ich finde, das

01:00:45.240 --> 01:00:46.860
ist dann der, den ich als letztes anfasse.

01:00:47.380 --> 01:00:50.540
Den muss ich dann bis zur vollen Dimension ausrechnen.

01:00:51.620 --> 01:00:54.300
Kann das sogar noch schlimmer werden von der Rechenzeit her?

01:00:54.800 --> 01:00:58.180
Kann ich also auch noch langsamer sein, als ich das mit dem naiven

01:00:58.180 --> 01:00:58.880
Verfahren wäre?

01:01:01.780 --> 01:01:04.140
Richtig, das viele vergessen.

01:01:04.280 --> 01:01:05.160
Es kommt der Vergleich hinzu.

01:01:05.240 --> 01:01:09.200
Nach jeder Addition von der Dimension muss ich noch vergleichen, bin

01:01:09.200 --> 01:01:12.240
ich da jetzt schon größer als mein bisher bestes Ergebnis oder nicht?

01:01:14.720 --> 01:01:17.000
Dann kann man noch so ein Mischverfahren machen und sagen, ich mache

01:01:17.000 --> 01:01:19.600
das nicht nach jeder Dimension, ich mache das nach jeweils acht

01:01:19.600 --> 01:01:20.520
Dimensionen.

01:01:20.640 --> 01:01:27.680
Oder ich gucke, wenn ich jetzt einfache Vektorrechnungen auf meiner

01:01:27.680 --> 01:01:31.260
CPU habe, die MMX-Erweiterung oder was es da heutzutage alles gibt,

01:01:31.560 --> 01:01:34.180
dann gucke ich halt, was kann ich denn so in einem Rutsch immer

01:01:34.180 --> 01:01:34.800
durchaddieren.

01:01:34.900 --> 01:01:37.160
Das sind dann irgendwie 16 Dimensionen und dann mache ich das immer

01:01:37.160 --> 01:01:41.320
noch nach einem Rutsch, diese Überprüfung und dann kann man dann die

01:01:41.320 --> 01:01:44.000
Early Abortion machen und dann kann der Compiler dann noch so was mit

01:01:44.000 --> 01:01:47.160
spekulativen Branching und allem möglichen Pipapo versuchen, Sachen

01:01:47.160 --> 01:01:47.780
rauszuholen.

01:01:48.200 --> 01:01:50.540
Aber trotzdem, wenn es wirklich dumm läuft, kann es sein, dass ich am

01:01:50.540 --> 01:01:51.560
Ende sogar langsamer bin.

01:01:52.200 --> 01:01:54.760
Aber in der Regel und im Mittel wird das natürlich nicht der Fall

01:01:54.760 --> 01:01:55.040
sein.

01:01:58.080 --> 01:02:02.740
Dann gibt es eine weitere Möglichkeit und die beschäftigt sich damit,

01:02:04.160 --> 01:02:09.680
in welcher Reihenfolge ich denn sozusagen die Vektoren ausrechne oder

01:02:09.680 --> 01:02:12.480
welche Vektoren ich mir überhaupt noch anschaue als mögliche

01:02:12.480 --> 01:02:15.700
Kandidaten dazu, welche die Nächsten sein können.

01:02:16.420 --> 01:02:21.080
Und da gibt es die Möglichkeit, dass man sich seinen Merkmalsraum in

01:02:21.080 --> 01:02:22.820
einer Art Baumstruktur organisiert.

01:02:26.460 --> 01:02:29.560
Und die Baumstruktur kann man sich so vorstellen, dass man sich seinen

01:02:29.560 --> 01:02:37.280
Merkmalsraum immer in so Halbebenen organisiert und dann halt für jede

01:02:37.280 --> 01:02:41.180
Dimension halt erstmal immer abfragt, liegt der Vektor links oder

01:02:41.180 --> 01:02:42.140
rechts von der Halbebene.

01:02:42.580 --> 01:02:45.980
Liegt er ober- oder unterhalb der nächsten Halbebene und so weiter und

01:02:45.980 --> 01:02:46.400
so fort.

01:02:46.980 --> 01:02:50.720
Und auf die Art und Weise schachtelt sich der Raum auf in so einer

01:02:51.260 --> 01:02:51.740
Baumstruktur.

01:02:52.380 --> 01:02:56.240
Und wenn ich meine Halbebenen, nach denen ich frage, jetzt korrekt und

01:02:56.240 --> 01:03:00.200
geschickt wähle und wenn meine Merkmalsvektoren, meine

01:03:00.200 --> 01:03:03.040
Referenzvektoren sich irgendwie schön in einem Raum zumindest halbwegs

01:03:03.040 --> 01:03:06.960
hinklustern, dann muss ich auch nicht unbedingt durch jede Dimension

01:03:06.960 --> 01:03:10.260
durchgehen, sondern ich muss nur so lange immer diese Vergleiche

01:03:10.260 --> 01:03:14.160
links, rechts von der Halbebene machen, bis ich in einem Unterraum

01:03:14.160 --> 01:03:17.580
ankomme, in dem sowieso nur noch ein Referenzvektor liegt.

01:03:18.880 --> 01:03:21.340
Und wenn ich, wie gesagt, wenn das halt schön geschickt drin liegt,

01:03:21.580 --> 01:03:24.600
dann kann das schon sein, dass ich halt nicht mehr für jede Dimension

01:03:24.600 --> 01:03:27.380
diesen Vergleich mit den Halbebenen machen muss, sondern dass das

01:03:27.380 --> 01:03:31.060
schon nach einer kleineren Anzahl an Dimensionen der Fall ist.

01:03:32.020 --> 01:03:36.160
Und da besteht jetzt die Kunst halt darin, dass man halt diese

01:03:36.160 --> 01:03:38.660
Halbebenen möglichst gut findet.

01:03:39.600 --> 01:03:42.480
Und da ist halt eine Möglichkeit, dass man halt so hingeht und sich

01:03:42.480 --> 01:03:44.040
zum Beispiel nach der Varianz orientiert.

01:03:44.140 --> 01:03:48.180
Ich gucke immer, in welcher Richtung ist die höchste Varianz und

01:03:48.180 --> 01:03:51.980
spalte dann halt diese höchste Varianz auf in zwei Unterteile.

01:03:52.960 --> 01:03:59.220
Und auf die Art und Weise komme ich dann in diesen Baum, der den

01:03:59.220 --> 01:03:59.780
aufspaltet.

01:04:00.180 --> 01:04:02.520
Und dann kann ich das Verfahren auch noch gleich dazu nehmen, um mir

01:04:02.520 --> 01:04:07.160
Referenzvektoren vielleicht sogar unüberwacht zu finden.

01:04:07.260 --> 01:04:10.200
Weil ich kann mir sagen, naja, wenn der Raum vielleicht kompakt genug

01:04:10.200 --> 01:04:15.460
ist, dann ist dieses Blatt in diesem Baum dann gleich auch noch meine

01:04:15.460 --> 01:04:19.200
Region, die diesem Referenzvektor zugeordnet wird, der jetzt durch das

01:04:19.200 --> 01:04:21.240
Blatt des Referenzvektors verarbeitet wird.

01:04:22.040 --> 01:04:26.120
Und auf die Art und Weise gibt es so zwei verschiedene Verfahren, wie

01:04:26.120 --> 01:04:29.960
man das berechnen kann.

01:04:30.480 --> 01:04:33.300
Und das Schöne ist, das werden wir später sehen, für bestimmte

01:04:33.300 --> 01:04:36.580
Situationen ist es sogar möglich, diese beiden Verfahren miteinander

01:04:36.580 --> 01:04:39.880
zu verbinden, um auch nochmal eine Beschleunigung zu erreichen.

01:04:42.340 --> 01:04:45.140
Also, das erst mal zum Thema, was man so bei Vektorquantisierung

01:04:45.140 --> 01:04:45.660
machen kann.

01:04:47.460 --> 01:04:50.380
Und jetzt zurück zu der Frage, die ich vorhin schon gesagt hatte.

01:04:50.540 --> 01:04:55.340
Da war die Frage, kann man da irgendwas daraus lernen für das Problem,

01:04:55.560 --> 01:04:58.940
dass ich Gauss-Mixtur-Verteilung möglichst schnell ausrechnen will.

01:04:59.440 --> 01:05:02.820
Dass ich irgendwie diesen Trick mit dem Logarithmus möglichst schnell

01:05:02.820 --> 01:05:05.080
in diese Gauss-Mixtur-Verteilung reinkriegen kann.

01:05:05.900 --> 01:05:08.300
Und da setzt ihr euch halt auch mal wieder mit zwei, drei Leuten, mit

01:05:08.300 --> 01:05:11.840
euren Nachbarn zusammen und überlegt mal, was gibt es da für mögliche

01:05:11.840 --> 01:05:13.300
Strategien, was man da machen könnte.

01:05:14.460 --> 01:05:19.340
Und als Hinweis, als erstes, das Verfahren, das dabei herauskommen

01:05:19.340 --> 01:05:21.520
soll, muss nicht mehr den exakten Wert zurückliefern.

01:05:22.020 --> 01:05:25.740
Also, ich kann da nur was beschleunigen, wenn ich nicht mehr den

01:05:25.740 --> 01:05:29.420
exakten Wert bekomme, sondern nur noch einen möglichst ähnlichen guten

01:05:29.420 --> 01:05:29.700
Wert.

01:05:31.160 --> 01:05:34.360
Und da wir ja da mit Vektorquantisierung zu tun hatten, wäre jetzt die

01:05:34.360 --> 01:05:37.420
Frage, wo wäre denn da die Analogie bei den Gauss-Mixtur-Verteilungen?

01:05:38.140 --> 01:05:40.900
Wo wären denn da die Referenzvektoren meiner Quantisierung?

01:05:41.360 --> 01:05:42.980
Was wäre da sinnvoll?

01:05:43.920 --> 01:05:46.500
Und natürlich, ich möchte die E-Funktion loswerden, das heißt, ich

01:05:46.500 --> 01:05:48.080
will irgendwie den Logarithmus anwenden können.

01:05:48.820 --> 01:05:51.380
Und jetzt muss ich diese beiden Ideen der Quantisierung und des

01:05:51.380 --> 01:06:00.360
Findens von Referenzvektoren irgendwie verknüpfen mit dem, dass ich

01:06:00.360 --> 01:06:04.160
logarithmieren nur auf einer Gauss-Glocke machen kann, plus der

01:06:04.160 --> 01:06:06.580
Tatsache, dass ich ja auch bei den Gauss-Glocken und bei den Gauss

01:06:06.580 --> 01:06:08.960
-Mixtur -Verteilungen, da habe ich ja ein Distanzmaß.

01:06:09.600 --> 01:06:12.280
Da habe ich ja die Maler-Lobis-Distanz oben im Exponenten der E

01:06:12.280 --> 01:06:12.880
-Funktion stehen.

01:06:13.900 --> 01:06:17.580
Das sind jetzt die drei Ideen, die man jetzt irgendwie geschickt

01:06:17.580 --> 01:06:18.780
miteinander verknüpfen muss.

01:06:19.180 --> 01:06:21.560
Ich will also nicht mehr den genauen Wert der Gauss-Mixtur

01:06:21.560 --> 01:06:24.800
rauskriegen, sondern es wird nur noch ein approximativer Wert.

01:06:24.960 --> 01:06:27.240
Dafür will ich aber, dass da der Logarithmus rein soll.

01:06:28.140 --> 01:06:32.220
Und ich will das so ähnlich machen wie bei der Quantisierung, dass ich

01:06:32.220 --> 01:06:38.900
da irgendwie einen Wert habe, der irgendwie repräsentativ jetzt ist

01:06:38.900 --> 01:06:40.440
für diesen x, dass ich da reinstecke.

01:06:41.040 --> 01:06:44.200
Okay, dann jeweils zusammensetzen.

01:06:46.960 --> 01:06:48.440
Okay, Freiwillige vor.

01:06:54.700 --> 01:06:57.180
Wer hat eine Grundidee, was man machen könnte?

01:06:58.240 --> 01:06:59.760
Wie werde ich diese dumme Summe los?

01:07:26.510 --> 01:07:29.330
Okay, also ich habe Gauss-Glocken in meiner Gauss-Mixtur.

01:07:32.460 --> 01:07:33.860
Die liegen irgendwie so.

01:07:35.960 --> 01:07:37.040
Und jetzt habe ich einen x.

01:07:43.130 --> 01:07:45.850
Ja, also eigentlich will ich sogar nur den Score haben.

01:07:45.970 --> 01:07:47.170
Ich will ja etwas logarithmisches haben.

01:07:54.850 --> 01:07:55.050
Genau.

01:08:19.350 --> 01:08:21.770
Also meine Logis-Distanz kann ich schnell ausrechnen, wie bei den

01:08:21.770 --> 01:08:22.470
einzelnen Gauss-Glocken.

01:08:26.190 --> 01:08:26.610
Genau.

01:08:28.090 --> 01:08:30.630
Dann hast du also hier den Logarithmus von der Gauss-Glocke.

01:08:36.100 --> 01:08:39.140
Na gut, also ich habe erstmal den Logarithmus-Wert von dieser Gauss

01:08:39.140 --> 01:08:39.420
-Glocke.

01:08:40.140 --> 01:08:41.500
Was mache ich mit den anderen Gauss-Glocken?

01:08:44.320 --> 01:08:48.020
Genau, wenn der Wert hier liegt und die Gauss-Glocken liegen irgendwie

01:08:48.020 --> 01:08:48.400
da hinten.

01:08:49.260 --> 01:08:50.460
Und das Ganze ist eine E-Funktion.

01:08:50.520 --> 01:08:54.660
Das heißt, die Distanz, wie groß wird der Wert sein, dieser Gauss

01:08:54.660 --> 01:08:55.820
-Glocke, wenn das x da liegt.

01:08:56.120 --> 01:08:58.560
Also wenn hier, das ist einmal Standardabweichung und das ist dann,

01:08:58.660 --> 01:09:00.060
keine Ahnung, 6 mal 7 mal Standardabweichung.

01:09:01.620 --> 01:09:03.840
Das ist nichts, das ist 0,0000 irgendwas.

01:09:04.440 --> 01:09:05.340
Der ist extrem klein.

01:09:06.800 --> 01:09:11.560
Der fällt ja nicht ab mit der euclidischen Distanz linear, sondern je

01:09:11.560 --> 01:09:14.540
weiter der weg ist, desto schneller fällt der ja sozusagen ab.

01:09:14.700 --> 01:09:17.860
Der geht ja ganz schnell gegen 0, wenn ich mich vom Mittelwert weit

01:09:17.860 --> 01:09:18.620
entferne.

01:09:18.960 --> 01:09:21.440
Einzige Ausnahme ist, wenn ich eine Varianz habe, die wirklich sehr

01:09:21.440 --> 01:09:22.280
breit gestreut ist.

01:09:22.300 --> 01:09:24.740
Aber wenn ich so eine ganz normale Varianz habe, fällt ja ja

01:09:24.740 --> 01:09:27.480
entsprechend der Varianz relativ schnell ab, wenn ich mich möglichst

01:09:27.480 --> 01:09:28.410
weit vom Mittelwert entferne.

01:09:29.300 --> 01:09:32.660
Das heißt also, die Idee ist, statt jetzt alle Gauss-Glocken in der

01:09:32.660 --> 01:09:36.880
Summe auszurechnen, rechne ich nur noch die Gauss-Glocke aus, die den

01:09:36.880 --> 01:09:39.980
größten Beitrag überhaupt zu dieser gesamten Summe überhaupt liefern

01:09:39.980 --> 01:09:40.200
wird.

01:09:40.940 --> 01:09:44.440
Und sag dann, wenn die Gauss-Glocken weit genug auseinander liegen und

01:09:44.440 --> 01:09:49.460
die Varianz nicht ganz so breit ist, sondern schon halbwegs

01:09:49.460 --> 01:09:53.900
hinreichend scharf, dann reicht es aus, diese eine Gauss-Glocke

01:09:53.900 --> 01:09:59.160
überhaupt nur noch auszurechnen und alle anderen ignoriere ich.

01:09:59.820 --> 01:10:00.780
Dann mache ich einen Fehler.

01:10:01.180 --> 01:10:03.520
Das, was am Ende herauskommt, ist nicht der exakte Werk der Gauss

01:10:03.520 --> 01:10:06.800
-Mixtur, aber der Fehler wird hoffentlich relativ klein sein, weil die

01:10:06.800 --> 01:10:11.860
Dinge halt nur ganz kleine Beiträge haben, die anderen Gauss-Glocken.

01:10:11.980 --> 01:10:14.080
Es gibt wirklich nur eine Gauss-Glocke, die diejenige ist, die

01:10:14.080 --> 01:10:17.500
überhaupt einen signifikanten Beitrag brauchen wird.

01:10:18.560 --> 01:10:22.120
Was ist, wenn gar keine Gauss-Glocke einen signifikanten Beitrag

01:10:22.120 --> 01:10:22.760
liefert?

01:10:23.500 --> 01:10:27.980
Also angenommen, da mein X liegt hier, funktioniert das Verfahren

01:10:27.980 --> 01:10:28.380
immer noch.

01:10:35.310 --> 01:10:36.310
Und da brauche ich das.

01:10:40.970 --> 01:10:43.730
Ja, oder was passiert hier, was ist denn der Wert?

01:10:43.990 --> 01:10:49.090
Dann wird das wieder dem Ding zugeordnet, der Wert ist schon de facto

01:10:49.090 --> 01:10:49.450
gleich.

01:10:49.650 --> 01:10:50.630
Also es funktioniert immer noch.

01:10:50.790 --> 01:10:54.450
Selbst wenn keine Gauss-Glocke einen signifikanten Beitrag dazu

01:10:54.450 --> 01:10:57.590
beileistet, dann heißt das, dass insgesamt die Gauss-Mixtur auch sehr

01:10:57.590 --> 01:11:01.070
nahe Null liegen wird und damit wird der Fehler auch sehr, sehr, sehr

01:11:01.070 --> 01:11:01.750
gering sein.

01:11:03.770 --> 01:11:08.310
So, und jetzt in den letzten zwei Minuten kann man sich vorstellen,

01:11:08.430 --> 01:11:11.670
dass man da auch noch was rein kombinieren kann mit der Idee, mit

01:11:11.670 --> 01:11:12.570
dieser Baumstruktur.

01:11:14.610 --> 01:11:17.990
Also angenommen, mir wäre der Fehler zu groß, wenn ich nur eine Gauss

01:11:17.990 --> 01:11:18.550
-Glocke nehme.

01:11:20.410 --> 01:11:22.890
Angenommen, das wäre mir zu groß, der Fehler.

01:11:23.270 --> 01:11:24.550
Ich will ein bisschen genauer rechnen.

01:11:25.750 --> 01:11:28.570
Aber ich will auch nicht die E-Funktion aller 32 Gauss-Glocken in der

01:11:28.570 --> 01:11:29.590
Gauss -Mixtur ausrechnen.

01:11:31.030 --> 01:11:32.450
Kann man sich da auch was vorstellen.

01:11:35.270 --> 01:11:42.750
Ja, die Idee wäre zum Beispiel, dass ich nur die zwei oder drei am

01:11:42.750 --> 01:11:44.230
nächsten liegenden Gauss-Glocken nehme.

01:11:47.090 --> 01:11:49.230
Und da ist jetzt natürlich noch die Frage,

01:11:52.610 --> 01:11:55.150
welche Technik... oder jetzt erstmal nur zu dem ursprünglichen

01:11:55.150 --> 01:11:57.310
Verfahren mit der nächsten Gauss-Glocke.

01:11:57.390 --> 01:11:59.590
Also ich muss die Gauss-Glocke finden, die am nächsten dran liegt,

01:11:59.710 --> 01:12:00.910
gemäß Mahler-Lobes-Distanz.

01:12:01.330 --> 01:12:02.890
Da brauche ich noch keine E-Funktion für.

01:12:03.790 --> 01:12:06.130
Plus, welche andere Technik nehme ich, damit ich es möglichst schnell

01:12:06.130 --> 01:12:06.450
finde?

01:12:07.330 --> 01:12:09.450
Genauso wie beim Quantisieren.

01:12:09.730 --> 01:12:12.870
Dieses Early Abortion ist etwas, was ich auch gleich drauf werfe, weil

01:12:12.870 --> 01:12:14.790
das in der Regel auch relativ gut funktionieren wird.

01:12:15.070 --> 01:12:17.430
Ich meine, dieses eine Beispiel mit dem ersten X zeigt ja relativ

01:12:17.430 --> 01:12:20.870
schnell, dass ich da nur sehr wenige Dimensionen werde ausrechnen

01:12:20.870 --> 01:12:23.810
müssen, weil in dieser Dimension ist der Unterschied schon so eklatant

01:12:23.810 --> 01:12:26.550
und wenn ich das über alle Dimensionen ungefähr gleich sehe, wird

01:12:26.550 --> 01:12:28.910
relativ schnell sich herauskristallisieren, dass das die am nächsten

01:12:28.910 --> 01:12:30.170
liegende Gauss-Glocke ist.

01:12:30.990 --> 01:12:34.210
Und das kann ich jetzt auch noch mit der Baumstruktur kombinieren, um

01:12:34.210 --> 01:12:37.810
die nächstgelegene Gauss-Glocke zu finden oder um vielleicht die drei

01:12:37.810 --> 01:12:40.250
nächstgelegenen Gauss-Glocken zu finden, den Raum zu finden, wo die

01:12:40.250 --> 01:12:41.930
drei Gauss-Glocken sind, die am nächsten liegen.

01:12:43.490 --> 01:12:48.130
Und wenn ich das so mache, am Ende kann ich eine Gauss-Mixtur

01:12:48.130 --> 01:12:52.110
Ausrechnung oder den Logarithmus einer Gauss-Mixtur ganz einfach

01:12:52.110 --> 01:12:54.170
dadurch approximieren, dass ich quantisiere.

01:12:54.450 --> 01:12:58.270
Meine Referenzvektoren sind also die Mittelwertsvektoren meiner

01:12:58.270 --> 01:12:59.630
einzelnen Gauss-Glocken.

01:12:59.630 --> 01:13:02.510
Die Distanzmaße sind halt die Mandalobes-Distanz.

01:13:02.870 --> 01:13:07.790
Das heißt, ich quantisiere jetzt auch auf eine Gauss-Glocke hin, führe

01:13:07.790 --> 01:13:11.310
eine ganz einfache Quantisierung durch und dann die Mandalobes

01:13:11.310 --> 01:13:14.150
-Distanz, die bei der Quantisierung noch so nebenbei abfällt, ist dann

01:13:14.150 --> 01:13:16.610
gleichzeitig auch noch der Wert, der aus der Gauss-Mixtur mit

01:13:16.610 --> 01:13:17.030
rauskommt.

01:13:18.070 --> 01:13:20.610
Und damit habe ich dann beide Verfahren sozusagen miteinander

01:13:20.610 --> 01:13:21.270
fusioniert.

01:13:29.070 --> 01:13:30.510
Da habe ich das Problem mit der Summe.

01:13:30.950 --> 01:13:32.650
Da kann ich den Logarithmus-Trick nicht anwenden.

01:13:33.430 --> 01:13:36.390
Aber ich muss nur noch fünf E-Funktionen ausrechnen statt 32.

01:13:36.790 --> 01:13:38.430
Da habe ich auch schon mal kräftig was gespart.

01:13:42.600 --> 01:13:44.860
Naja, du willst halt, dass dein Fehler geringer ist.

01:13:45.160 --> 01:13:45.760
Wenn ich die fünf

01:13:52.190 --> 01:13:52.590
nächsten...

01:13:52.590 --> 01:13:54.590
Doch, die Gauss-Mixtur ist gegeben.

01:13:55.230 --> 01:13:56.870
Die ist irgendwo vom Himmel gefallen.

01:13:56.930 --> 01:13:57.710
Die habe ich irgendwo geschätzt.

01:13:57.790 --> 01:13:58.990
Das ist meine Gauss-Mixtur-Funktion.

01:14:00.170 --> 01:14:01.430
Die Parameter stehen fest.

01:14:01.530 --> 01:14:02.670
Ich will sie jetzt nur noch ausrechnen.

01:14:02.750 --> 01:14:05.010
Ich will nur noch das Ausrechnen der Gauss-Mixtur-Funktionen wirklich

01:14:05.010 --> 01:14:05.930
schnell machen.

01:14:10.640 --> 01:14:10.640
Genau.

01:14:14.900 --> 01:14:15.220
Nö,

01:14:18.500 --> 01:14:18.940
macht mal nicht.

01:14:19.080 --> 01:14:19.880
Ich will einfach nur den Wert.

01:14:20.140 --> 01:14:21.740
Mich interessiert nicht, wie groß der Fehler ist.

01:14:22.220 --> 01:14:26.020
Mich interessiert nur, dass der Wert, der da rauskommt, das ist das

01:14:26.020 --> 01:14:26.220
Einzige.

01:14:26.280 --> 01:14:27.540
Mich interessiert nicht, wie groß der Fehler ist.

01:14:27.960 --> 01:14:30.820
Ich weiß, dass ich einen Fehler mache, aber mich interessiert nicht,

01:14:30.920 --> 01:14:32.060
wie groß er ist.

01:14:36.740 --> 01:14:36.880
Genau.

01:14:39.780 --> 01:14:40.660
Nimmt mal mehr hinzu.

01:14:40.840 --> 01:14:43.120
Kann natürlich dann nicht mehr im logarithmischen rechnen, sondern man

01:14:43.120 --> 01:14:45.060
wird in die E-Funktion ausrechnen müssen.

01:14:45.560 --> 01:14:49.800
Aber ich muss dann nur noch drei E-Funktionen ausrechnen statt 32 E

01:14:49.800 --> 01:14:50.280
-Funktionen.

01:14:50.300 --> 01:14:52.800
Statt k E-Funktionen, wie es in der Gauss-Mixtur gibt.

01:14:53.600 --> 01:14:54.760
Okay, machen wir Schluss für heute.

