├── .gitignore ├── download-images.sh ├── image-sources.txt ├── .github └── workflows │ └── build-pdfs.yaml ├── LICENSE ├── README.md ├── template.typ ├── chap1.typ ├── chap3.typ ├── chap2.typ ├── chap5.typ └── chap4.typ /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | .vscode 3 | slides/* 4 | images/* 5 | *.pdf -------------------------------------------------------------------------------- /download-images.sh: -------------------------------------------------------------------------------- 1 | #! /usr/bin/env bash 2 | mkdir -p ./images 3 | xargs -P 10 -a image-sources.txt -L1 bash -c 'wget -t 10 $1 -O images/$0' 4 | -------------------------------------------------------------------------------- /image-sources.txt: -------------------------------------------------------------------------------- 1 | lambda_complexity.png https://i.sstatic.net/1d8XV.png https://stats.stackexchange.com/questions/118712/why-does-ridge-estimate-become-better-than-ols-by-adding-a-constant-to-the-diago 2 | -------------------------------------------------------------------------------- /.github/workflows/build-pdfs.yaml: -------------------------------------------------------------------------------- 1 | name: build documents 2 | on: 3 | push: 4 | branches: main 5 | 6 | jobs: 7 | build: 8 | runs-on: ubuntu-latest 9 | steps: 10 | - uses: actions/checkout@v4 11 | - uses: typst-community/setup-typst@v4 12 | 13 | - name: get images 14 | run: | 15 | ./download-images.sh 16 | 17 | - name: build pdfs 18 | run: | 19 | typst c chap1.typ 20 | typst c chap2.typ 21 | typst c chap3.typ 22 | typst c chap4.typ 23 | typst c chap5.typ 24 | 25 | - name: upload pdfs 26 | uses: actions/upload-artifact@v4 27 | # always upload, even if building fails 28 | if: "success() || failure()" 29 | with: 30 | name: promi-pdfs 31 | path: "*.pdf" 32 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2024 - present Andreas B. 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Ausarbeitungen des Moduls ProMI 2 | 3 | Vorlesungsinhalte des Moduls ProMI (Probabilistische Methoden der Informatik) ausgearbeitet und mit mehr Kontext eingeordnet um die Verständlichkeit des Inhalts zu steigern. 4 | 5 | In Zukunft sollen die Kapitel auch noch mit Graphen ergänzt und weiter verdeutlicht werden. Da Typst meines erachtens aktuell keine ordentlichen packages für Graphen hat wird sich hier wahrscheinlich eher die Generierung via Python und matplotlib eignen. 6 | 7 | #### Vorgebaute PDFs 8 | 9 | Mit jedem Commit auf `main` werden automatisch PDFs gebaut, diese sind bei den [Action-Runs](https://github.com/fussballandy/promi-2425/actions) zu finden. Einfach auf den letzten Run clicken und die Artefakte herunterladen, in der Zip-Datei sind die Dokumente. 10 | 11 | #### Hinweise 12 | 13 | Der Titel "Probabilistischer Untergang meines Lebens" ist rein humorvoll aufzufassen. 14 | 15 | #### Bauen 16 | 17 | Um eventuell benötigte Bilder in das `images/`-Verzeichnis herunterzuladen, kann das Skript [`download-images.sh`](download-images.sh) genutzt werden. 18 | Die Bilder sind in der Datei [`image-sources.txt`](image-sources.txt) festgehalten, nach folgendem Schema: 19 | ``` 20 | 21 | ``` 22 | -------------------------------------------------------------------------------- /template.typ: -------------------------------------------------------------------------------- 1 | #import "@preview/showybox:2.0.3": showybox 2 | 3 | #let book-template( 4 | chapter: 1, 5 | version: "1.0", 6 | body 7 | ) = { 8 | set document( 9 | title: [Kapitel #chapter -- Probabilistischer Untergang meines Lebens], 10 | author: "Andreas" 11 | ) 12 | 13 | set page( 14 | margin: ( 15 | top: 15mm, 16 | left: 15mm, 17 | right: 15mm, 18 | bottom: 20mm 19 | ), 20 | header: [ 21 | #set align(right) 22 | Kapitel #chapter -- Version #version 23 | ], 24 | numbering: "1", 25 | number-align: right 26 | ) 27 | 28 | set par(justify: true) 29 | set text(font: "New Computer Modern", size: 10pt, lang: "de") 30 | show math.equation: set text(font: "New Computer Modern Math", size: 1.1em) 31 | set list(marker: [--]) 32 | 33 | body 34 | 35 | v(1fr) 36 | 37 | box[ 38 | #set text(weight: "bold") 39 | Bei Fragen, Fehlern, Verbesserungen oder weiterem \ 40 | gerne entweder in Discord melden oder auf 41 | #link("https://github.com/FussballAndy/promi-2425")[#text("GitHub", fill: blue.lighten(20%))] ein Issue erstellen. 42 | 43 | Literaturempfehlungen 44 | #set text(weight: "regular") 45 | - Chris Piech sein Skript zu einer vergleichbaren Veranstaltung an 46 | Stanford: \ 47 | https://chrispiech.github.io/probabilityForComputerScientists/en/ProbabilityForComputerScientists.pdf \ 48 | Bzw. der dazugehörige Online Reader: \ 49 | https://chrispiech.github.io/probabilityForComputerScientists/en/ 50 | - C. M. Bishop: Pattern Recoginition and Machine Learning \ 51 | https://www.microsoft.com/en-us/research/uploads/prod/2006/01/Bishop-Pattern-Recognition-and-Machine-Learning-2006.pdf 52 | ] 53 | } 54 | 55 | #let definition(title, body) = { 56 | showybox( 57 | title: title, 58 | body 59 | ) 60 | } 61 | 62 | #let note(body) = [ 63 | #set text(size: .8em) 64 | *Hinweis:* #body 65 | ] 66 | 67 | #let notation-table(body) = { 68 | set table(stroke: (_,y) => { 69 | ( 70 | top: if y == 1 { 71 | 1pt + gray 72 | } else if y > 1 { 73 | 0.5pt + gray 74 | } 75 | ) 76 | }) 77 | show table.cell.where(y: 0): set text(weight: "bold") 78 | body 79 | } 80 | 81 | #let dangerous(body) = [ 82 | #set text(size: .8em) 83 | #emoji.warning *Ggf. falsch:* #body 84 | ] 85 | 86 | #let digression(title, breakable: true, body) = block( 87 | stroke: 1pt + black, 88 | inset: 5pt, 89 | width: 100%, 90 | breakable: breakable)[ 91 | *Exkurs*: #title \ 92 | #body 93 | ] 94 | 95 | #let variance = math.bb("V") 96 | #let expect = math.bb("E") 97 | 98 | #let Cov = math.op("Cov") 99 | #let Corr = math.op("Corr") 100 | #let Skew = math.op("Skew") 101 | #let Kurt = math.op("Kurt") -------------------------------------------------------------------------------- /chap1.typ: -------------------------------------------------------------------------------- 1 | #import "@preview/showybox:2.0.3": showybox 2 | #import "template.typ": * 3 | 4 | #show: book-template.with( 5 | chapter: 1, 6 | version: "1.0", 7 | ) 8 | 9 | = Grundlagen 10 | 11 | == Begriffe 12 | 13 | 14 | #notation-table(table( 15 | columns: (auto, 1fr), 16 | table.header([Name], [Bedeutung]), 17 | [Ergebnisraum \ (engl. Sample Spaces)], 18 | [Eine Menge $cal(X)$ aller möglichen Ergebnisse.\ 19 | Bsp. Münzwurf: $cal(X) = {"Heads", "Tails"}$], 20 | [Ereignis \ (engl. Event)], 21 | [Eine Menge $E$ an Ergebnissen, die im Ergebnisraum möglich sind. 22 | Entsprechend eine Teilmenge des Ergebnisraum. \ 23 | Bsp. Münze landet auf Kopf: $E = {"Tails"}$], 24 | [Zufallsvariable \ (engl. Random Variable)], 25 | [Eine Variable, deren Wert durch Zufall bestimmt wird, da z.B. ihr Wert noch 26 | unbekannt ist. \ 27 | Wir nennen eine Zufallsvariable _diskret_ (engl. _discrete_), wenn der 28 | Ergebnisraum endlich ist, und _stetig_ (engl. _continuous_), wenn der 29 | Ergebnisraum unendlich ist.] 30 | )) 31 | 32 | *Wahrscheinlichkeit* 33 | 34 | Mit der "Funktion" $P$ können wir die Wahrscheinlichkeit eines Events bestimmen. 35 | So schreiben wir z.B. $P(E)$ für die Wahrscheinlichkeit, dass $E$ eintritt. 36 | Ähnlich schreiben wir $P(X=x)$ für die Wahrscheinlichkeit, dass die 37 | Zufallsvariable $X$ den Wert $x$ annimmt. 38 | 39 | *Wahrscheinlichkeits Axiome* 40 | + Wahrscheinlichkeit ist nicht negativ: $P(E) >= 0$ 41 | + Wahrscheinlichkeit des Ergebnisraum ist 1: $P(cal(X)) = 1$ 42 | + Für die Wsk. von zwei Ereignissen $E$, $F$ gilt: 43 | $P(E union F) = P(E) + P(F) - P(E sect F)$. Für Ereignisse ohne 44 | Gemeinsamkeiten ist $P(E sect F)=0$. Daher ist für diese die Wsk. einfach die 45 | Summe der einzelnen Wsk. 46 | 47 | Des weiteren gilt: $P(overline(E)) = 1 - P(E)$. 48 | 49 | == Funktionen 50 | 51 | #grid( 52 | columns: (48%, 48%), 53 | column-gutter: 1fr, 54 | definition("Probability Mass Function (PMF)")[ 55 | Die *PMF* ist eine Funktion $p: cal(X) -> [0,1]$, die die Wsk. angibt, 56 | dass eine diskrete Zufallsvariable $X$ einen Wert $x$ annimmt. 57 | $ p(x)=P(X=x) $ 58 | Dabei ist $sum_(x in cal(X)) p(x)=1$ 59 | ], 60 | definition("Probability Density Function (PDF)")[ 61 | Die *PDF* ist eine Funktion $f: cal(X) -> bb(R)_(>=0)$, die die Wsk. 62 | angibt, dass eine stetige Zufallsvariable $X$ nahe einem Wert $x$ ist. 63 | 64 | Dabei ist $integral_(x in cal(X)) f(x) dif x=1$ 65 | 66 | #note[ 67 | In der Vorlesung wurde die PDF mit Symbol $p$ eingeführt. Es scheint 68 | allerdings (auch auf Jans Folien) üblicher zu sein diese mit $f$ zu 69 | bezeichnen. In den weiteren Kapiteln wird allerdings eher wieder $p$ 70 | genutzt. 71 | ] 72 | ] 73 | ) 74 | 75 | #definition("Cumulative Distribution Function (CDF)")[ 76 | Die *CDF* ist eine Funktion $F: bb(R) -> [0,1]$, die die Wsk. angibt, 77 | dass eine Zufallsvariable $X$ einen Wert kleiner oder gleich $x$ annimmt. 78 | $ F(x) = P(X <= x) = integral_(-infinity)^(x) p(x') dif x' $ 79 | Dabei ist $F(-infinity)=0$ und $F(+infinity)=1$ 80 | 81 | Gemäß Folien schreibt man auch gelegentlich $F_X$ um die Zufallsvariable $X$ 82 | zu verdeutlichen. 83 | 84 | Des weiteren gilt: $ f(x) = (dif F_X) / (dif x) (x)$ 85 | ] 86 | 87 | == Verteilungen (engl. Distributions) 88 | 89 | Bevor wir uns einzelne Verteilungen anschauen, gilt es erstmal den Begriff der 90 | Verteilung zu klären: \ 91 | Eine Verteilung beschreibt die Wahrscheinlichkeit, mit welcher eine 92 | Zufallsvariable gewisse Werte annimmt. Sowohl die Wahrscheinlichkeit, als auch 93 | die Werte, hängen dabei stark vom Kontext ab. \ 94 | Des weiteren schreiben wir $X ~ D$, wobei $D$ eine Verteilung ist (mehr dazu 95 | gleich), um zu sagen, dass die Variable $X$ eine entsprechende Verteilung hat. 96 | 97 | #definition("Gleichverteilung (engl. Uniform Distribution)")[ 98 | Eine stetige Zufallsvariable $X$ hat eine *Gleichverteilung* $X ~ U(a,b)$, 99 | falls die Wsk., dass $X$ einen Wert $x in [a,b]$ animmt für alle $x$ gleich 100 | ist und für alle anderen $x in.not [a,b]$ 0 ist. 101 | 102 | Die PDF ist entsprechend wie folgt definiert: 103 | $ f(x) = cases( 104 | 1/(b-a) quad &"for" a <= x <= b \ 105 | 0 &"otherwise" 106 | ) $ 107 | ] 108 | 109 | #definition("Categorical Distribution")[ 110 | #quote(block: true, attribution: [Chris Piech])[ 111 | The Categorical Distribution is a fancy name for random variables which 112 | takes on values *_other than numbers_* 113 | ] 114 | Entsprechend hat eine diskrete Zufallsvariable $X$ eine *Categorical 115 | Distribution*, wenn es $K$ mögliche Kategorien gibt ($K$ ist endlich), wobei 116 | jede dieser Kategorien eine eigene Wsk. $p_i$ hat. 117 | 118 | Die PMF ist entsprechend wie folgt definiert: \ 119 | $ p(i)=P(X=i)=p_i "für alle" i in {1,2,...,K} "mit" sum_(i=1)^(K) p_i = 1 $ 120 | 121 | 122 | #align(center,{ 123 | table( 124 | stroke: 0.2pt + black, 125 | columns: 3, 126 | table.header([Category], $x$, $p(x)$), 127 | [Even], $0$, $0.5$, 128 | [Odd], $1$, $0.5$ 129 | ) 130 | }) 131 | 132 | #note[Im deutschen scheint diese Art der Verteilung nicht gerade geläufig zu 133 | sein.] 134 | ] 135 | 136 | == Verknüpfungen von Wahrscheinlichkeiten 137 | 138 | #notation-table(table( 139 | columns: (auto, auto, 1fr), 140 | table.header([Name], [Notation], [Bedeutung]), 141 | [Konjunktion, \ "Verundung", \ Schnitt], [$X Y$, \ $X "and" Y$, \ $X sect 142 | Y$], [Die Konjunktion von zwei Ereignissen ist ein Ereignis, dass auftritt, 143 | wenn beide Ereignisse auftreten. Zur Notation ist zu beachten, dass im Rahmen 144 | von Wsk.-Funktionen oft auch $P(X,Y)$ für die Konjunktion von $X$ und $Y$ 145 | geschrieben wird. ], 146 | [Disjunktion, \ "Veroderung", \ Vereinigung], [$X+Y$, \ $X "or" Y$, \ $X 147 | union Y$], [Die Disjunktion von zwei Ereignissen ist ein Ereignis, dass 148 | auftritt, wenn mind. eins von beiden Ereignissen auftritt.], 149 | [Konditionelle Wsk.\ Conditional Prob.], [$X | Y$], [Die Konditionelle Wsk. 150 | von zwei Ereignissen ist die Wsk., dass $X$ auftritt, sofern $Y$ bereits 151 | aufgetreten ist. \ 152 | #note[An sich ist $P(X|Y)$ die konditionelle Wsk. Da es allerdings zu den 153 | Verknüpfungen passt habe ich die konditionelle Verknüpfung zweier Ereignisse 154 | hier bereits aufgenommen.]] 155 | )) 156 | 157 | Hierbei bindet die Konjunktion (zumindest in der Schreibweise $X,Y$) mehr als 158 | die konditionelle Wsk. D.h., dass $X,Y | Z$ für $(X,Y) | Z$ steht und nicht $X, 159 | (Y | Z)$. Zu den weiteren Präszedenzen kann ich aktuell keine Aussage treffen. 160 | 161 | Dazu ist zu beachten, dass Jan in seinen Folien meist die PMF/PDF mit 162 | eingesetzten Variablen nutzt. Also z.B. $p(x,y)$. Dies ist eine 163 | kurzschreibweise für $P(X=x,Y=y)$. \ 164 | Generell wird im folgenden bei der Nutzung von PMF/PDF meist mit $x$, $y$, etc. 165 | auf unterschiedliche Zufallsvariablen $X$, $Y$, etc. abgezielt. Heißt 166 | $p(x)=P(X=x)$, aber $p(y)=P(Y=y)$ und nicht $P(X=y)$. 167 | 168 | == Verhältnisse von Variablen 169 | 170 | #definition("Unabhängigkeit (Independence)")[ 171 | Zwei Zufallsvariablen $X$, $Y$ sind *unabhängig*, wenn die Wahrscheinlichkeit, 172 | dass die Werte $x$, $y$ angenommen werden, nur von den jeweiligen 173 | Wahrscheinlichkeiten, dass $X=x$ und $Y=y$ eintritt, abhängig ist. \ 174 | D.h. 175 | $ p(x,y)=p(x)p(y) $ 176 | Sofern dies nicht gilt sind $X$ und $Y$ abhängig. 177 | ] 178 | 179 | #definition("Konditionale Unabhängigkeit (Conditionally Independent)")[ 180 | Zwei Zufallsvariablen $X$, $Y$ sind *konditional unabhängig* gegeben einer 181 | dritten Zufallsvariable $Z$, wenn die Wsk. für $X=x$ und $Y=y$ gegeben 182 | $Z=z$ unabhängig sind. \ 183 | D.h. 184 | $ p(x,y | z) = p(x | z) p(y | z) $ 185 | ] 186 | 187 | == Arten von Wsk. 188 | 189 | #definition("Joint Probability")[ 190 | Die *joint probability* ist die Wsk., dass zwei Zufallsvariablen $X$, $Y$ 191 | bestimmte Werte $x$, $y$ annehmen -- Also quasi die Wsk. der Konjunktion 192 | von $X=x$ und $Y=y$. \ 193 | Für diskrete Variablen ist die PMF dabei: 194 | $ p(x,y) = p(x) p(y | x) = p(y) p(x | y) $ 195 | Für stetige Variablen ist die PDF erstmal analog, kann aber mit der CDF $F$ 196 | verknüpft werden: 197 | $ f(x,y) = f(x) f(y | x) = f(y) f(x | y) = (diff^2)/(diff x diff y) F(x,y) $ 198 | 199 | Man beachte, dass für unabhängige Variablen diese Wsk. genau wieder die 200 | Formel $p(x,y)=p(x)p(y)$ wiedergibt, da $p(y | x)$ bei unabhängigkeit 201 | gleich $p(y)$ ist. 202 | 203 | #note[Die deutsche Übersetzung hierfür wäre "Multivariat". Da dieses Wort 204 | sehr ungewöhnlich ist, wurde die deutsche Übersetzung hier weggelassen.] 205 | ] 206 | 207 | #definition("Marginal Probability")[ 208 | Die *marginal probability* ist die Wsk., dass eine Zufallsvariable $X$ einen 209 | Wert $x$ annimmt, unabhängig von einer weiteren Zufallsvariable $Y$. Bzw. 210 | anders herum: man hat einen Weg um die Wsk. $p(x,y)$ zu bestimmen, will aber 211 | $p(x)$ wissen. 212 | Für diskrete Variablen: 213 | $ p(x) = sum_(y in cal(Y)) p(x,y) = sum_(y in cal(Y)) p(x)p(y | x) $ 214 | Für stetige Variablen: 215 | $ f(x) = integral_(-infinity)^(infinity) f(x,y) dif y $ 216 | 217 | Bei einer konditionalen Unabhängigkeit gilt des weiteren: 218 | $ p(x,y) = sum_(z in cal(Z)) p(x | z) p(y | z) p(z) $ 219 | ] 220 | 221 | == Satz von Bayes (Bayes' Rule / Theorem) 222 | 223 | Mithile des Satz von Bayes kann man die abhängigkeit von Wsk. umdrehen. D.h. man 224 | kann $P(B | A)$ in $P(A | B)$ umwandeln -- zumindest solange man auch $P(A)$ 225 | und $P(B)$ hat. 226 | 227 | tldr: 228 | $ P(A | B) = (P(B | A) P(A)) / P(B) $ 229 | 230 | *Herleitung:* 231 | Aus der konditionalen Wsk. von $A$ und $B$ erhalten wir: 232 | $ P(A | B) = P(A, B) / P(B) quad "und" quad P(B | A) = P(A,B) / P(A) $ 233 | Formt man nun beide Seiten nach $P(A,B)$ um und setzt diese gleich erhält man: 234 | $ P(A | B) P(B) = P(B | A) P(A) $ 235 | Und daraus erhält man schlussendlich den Satz. 236 | 237 | 238 | Hier kann man auch noch das _Law of total probability_ erwähnen: 239 | $P(E) = P(E | F) P(F) + P(E | overline(F)) P(overline(F))$. 240 | == Statistik von Wsk. bzw. Verteilungen 241 | 242 | #definition("Erwartung (Expectation)")[ 243 | Die *Erwartung* / *Erwatungswert* von einer Zufallsvariable $X$ (geschrieben 244 | $expect[X]$) beschreibt den durchschnittlichen Wert, den 245 | die Zufallsvariable annimmt. \ 246 | #grid( 247 | columns: (1fr, 1fr), 248 | [ 249 | Für diskrete Variablen gilt: 250 | $ expect[X] = sum_(x in cal(X)) x p(x) $ 251 | ], [ 252 | Für stetige Variablen gilt: 253 | $ expect[X] = integral_(x in cal(X)) x f(x) dif x $ 254 | ] 255 | ) 256 | Oft schreiben wir auch $mu$ oder $mu_X$ für $bb(E)[X]$ 257 | ] 258 | 259 | #grid( 260 | columns: (48%, 48%), 261 | column-gutter: 1fr, 262 | definition("Varianz (Variance)")[ 263 | Die *Varianz* misst, wie sehr die möglichen Werte einer Zufallsvariable $X$ 264 | ausgebreitet sind bzw. wie weit sich diese strecken. \ 265 | Man berechnet die Varianz wie folgt: 266 | $ variance[X] = expect[(X-expect[X])^2] = expect[X^2] - expect[X]^2 $ 267 | Man beachte, dass die Varianz stets $>= 0$ ist. 268 | ], 269 | definition("Standardabweichung (Standard Deviation)")[ 270 | Die *Standardabweichung* $sigma$ misst hingegen die Varianz um den 271 | Erwartungswert $mu$ herum. 272 | $ sigma=sqrt(variance[X]) $ 273 | Entsprechend ist diese auch wieder $>= 0$. Dazu ist die Standardabweichung 274 | deutlich verbreiteter / wichtiger. 275 | ] 276 | ) 277 | 278 | Eigenschaften von Erwartungswert und Varianz: 279 | + Erwartung ist linear $expect[X+Y] = expect[X] + expect[Y]$ 280 | + $variance[X+c] = variance[X]$ für alle Konstanten $c$ 281 | + $variance[c X] = c^2 variance[X]$ für alle Konstanten $c$ 282 | + $variance[X+Y] = variance[X] + variance[Y]$ für unabhängige $X$, $Y$ 283 | 284 | #definition("Moment")[ 285 | *Momente* sind quantitive Messungen von der Form der Verteilung einer 286 | Zufallsvariable $X$. Was sie aber wirklich aussagen weiß keiner so 287 | genau. 288 | #grid( 289 | columns: 3, 290 | column-gutter: 1em, 291 | [ 292 | n-ter Moment um einen Wert $c$ $ expect[(X-c)^n] $ 293 | ], 294 | [ 295 | n-ter Zentraler Moment um die Erwartung $ expect[(X-mu)^n] $ 296 | ], 297 | [ 298 | n-ter _Standardized_ Moment $ expect[((X-mu)/sigma)^n] $ 299 | ] 300 | ) 301 | ] 302 | 303 | #definition("Schiefe (Skewness)")[ 304 | Die *Schiefe* einer Zufallsvariable $X$ bzw. von deren Verteilung gibt an, wie 305 | asymmetrisch die Verteilung um den Erwartungswert $mu$ herum ist. 306 | $ 307 | "Skew"(X) = expect[((X-mu)/sigma)^3] 308 | $ 309 | Für eine symmetrische Verteilung ist die Schiefe 0. 310 | ] 311 | 312 | #definition("Wölbung (Kurtosis)")[ 313 | Die *Wölbung* einer Zufallsvariable $X$ gibt an, wie sehr die Verteilung bzw. 314 | deren Mitte/Gipfel einer Normalverteilung ähnelt. Speziell im Hinblick auf 315 | wie spitz/flach der Gipfel ist. 316 | $ "Kurt"(X) = expect[((X-mu)/sigma)^4]-3 $ 317 | Entsprechend wegen des Vergleiches mit der Normalverteilung rechnen wir hier 318 | auch minus $3$, was die Höhe des Gipfels der Normalverteilung ist. 319 | ] 320 | 321 | #definition("Covariance")[ 322 | Die *Covariance* misst die Abhängigkeit von zwei Zufallsvariablen. Genauer 323 | wird geguckt, inwiefern die Abweichung von einer Variable zu ihrem 324 | Erwartungswert der Abweichung von einer anderen Variable zu ihrem 325 | Erwartungswert ähnelt. 326 | $ Cov(X,Y) = expect[(X-mu_X)(Y-mu_Y)] = expect[X Y] - mu_X mu_Y $ 327 | Wenn größere Werte von einer Variable mit größeren Werten einer anderen 328 | Variable entsprechen, dann ist die Covariance positiv, andernfalls negativ. 329 | Und wenn beide unabhängig sind ist die Covariance 0 (Umkehrung gilt nicht 330 | unbedingt). \ 331 | Eigenschaften: 332 | + $Cov(X,X)=variance[X]$ 333 | + $Cov(X,Y)=Cov(Y,X)$ 334 | + $Cov(X,c)=0$ für alle Konstanten $c$ 335 | + $variance[X+Y]=variance[X]+variance[Y]+2Cov(X,Y)$ 336 | + $Cov(X+Y,Z+W)=Cov(X,Z)+Cov(X,W)+Cov(Y,Z)+Cov(Y,W)$ 337 | ] 338 | 339 | #definition("Correlation")[ 340 | Die *Correlation* ist die Covariance zweier Variablen genormt nach der Varianz 341 | der beiden Variablen. 342 | $ Corr(X,Y) = Cov(X,Y)/(sigma_X sigma_Y) $ 343 | 344 | Eigenschaften: 345 | + $Corr(X,Y) in [-1,1]$ 346 | + Gemäß $Cov$: $X$, $Y$ unabhängig $=> Corr(X,Y)=0$ 347 | (erneut Umkehrung nicht unbedingt) 348 | ] 349 | 350 | #definition("Median")[ 351 | Wir sagen ein Wert $c$ ist der *Median* einer Zufallsvariable $X$, wenn die 352 | "Masse" links von $c$ gleich der "Masse" rechts von $c$ ist. Der Median teilt 353 | also die Verteilung in zwei gleichmäßige Massen. \ 354 | Mathematisch drückt man das ganze wie folgt aus: 355 | $ c "median" <=> P(X <= c) >= 0.5 "und" P(X >= c) >= 0.5 $ 356 | Bei symmetrischen Verteilungen ist der Erwartungswert auch der Median. 357 | ] 358 | 359 | #definition("Quantile, Perzentile und Quartile")[ 360 | Diese Begriffe bezeichnen die Aufteilung der Verteilung in entsprechend viele 361 | gleichmassige Teile. Also für Quartile in 4 Teile und Perzentile in 100 Teile 362 | etc. 363 | ] 364 | 365 | #definition("Modi (Modes)")[ 366 | *Modi* sind Werte in der Verteilung, die mit hohe Dichte bzw. Wsk. haben. 367 | Anschaulich sind es einfach die Maxima der Verteilung. 368 | ] -------------------------------------------------------------------------------- /chap3.typ: -------------------------------------------------------------------------------- 1 | #import "template.typ": * 2 | 3 | #show: book-template.with( 4 | chapter: 3, 5 | version: "1.0.1", 6 | ) 7 | 8 | = Verteilungen 9 | 10 | Gucken wir uns nun mal weitere Verteilungen an. 11 | 12 | #definition("Bernoulli Verteilung (Bernoulli Distribution)")[ 13 | Eine Zufallsvariable $X$ hat eine *Bernoulli Verteilung* $X ~ "Ber"(p)$, 14 | sofern diese nur zwei mögliche Ausgänge hat. Meist wird dabei einer dieser 15 | beiden Ausgänge als Erfolg bezeichnet und der andere als Misserfolg. Das $p$ 16 | in der Verteilung ist dabei die Wsk., dass der Erfolgszustand angenommen wird, 17 | ist aber im allgemeinen sehr Kontextabhängig. 18 | 19 | Es gilt also: 20 | $ 21 | P(X="'Erfolg'") = p quad P(X="'Misserfolg'") = 1-p 22 | $ 23 | Der Einfachheit halber bezeichnen wir allerdings $"'Erfolg'"$ oft mit $1$ und 24 | $"'Misserfolg'"$ oft mit $0$. 25 | 26 | Die folgenden Eigenschaften gelten für $0 bb(R)$ umwandeln. Sprich $Y=g(X)$. 78 | 79 | Nun ist der allgemeine Ansatz um $f_Y$ und $F_Y$ zu bestimmen, dass man zuerst 80 | die CDF über einen etwas besonderen Weg herleitet und basierend darauf dann 81 | die PDF automatisch als Ableitung erhält. Das ganze sieht dann wie folgt aus: 82 | $ 83 | F_Y (y) = P(Y <= y) = P(g(X) <= y) = P(X in {x | g(x) <= x}) 84 | $ 85 | #sub[$P(X in M)$ steht hierbei für die Wsk., dass der Wert, den $X$ annimmt in 86 | der Menge $M$ ist.] 87 | 88 | Entsprechend erhalten wir dann daraus die PDF: 89 | $ 90 | f_Y (y) = (dif F_Y) / (dif y) (y) 91 | $ 92 | 93 | Ist nun $g$ (strikt) monoton, dann können wir die Umkehrfunktion $g^(-1)$ 94 | aufstellen. Mit dieser können wir dann eine simplere CDF aufstellen: 95 | #grid(columns: (1fr, 1fr), column-gutter: 2em)[ 96 | Für ein monoton _wachsendes_ $g$: 97 | $ 98 | F_Y (y) &= P(g(X) <= y) \ &= P(X <= g^(-1) (y)) \ &= F_X (g^(-1) (y)) 99 | $ 100 | Daraus erhalten wir dann erneut: 101 | $ 102 | f_Y (y) = f_X (g^(-1) (y)) dif / (dif y) g^(-1) (y) 103 | $ 104 | ][ 105 | Für ein monoton _fallendes_ $g$: 106 | $ 107 | F_Y (y) &= P(g(X) <= y) \ &= P(X >= g^(-1) (y)) \ &= 1- F_X (g^(-1) (y)) 108 | $ 109 | Daraus erhalten wir dann erneut: 110 | $ 111 | f_Y (y) = - f_X (g^(-1) (y)) dif / (dif y) g^(-1) (y) 112 | $ 113 | ] 114 | 115 | Die Kombination aus beidem ergibt: 116 | $ 117 | f_Y (y) = f_X (g^(-1) (y)) abs( dif / (dif y) g^(-1) (y) ) 118 | $ 119 | 120 | Für den Erwartungswert einer solch transformierten Variable gilt: 121 | $ 122 | expect[g(X)] = integral_(-infinity)^(infinity) g(x) f_X (x) dif x 123 | $ 124 | 125 | Wie schon eben angesprochen kann man hierdurch nun eben sowas berechnen, wie 126 | $expect[X^2]$, was dann eben zu 127 | $integral_(-infinity)^(infinity) x^2 f_X (x) dif x$ wird. 128 | 129 | == Convolution 130 | 131 | Nun betrachten wir den Fall, dass wir zwei Zufallsvariablen $X$ und $Y$ haben 132 | und zu einer dritten Zufallsvariable $Z = X + Y$ die Verteilung wissen 133 | wollen. Entsprechend müssen eben $X$ und $Y$ auch Zufallsvariablen über 134 | ähnlichen Wertebereichen (hier zusammengefasst als $cal(X)$) sein. 135 | Der allgemeine Ansatz dafür ist die _Convolution_. Diese ist anschaulich ein 136 | Weg um zwei Funktionen flüssig zu verbinden bzw. zu "verschmieren". 137 | $ 138 | f_Z (z) = (f_X * f_Y) (z) 139 | $ 140 | 141 | #grid(columns: (1fr, 1fr), column-gutter: 2em)[ 142 | Für diskrete Wertebereiche gilt: 143 | $ 144 | f_Z (z) = sum_(x in cal(X)) f_X (x) f_Y (z-x) 145 | $ 146 | ][ 147 | Für stetige Wertebereiche gilt: 148 | $ 149 | f_Z (z) = integral_(x in cal(X)) f_X (x) f_Y (z-x) dif x 150 | $ 151 | ] 152 | 153 | == Central Limit Theorem 154 | 155 | Das Central Limit Theorem besagt, dass $n$ unabhängige und gleichmäßig verteilte 156 | Zufallsvariablen $X_1, X_2, ..., X_n$ mit gleichem Erwartungswert 157 | $expect[X_i] = mu$ und gleicher Varianz $variance[X_i] = sigma^2$ aufsummiert 158 | einer Normalverteilung annähern. 159 | 160 | Die Zufallsvariable $S_n$ bezeichnet dabei die Summe von $n$ solcher 161 | Zufallsvariablen. Also $display(S_n = sum_(i=1)^n X_i)$. Des weiteren 162 | bezeichnet die Zufallsvariable $Z_n$ die normalisierte Version dieser 163 | Zufallsvariable: 164 | $ 165 | Z_n = (S_n - expect[S_n]) / sqrt(variance[S_n]) quad "mit" 166 | lim_(n -> infinity) F_Z_n (z) = P(Z_n <= z) 167 | = 1/(2pi) integral_(-infinity)^z e^(-x^2 slash 2) dif x 168 | $ 169 | Der letzte Teil der Formel ist dabei die konkrete CDF einer Normalverteilung 170 | mit Erwartungswert $mu = 0$ und Standardabweichung $sigma^2 = 1$. 171 | 172 | 173 | Im allgemeinen gilt auch für die PDF $f$ einer Normalverteilung 174 | $cal(N)(mu,sigma^2)$: 175 | $ 176 | f(x) = 1/(sigma sqrt(2pi)) exp (-1/2 ((x-mu)/sigma)^2) 177 | $ 178 | 179 | Nun kann es etwas nervig sein immer wieder erwähnen zu müssen, dass eine 180 | Funktion $f$ eine Normalverteilung ist. Entsprechend gibt es die Notation 181 | $cal(N) (x | mu, sigma^2)$ um die Funktion der Normalverteilung mit 182 | entsprechenden Parametern anzugeben. 183 | 184 | Zudem ist der Grenzwert von $Z_n$ für beliebige Zufallsvariablen $X_i$ gleich, 185 | solange eben der Erwartungswert und die Standardabweichung gleich sind und 186 | alle Variablen unabhängig und gleichmäßig verteilt sind. 187 | 188 | == Products and Quotients 189 | 190 | Jan sagt selbst, dass dies wahrscheinlich weniger relevant ist, darum werde ich 191 | das ganze hier auch nicht weiter ausführen. Der Vollständigkeit halber aber 192 | trotzdem noch die PDF vom Produkt/Quotient zweier Zufallsvariablen $X$, $Y$: 193 | 194 | #grid(columns: (1fr, 1fr), column-gutter: 2em)[ 195 | PDF von $Z=X Y$: 196 | $ 197 | f_Z (z) = integral_(x in cal(X)) f_X (x) f_Y (z slash x) 1/abs(x) dif x 198 | $ 199 | ][ 200 | PDF von $U=Y slash X$: 201 | $ 202 | f_U (u) = integral_(x in cal(X)) f_X (x) f_Y (u x) abs(x) dif x 203 | $ 204 | ] 205 | 206 | = Maximum Entropy Distributions 207 | 208 | // TODO: Sehr random reingeworfen und zu wenig ausgeführt. 209 | Ab diesem Punkt ist es ggf. auch einmal ganz hilfreich zu erwähnen, dass die 210 | Begriffe Zufallsvariable und Verteilung oft sehr stark Hand in Hand gehen. 211 | Entsprechend reden wir auch im folgenden über die Entropie einer Verteilung, 212 | obwohl wir diese eigentlich erstmal nur für Zufallsvariablen definiert haben. 213 | (Wobei wir dort eigentlich auch eher die Verteilung $p$ für die konkrete 214 | Berechnung nutzen.) 215 | 216 | Nun betrachten wir den Fall, dass wir die genaue Verteilung nicht wissen. Das 217 | einzige was wir darüber wissen, ist dass diese gewisse Einschränkungen 218 | erfüllt. Nun kann in solch einem Fall eine Vielzahl von verschiedenen 219 | Verteilungen zur Auswahl stehen, die alle jeweils die Einschränkungen erfüllen. 220 | Welche von diesen Verteilungen sollen wir also am besten wählen? 221 | 222 | Laut dem Prinzip der maximalen Entropie (engl. Principle of Maximum Entropy) 223 | wählen wir dann am besten eine Verteilung mit einer möglichst hohen bzw. der 224 | höchsten Entropie. Dadurch soll verhindert werden, dass bereits andere 225 | Informationen in die Verteilung einfließen. Intuitiv ist das auch ein sehr guter 226 | Ansatz. Schließlich wissen wir nichts über die Verteilung und Entropie misst 227 | eben die Ungewissheit einer Verteilung, also kann es durchaus hilfreich sein 228 | eine Verteilung mit maximaler Entropie zu wählen. 229 | 230 | Zur Wiederholung: Die Formel von Entropie für eine stetige Zufallsvariable $X$ 231 | bzw. deren Verteilung $p$ lautet wie folgt: 232 | $ 233 | Eta (p) = - integral p(x) log_2 p(x) dif x 234 | $ 235 | 236 | Nun wollen wir die Verteilung $p$ wissen, für die wir $Eta(p)$ maximal bekommen. 237 | Also 238 | $ 239 | arg max_p Eta (p) = arg max_p - integral p(x) log_2 p(x) dif x quad 240 | "wobei" quad integral_a^b p(x) dif x = 1 241 | $ 242 | Man beachte, dass selbst ohne weitere Einschränkungen trotzdem bereits die 243 | Einschränkung, dass das Integral der übergebenen Funktion 1 ergibt -- diese also 244 | eine valide PDF ist, vorhanden ist. 245 | 246 | #note[$arg$ bezeichnet hierbei das entsprechende Argument des $max$. Genauer 247 | also für welches $p$ eben diese maximale Verteilung angenommen wird. $max$ 248 | allein würde uns nur die höchstmögliche Entropie angeben.] 249 | 250 | Nun wollen wir über einem Intervall $[a,b]$ und ohne weitere Einschränkungen 251 | dieses Prinzip anwenden. Jan nutzt hier auf seinen Folien nun eine interessante 252 | Herleitung, die aber wenig erklärt wurde. Diese zu verstehen würde überhaupt 253 | erstmal ein Verständnis von Lagrangian benötigen. Also fassen wirs kurz, wir 254 | erhalten, dass in solch einem Fall eine Uniforme Distribution mit Wsk. 255 | $p(x) = 1 slash (b-a)$ am besten geeignet ist bzw. am meisten Entropie hat. 256 | 257 | #digression([Wie leitet man so etwas her?])[ 258 | #let Lagrangian = math.cal("L") 259 | Wie bereits erwähnt nutzen wir hier maßgeblich den Lagrangian Multiplier bzw 260 | die Lagrange Funktion. 261 | Diese hilft uns den Maximalwert einer Methode unter gewissen Einschränkungen 262 | zu bestimmen. 263 | 264 | Als Vorbedingung für die Lagrange Funktion brauchen wir dann: 265 | - Eine Funktion $f$, über der wir das Maximum/Minimum bestimmen wollen und 266 | - eine Einschränkung $g$, wobei diese für alle Eingaben, eine konstante $c$ 267 | annehmen soll. Also $g(x)=c$ 268 | Dann sieht die Lagrange Funktion wie folgt aus: 269 | $ 270 | Lagrangian (x,lambda) equiv f(x) + lambda (g(x) - c) 271 | $ 272 | #sub[Man beachte, dass hier erneut sehr viel mehr Input in die "Funktion" 273 | fließt, als nur die eigentlichen Parameter -- wann funktionale Mathematik?] \ 274 | Das $lambda$ ist hierbei der _Lagrange multiplier_. Was das genau ist kann 275 | ich gerade auch nicht sagen. Und ist weiter auch nicht relevant. 276 | 277 | Jan nutzt hierbei nun eine etwas abgewandelte Notation und schreibt $p(x)$ 278 | mit in die "Funktion". Dies ist vermutlich zur Verdeutlichung, dass wir 279 | hierbei eben über der Funktion $p$ maximieren wollen. 280 | 281 | Dazu kommt nun unsere in dem Fall einzige Einschränkung, der _normalization 282 | constraint_ ins Spiel: 283 | $ 284 | g(p) = integral_a^b p(x) dif x 285 | $ 286 | und diese Einschränkung soll eben immer den Wert 1 ergeben. Also $g(p)=1$. 287 | 288 | Wir erhalten also: 289 | $ 290 | Lagrangian (p(x),lambda_0) = - integral_a^b p(x) log_2 p(x) dif x + 291 | lambda (integral_a^b p(x) dif x - 1) 292 | $ 293 | 294 | Leiten wir dies nun nach $p(x)$ ab und berechnen die Nullstellen erhalten wir: 295 | $ 296 | diff / (diff p(x)) (p(x), lambda_0) = - log_2 p(x) - 1 + lambda_0 = 0 \ 297 | =>p(x) = e^(lambda_0 - 1) 298 | $ 299 | #note[Wir nutzen hier $diff$, da $lambda_0$ eben auch ein Parameter ist und 300 | wir somit bei Analysis in mehreren Dimensionen sind.] 301 | 302 | Setzen wir diese Funktion nun in unsere Einschränkung ein erhalten wir: 303 | $ 304 | g(p) = integral_a^b e^(lambda_0 - 1) dif x &= 1 <=> \ 305 | e^(lambda_0 - 1) integral_a^b 1 dif x &= 1 <=> \ 306 | e^(lambda_0 - 1) (b-a) &= 1 <=> \ 307 | e^(lambda_0 - 1) &= 1/(b-a) 308 | $ 309 | 310 | Wir erhalten also $p(x)=1 slash (b-a)$. 311 | 312 | #sub[Ich hoffe mal dieser Crash Kurs hat einigermaßen geholfen.] 313 | ] 314 | 315 | Dies kann man nun mal mit einigen Constaints durchspielen und dann erhält 316 | man die Tabelle auf Seite 51. (Hab ich jetzt hier nicht abgetippt weil zu viel.) 317 | _Support_ bezeichnet dabei wahrscheinlich noch den Bereich, auf dem diese 318 | Verteilung gültig ist. 319 | 320 | Jan erwähnt hier noch Minimum Relative Entropy. Die Idee hier ist die 321 | nächstbeste Verteilung $p$ zu einer Verteilung $q$ zu finden, die gewisse 322 | Einschränkungen erfüllt. Dafür wird dann die KL-Divergenz aus Kapitel 2 323 | genutzt. Genauer werde ich darauf jetzt allerdings nicht eingehen. 324 | 325 | = Mixture Distributions 326 | 327 | Die Inspiration hierfür: Wir haben nun 5 verschiedene Normalverteilugen 328 | $p_k (x) = cal(N) (x | mu_k, sigma_k^2)$ für $k=1,2,...,5$. Nun wollen wir eine 329 | Verteilung $p(x)$ haben, die all diese Verteilungen zu einer einzigen Verteilung 330 | vereint. 331 | 332 | Im allgemeinen geht das, indem man einen "gewichteten Mittelwert" aus den 333 | Verteilungen nimmt. Oder auf gut deutsch: aufsummieren und mit Gewichten 334 | #sym.lt.eq 1 multiplizieren. \ 335 | Also: Für Verteilungen $p_0 (x|theta_0),p_1 (x|theta_1),...,p_K (x|theta_K)$ 336 | (ignoriert bis Kapitel 4 einfach das "$| theta_i$") ergibt sich 337 | dann folgende _Mixture Distribution_: 338 | $ 339 | p(x) = sum_(k=1)^K pi_k p_k (x | theta_k) quad "wobei" quad 340 | sum_(k=1)^K pi_k = 1 quad "und" quad 0 <= pi_k <= 1 341 | $ 342 | #note[An sich muss es nichtmal unbedingt eine Summe sein, sondern kann jegliche 343 | _konvexe_ Verknüpfung dieser Verteilungen sein.] 344 | 345 | Hierzu betrachten wir noch _latent varaibles_. Dies sind Variablen, die nicht 346 | direkt gemessen werden können, sondern die man erst nach Evaluation mehrerer 347 | Messwerte konkret feststellen kann. Wikipedia nennt dazu ein recht schönes 348 | Beispiel: 349 | #quote(block: true, attribution: 350 | link("https://de.wikipedia.org/wiki/Latentes_Variablenmodell", 351 | underline("Wikipedia")))[ 352 | Ein Beispiel für eine latente Variable ist die Intelligenz. Sie kann nicht 353 | direkt gemessen werden, aber aus einer Vielzahl von Testergebnissen ([den 354 | beobachtbaren Datenpunkten]) können eine oder mehrere hinter den 355 | Testergebnissen liegende latente Variablen (Intelligenz) extrahiert werden. 356 | ] 357 | Im Beispiel von unserer mixture distribution wäre eben die Gewichtung eine 358 | solche Variable. Wenn wir nur einen Datenpunkt betrachten können wir nicht 359 | direkt sagen, welche Gewichte die einzelnen Verteilungen haben, sondern erst 360 | wenn man viele Datenpunkte betrachtet. 361 | 362 | = Kernel Density Estimation 363 | 364 | Zuletzt kommt noch ein Weg um eine PDF aus einer Menge an Datenpunkten 365 | $D = {x_1,x_2,...,x_N}$ herleiten zu können. 366 | 367 | Ein Ansatz wäre es nun erst einmal entsprechende PDF $p_k (x)$ mit einer 368 | Normalverteilung $cal(N) (x_k | mu, sigma^2)$ aufzustellen. Dann kann man aus 369 | diesen PDF eine Mixture Distribution bilden, wobei alle Gewichte $1/N$ sind: 370 | $ 371 | f(x) = 1/N sum_(k=1)^N p_k (x) 372 | $ 373 | 374 | Dies kann man nun mit einem _density kernel_ $cal(K)$ verallgemeinern. 375 | Für diesen gilt: 376 | $ 377 | cal(K): bb(R) -> bb(R)_+ quad integral cal(K) (x) dif x = 1 quad cal(K) (x) 378 | = cal(K) (-x) 379 | $ 380 | 381 | Dazu nehmen wir noch eine Bandbreite (engl. bandwidth) $h$, welche die breite 382 | des Kernels kontrolliert, bzw. bildlich die Funktion glatter macht: 383 | $ 384 | f(x) = 1 / (N h) sum_(k=1)^N cal(K) ((x - x_k) / h) 385 | $ 386 | 387 | #line(length: 100%) 388 | 389 | *Changelog*: 390 | - 1.0 #sym.arrow.r 1.0.1: Fix von Rechtschreibfehlern -------------------------------------------------------------------------------- /chap2.typ: -------------------------------------------------------------------------------- 1 | #import "template.typ": * 2 | #import "@preview/fletcher:0.5.5" as fletcher: diagram, node, edge 3 | 4 | #show: book-template.with( 5 | chapter: 2, 6 | version: "1.0.1", 7 | ) 8 | 9 | #let source = math.accent("X", math.macron) 10 | #let channel = math.accent("K", math.macron) 11 | 12 | = Information 13 | 14 | Zuerst einmal sollte man klären, was Information überhaupt ist. In der 15 | Informationstheorie (engl. Information Theory) bezeichnet Information das 16 | Wissen, welches ein Absender durch einen Informationskanal an einen Empfänger 17 | vermittelt. Dazu ist es noch wichtig zu erwähnen, das Information und Daten 18 | nicht das gleiche sind. 19 | 20 | Die Informationstheorie beschäftigt sich stark mit der Übertragung, 21 | Verarbeitung, Extrahierung und Verwertung von Informationen. Sie wurde stark 22 | von Claude Shannon vorangetrieben. Denn dieser hat vor allem Bits als Einheit 23 | gewählt, wodurch seine Arbeit gut auf heutige Rechnersysteme übertragbar ist. 24 | 25 | Eben wurde bereits der Informationskanal (engl. Information Channel) erwähnt, 26 | hier eine Beschreibung des Aufbau: 27 | - Daten fließen von einem Sender zu einem Empfänger 28 | - Der Sender kodiert die Nachricht 29 | - Die Nachricht fließt durch einen störenden Kanal, der ggf. unreinheiten in die 30 | Nachricht bringt 31 | - Der Empfänger erhält die Nachricht und dekodiert diese. Daraus kann er dann 32 | informationen basierend auf der Nachricht erhalten. 33 | 34 | #align( 35 | center, 36 | diagram( 37 | node-stroke: 1pt, 38 | edge-stroke: 1pt, 39 | spacing: 5em, 40 | node((0,0), [Sender], height: 3em), 41 | edge("-|>"), 42 | node((1,0), [Kodierer], height: 3em), 43 | edge("-|>"), 44 | node((2,0), [(störender) \ Kanal], height: 3em), 45 | edge("-|>"), 46 | node((3,0), [Dekodierer], height: 3em), 47 | edge("-|>"), 48 | node((4,0), [Empfänger], height: 3em) 49 | ) 50 | ) 51 | 52 | Was uns aber vor allem auch in der Informationstheorie interessiert ist der 53 | Aspekt der Überraschung (engl. Surprise). Dies ist auch maßgeblich unsere 54 | Definition von Information bzw. $I(x)$. \ 55 | Weniger wahrscheinliche Ereignisse sind überraschender. Entsprechend hat man 56 | auch mehr Information, wenn die Überraschung größer ist. 57 | 58 | Wenn man nun zwei Nachrichten vergleicht: 59 | + The program terminated due to an error 60 | + The program terminated with Error Code 3 61 | Dann kann man sich ableiten, dass die 2. Nachricht mehr Informationen enthält, 62 | da sie weniger zu erwarten war. Für die Erwartung spielt es hier demnach auch 63 | eine Rolle, wie divers die Nachricht sein kann. Im Falle von Nachricht 1 gibt 64 | es nur 2 Möglichkeiten: Fehler und kein Fehler. Hingegen in Nachricht 2 gibt es 65 | deutlich mehr Möglichkeiten: Error 0, 1, 2, .... Da also die Nachricht 66 | "Error Code 3" unerwartbarer war, enthält diese entsprechend mehr Information. 67 | 68 | Kommen wir also nun konkret zur Bestimmung von Information: 69 | 70 | #definition("Absender (Information Source)")[ 71 | Ein *Absender* #source ist ein Tupel $(cal(X), p)$, wobei 72 | $cal(X)$ die Menge der möglichen Nachrichten ist und $p:cal(X)->bb(R)$ 73 | eine Funktion, die die Wsk. angibt, dass eine Nachricht $x in cal(X)$ 74 | gesendet wurde. 75 | 76 | Ist $x$ eine Nachricht mit einer Wsk. $p(x)>0$, dann ist die Information, die 77 | $x$ beinhaltet: 78 | $ I(x) = log 1/p(x) = -log p(x) $ 79 | 80 | Zudem nennt man einen Absender _stationary_, wenn $cal(X) != emptyset$, 81 | $forall x in cal(X): p(x)>0$ und $display(sum_(x in X) p(x))=1$ gilt. 82 | 83 | #dangerous[Information scheint nicht direkt nur zur konkreten Messung von 84 | Informationen einer Nachricht zu sein, sondern viel mehr auch eine Bestimmung 85 | einer möglichen Kodierung einer Nachricht. Entsprechend ist die Einheit von 86 | Information auch Bits] 87 | 88 | #note[Das $p$ hier ist semi zusammenhängend mit der PMF, die in Kapitel 1 89 | vorgestellt wurde. Man kann es wieder als die PMF sehen und damit eine 90 | Zufallsvariable $X$ als eine zu erhaltende Nachricht ansehen, wobei man die 91 | Wsk. 92 | herausfinden will, dass diese die Nachricht $x$ ist. Außerdem wird für den 93 | Logarithmus -- speziell im Kontext von Shannon -- meist die Basis 2 94 | verwendet. 95 | Eine genaue festlegung muss dort aber laut meiner Kenntnis nicht getroffen 96 | werden.] 97 | ] 98 | 99 | // box, da sonst blödes page breaking. Ggf. bei neuem layout zu block 100 | #digression([Warum der Logarithmus], breakable: false)[ 101 | Man fragt sich nun vielleicht, warum hier der Logarithmus genutzt wurde und 102 | nicht einfach nur $1 \/ p(x)$. \ 103 | Das erste Problem wäre, dass die Information einer Nachricht die immer 104 | auftritt ($p(x)=1$) dann $1 slash 1 = 1$ wäre, diese Nachricht aber 105 | eigentlich 106 | gar keine Information enthält. Des weiteren hat Shannon Information genutzt 107 | um 108 | die Anzahl an Bits zu berechnen, die benötigt werden, um eine Nachricht $x$ 109 | zu 110 | kodieren. Das Ziel dabei ist häufigere Nachrichten mit weniger Bits zu 111 | kodieren und seltenere Nachrichten mit mehr Bits. 112 | 113 | Eine nun berechtige Frage ist: Warum sollte ich gewisse Nachrichten kürzer 114 | kodieren wollen als andere? Man kann ja schließlich einfach die Anzahl der 115 | Nachrichten $n=|cal(X)|$ nehmen, dann den Logarithmus davon nehmen 116 | $b = log_2 n$. Dann hat man auch eine Anzahl an Bits, mit der man sogar jede 117 | Nachricht aus $cal(X)$ kodieren kann. (Natürlich noch angepasst auf Bytes da 118 | kein Rechner heutzutage ordentlich mit Bits arbeitet). 119 | Jeder der nun InfMan gehört hat sollte aber ein recht alltägliches 120 | Gegenbeispiel kennen wo das nicht so ist: Die Kodierung von Texten, speziell 121 | z.B. UTF-8. \ 122 | Zur Aufklärung: In UTF-8 besteht ein Text erstmal aus einer Liste an Byte 123 | (8 Bits). Da man aber in einem Byte nur 256 Zeichen kodieren könnte werden 124 | für 125 | _seltenere_ Zeichen entsprechend mehr Byte zur Kodierung genutzt. So kann ein 126 | einzelnes Zeichen in UTF-8 1-4 Byte groß sein. Und welche Zeichen sind nun nur 127 | mit einem Byte kodiert? Eben die, die bei uns im Alltag am häufigsten 128 | vorkommen: a-z,A-Z,0-9,Punktationen etc. Hingegen ein Zeichen wie 'ä', 129 | welches 130 | (zumindest im Englischen) nicht so häufig vorkommt wird mit 2 Byte kodiert. 131 | Das bringt eben den Vorteil, dass viele Nachrichten dadurch deutlich weniger 132 | Speicher benötigen. Würde man alle Zeichen mit 4 Byte kodieren, würde ein 133 | Text 134 | wie `"Hello world!"` 48 Byte benötigen, während er so nur 12 Byte benötigt. 135 | ] 136 | 137 | Fairerweise ist dieser Exkurs ein wenig ausgeartet. Falls man allerdings noch 138 | etwas mehr zum Verständnis von Information bzw. der Formel dahinter lesen will, 139 | kann ich den folgenden Artikel (oder zumindest die ersten beiden Abschnitte) 140 | sehr empfehlen: 141 | https://randompearls.com/science-and-technology/mathematics/information-theory-rationale-behind-using-logarithm-entropy-and-other-explanations/ 142 | 143 | #definition("Entropie (Entropy)")[ 144 | *Entropie* ist die Messung der Ungewissheit, welche möglichen Werte eine 145 | Zufallsvariable $X$ annehmen kann. Dabei ist sie auch ein Maß für den 146 | erwarteten Informationsgehalt der Nachrichten eines Absenders. 147 | 148 | Für eine diskrete Zufallsvariable $X$ über einer Menge an Nachrichten 149 | $cal(X)={x_1, x_2, ..., x_n}$ eines Absenders #source wie folgt beschreiben: 150 | $ 151 | Eta(X)=sum_(i=1)^n p(x_i) I(x_i) = 152 | sum_(i=1)^n p(x_i) log 1/p(x_i) = 153 | - sum_(i=1)^n p(x_i) log p(x_i) = 154 | expect[I(X)] 155 | $ 156 | 157 | #sub[Fragt bitte nicht warum auf Jans Folie das $n$ auf einmal zu $N$ wird] 158 | 159 | Da sich Entropie maßgeblich aus Information zusammensetzt ist die Einheit 160 | davon wieder Bits. 161 | 162 | #note[$Eta$ IST KEIN GROSSES h SONDERN EIN GROSSES `Eta`] 163 | ] 164 | 165 | #definition("Differential Entropy (kurz: DE)")[ 166 | Die differentielle Entropie erweitert das Konzept von Entropie auf stetige 167 | Zufallsvariablen. Da stetige Zufallsvariablen allerdings andere Eigenschaften 168 | haben wie diskrete Zufallsvariablen gilt hier ein wenig Vorsicht. 169 | (Z.B. kann die PDF $>1$ sein oder aber die DE $<0$) 170 | 171 | Die Entropie einer stetigen Zufallsvariable über einer Menge an Nachrichten 172 | $cal(X)$ lautet also wie folgt: 173 | $ 174 | Eta(X) = integral_(x in cal(X)) f(x) I(x) dif x = 175 | integral_(x in cal(X)) f(x) log 1/f(x) dif x = 176 | - integral_(x in cal(X)) f(x) log f(x) dif x = 177 | expect[I(X)] 178 | $ 179 | 180 | #note[Man beachte, dass im Rahmen von stetigen Zufallsvariablen die 181 | Information an sich auch die PDF nutzen sollte und nicht die PMF. Zudem 182 | scheint man teilweise $h$ als Symbol für die DE zu nutzen] 183 | ] 184 | 185 | Jetzt haben wir uns also der Definition des Absenders, der Kodierung 186 | (Information) und nun durch Entropie dem Empfänger befasst. Nun fehlt noch das 187 | Herzstück von Informationskanälen und das ist der Kanal selbst: 188 | 189 | #definition("Kanal (Channel)")[ 190 | Ein *Kanal* #channel ist ein Tupel $(A,B,q_K)$ wobei 191 | - $A != emptyset$, $B != emptyset$ und 192 | - $q_K: A times B -> [0,1]$ mit $forall a in A: sum_(b in B) q_K(a,b)=1$ \ 193 | 194 | $q_K$ ist dabei die sogenannte _channel transition function_, welche uns die 195 | Wsk. gibt, dass ein Symbol $a$ bei Durchgang durch den Kanal zu einem Symbol 196 | $b$ mutiert. 197 | 198 | Die Aufgabe eines Kanals ist es Nachrichten zu übermitteln, dabei können aber 199 | Fehler auftreten. Wenn in einem Kanal eben solche Fehler auftreten können 200 | nennen wir diesen auch störend (?, engl: noisy). 201 | 202 | #note[Der Begriff _channel transition function_ scheint zumindest laut einer 203 | kurzen Google Suche nicht gerade geläufig zu sein.] 204 | ] 205 | 206 | *Eigenschaften von Kanälen:* 207 | 208 | #notation-table(table( 209 | columns: (auto, 1fr), 210 | table.header([Begriff], [Bedeutung]), 211 | [Binary symmetric channel (BSC)], [Ein BSC ist ein Kanal, in dem jedes 212 | übertragene Bit eine Wsk. von $r$ hat geflippt zu werden ($0->1, 1->0$)], 213 | [Binary erasure channels (BEC)], [Ein BEC ist ein Kanal, in dem jedes 214 | übertragene Bit eine Wsk. von $r$ hat gelöscht zu werden. Der Empfänger 215 | weiß dann, dass ein Bit fehlt, aber nicht welchen Wert dieses hatte.], 216 | [Transinformation], [Die Transinformation misst die Gemeinsamkeit zwischen 217 | dem Eingang $X$ und dem Ausgang $Y$ eines Kanals.], 218 | [Channel Capacity], [Die Kanalkapazität gibt den maximalen Durchsatz an Daten 219 | an, die durch den Kanal mit relativ kleiner Fehler Wsk. übertragen werden 220 | können.] 221 | )) 222 | 223 | = Rechnen mit Information 224 | 225 | #definition("Joint Entropy")[ 226 | Die *Joint Entropy* gibt an, wie viele Bits bzw. Einheiten an Information wir 227 | benötigen, um das Ergebnis von zwei Zufallsvariablen zu kodieren. Dabei gibt 228 | sie dann gleichzeitig auch die Ungewissheit über die Werte der beiden 229 | Variablen an. 230 | 231 | Für zwei Zufallsvariablen $X$, $Y$ über den Mengen $cal(X)$, $cal(Y)$ ist die 232 | Joint Entropy wie folgt definiert: 233 | $ Eta(X,Y) = sum_(x in cal(X)) sum_(y in cal(Y)) p(x,y) log 1/p(x,y) $ 234 | 235 | #note[Jan scheint in seinen Folien $X$ als die Eingangs und $Y$ als die 236 | Ausgangs Nachricht zu bezeichnen. Im allgemeinen scheint man dies aber nicht 237 | direkt so zu klassifizieren. Dies scheint eher im Kontext davon zu sein, dass 238 | Jan dies nutzt um auf die Kanalkapazität hinzuarbeiten.] 239 | ] 240 | 241 | Jan führt hier nun die *Marginal Distribution* ein. Diese ist aber quasi analog 242 | zu Marginal Probability aus Kapitel 1. Daher werde ich hier nicht weiter drauf 243 | eingehen. 244 | 245 | #definition("Mutual Information")[ 246 | *Mutual Information* $I(X;Y)$ misst, wie viel Information sich zwei 247 | Zufallsvariablen $X$ und $Y$ teilen. Entsprechend sagt sie auch aus, wie viel 248 | wir über $X$ wissen, wenn wir den Wert von $Y$ kennen. 249 | 250 | $ 251 | I(X;Y) = Eta(X) + Eta(Y) - Eta(X,Y) = sum_(x in cal(X)) sum_(y in cal(Y)) 252 | p(x,y) log (p(x,y)/(p(x)p(y))) 253 | $ 254 | ] 255 | 256 | 257 | #box[ // Box für layout Gründe 258 | Nachdem wir also diese drei Definitionen hinter uns haben können wir nun zur 259 | Formel für die Kanalkapazität kommen. Hierbei ist nun zu beachten, dass $X$ 260 | der Eingang in den Kanal und $Y$ der Ausgang aus dem Kanal ist: 261 | $ 262 | C = max_p(x) I(X;Y) = Eta(Y) - Eta(Y|X) 263 | $ 264 | Der Grund warum wir hier $display(max_p(x))$ schreiben, ist dass wir das Maximum 265 | von $I(X;Y)$ über allen möglichen Werten $p(x)$ bzw. allen möglichen 266 | Verteilungen bekommen wollen. 267 | ] 268 | 269 | = Kodierungsstrategien 270 | 271 | #definition("Block Coding")[ 272 | Bei der *Block Kodierung* wird die Nachricht in Blöcke mit fester Größe 273 | kodiert. Dadurch kann die Fehlererkennung und Korrektur vereinfacht werden, da 274 | man redundante Informationen hinzufügen kann. 275 | 276 | *Kodierung:* Jeder Block mit $k$ Informations Bits wird in einen Block mit $n$ 277 | Bits umgewandelt, wobei $n > k$. 278 | 279 | *Informationsrate (Code Rate):* $R=k/n$. Höhere Redundanz -- entsprechend 280 | kleineres $R$ -- verbessert die Fehlerkorrektur. 281 | 282 | #note[Die Informationsrate gibt an, welcher Anteil der kodierten Nachricht 283 | tatsächlich der Inhalt der ursprünglichen Nachricht ist.] 284 | 285 | *Fähigkeit zur Fehlerkorrektur:* Fehler können durch den Abgleich mit dem 286 | originalen Block erkannt werden. #sub[Dafür muss man allerdings Einsicht 287 | in sowohl Eingang als auch Ausgang haben.] 288 | ] 289 | 290 | #definition("Convolutional Coding")[ 291 | Bei der *Convolutional Kodierung* werden die einzelnen Bits einer Nachricht 292 | basierend auf vorherigen und nachfolgenden Bits kodiert. Dadurch kann 293 | stetig auf Fehler geprüft werden, was vor allem bei Echtzeitübertragungen 294 | sehr hilfreich ist. 295 | 296 | *Kodierung:* Lässt eingabe Bits durch Shift Register gehen und erstellt dann 297 | mittels diesen Bits und den aktuellen Eingabe Bits entsprechende Ausgabe Bits. 298 | 299 | *Einflusslänge (Constraint Length):* Gibt an, wie viele Register die Eingabe 300 | durchgehen muss. 301 | 302 | *Informationsrate:* Ähnlich wie bei Block Kodierung $R=k/n$. 303 | #sub[Wobei wir hier erstmal nicht wirklich $k$ und $n$ eingeführt haben] 304 | ] 305 | 306 | = Mehr Entropie 307 | 308 | Analog zu Ereignissen kann man auch bei Entropie konditionale Abhängigkeit 309 | haben. So kann das wissen eines Wertes die Unsicherheit über den anderen 310 | reduzieren. 311 | 312 | #definition("Konditionale Entropie (Conditional Entropy)")[ 313 | Die *Konditionale Entropie* berechnet die Ungewissheit vom Wert einer 314 | Zufallsvariable $Y$, sofern wir bereits den Wert einer Zufallsvariable $X$ 315 | wissen. 316 | 317 | $ Eta(Y|X) = Eta(Y) - I(X;Y) $ 318 | 319 | #dangerous[ 320 | Sofern ich jetzt keine Konditionen übersehe sollte diese Formel in 321 | Kombination mit der Mutual Information folgende Gleichung ergeben: 322 | $Eta(X|Y) = Eta(X,Y) - Eta(Y)$ 323 | ] 324 | 325 | Laut #link("https://en.wikipedia.org/wiki/Conditional_entropy", 326 | underline("Wikipedia")) gibt es wohl noch eine weitere Formel für die 327 | konditionale Entropie: 328 | $ Eta(Y|X) = - sum_(x in cal(X)) sum_(y in cal(Y)) p(x,y) log (p(x,y)/p(x)) $ 329 | Wie relevant diese sein wird kann ich derzeit nicht sagen. 330 | ] 331 | 332 | Und natürlich braucht es auch noch einen Weg, wie wir Verteilungen in Bezug 333 | auf ihre Entropie vergleichen können. 334 | 335 | #definition("Cross Entropy")[ 336 | _Jegliche Erklärungen die ich hierfür gefunden habe waren viel zu 337 | kompliziert. Daher muss Jans Erklärung es tun._ \ 338 | Die *Cross Entropy* gibt uns für zwei Verteilungen $p$, $q$ über der Menge 339 | $cal(X)$ die Durchschnittliche Information/Überraschung für eine Verteilung 340 | $p$, wenn wir eigentlich von der Verteilung $q$ ausgehen. 341 | 342 | $ Eta(p,q) = sum_(x in cal(X)) p(x) log 1/q(x) 343 | = sum_(x in cal(X)) p(x) I_q(x) $ 344 | ] 345 | 346 | = Divergenz 347 | 348 | Erstmal wieder die wichtigste Frage: Was ist überhaupt eine Divergenz? 349 | Divergenzen werden genutzt um zwei Wahrscheinlichkeitsverteilungen zu 350 | vergleichen. Dabei scheinen diese erstmal eher aus der Vektorarithmetik zu 351 | kommen und sind dann auf Wahrscheinlichkeiten übertragen worden. \ 352 | Jan sagt noch: Divergenzen messen, wie effizient eine Verteilung die andere 353 | kodiert. 354 | 355 | Dazu haben sie folgende Eigenschaften: 356 | - Asymmetrisch: Nicht alle Divergenzen sind symmetrisch 357 | - Nicht-Negativ: Sie sind allerdings immer $>= 0$ 358 | - Null, falls die Verteilungen identisch 359 | 360 | Kommen wir also zur mit am verbreitetsten Divergenz: Kullback-Leibler Divergenz. 361 | 362 | #definition("Kullback-Leibler (KL) Divergenz (KL Divergence)")[ 363 | Die *KL Divergenz* $D_("KL")(p || q)$ misst für zwei Verteilungen $p$, $q$ 364 | über einer Menge $cal(X)$ die Information, die wir verlieren, wenn wir $q$ 365 | zur Kodierung nutzen, obwohl wir aber eigtl. eine Kodierung bzgl. $p$ 366 | erwarten. \ 367 | #dangerous[An sich wird in den Definitionen erstmal nur von Information 368 | gesprochen, ich glaube aber als Kodierung ist das verständlicher, sofern es 369 | richtig ist.] \ 370 | Deshalb der Vollständigkeit: Die KL Divergenz misst den Verlust an 371 | Information, wenn $q$ genutzt wird um $p$ zu approximieren. Dazu wird diese 372 | Divergenz auch häufig als relative Entropie (engl: Relative Entropy) 373 | bezeichnet. Und sie ist nicht symmetrisch. 374 | 375 | $ 376 | D_"KL" (p || q) = sum_(x in cal(X)) p(x) log (p(x)/q(x)) 377 | $ 378 | 379 | Für stetige Verteilungen sieht diese Formel recht ähnlich aus, nur mit 380 | $integral_(-infinity)^(infinity)$ anstatt der Summe. 381 | ] 382 | 383 | Und zu guter letzt hat der _man himself_ Claude Shannon zusammen mit Johan 384 | Jensen ebenfalls eine Divergenz aufgestellt. 385 | 386 | #definition("Jensen-Shannon Divergenz (JS Divergence)")[ 387 | Die *JS Divergenz* $D_"JS" (p || q)$ ist eine abgewandelte Form der KL 388 | Divergenz um diese symmetrisch und immer endlich zu machen. So liegt die 389 | JS Divergenz immer zwischen 0 und 1. 390 | 391 | Erneut haben wir also Verteilungen $p$ und $q$ über einer Menge $cal(X)$. 392 | Dazu definieren wir uns eine dritte Verteilung $m$ mit $m = (p + q) slash 2$. 393 | Also einem arithmetischen Mittel von $p$ und $q$. Basierend darauf können wir 394 | nun die JS Divergenz definieren: 395 | $ 396 | D_"JS" (p || q) = 1/2 D_"KL" (p || m) + 1/2 D_"KL" (q || m) 397 | $ 398 | Die Wurzel von dieser Divergenz ist sogar eine Distanz (für was genau diese 399 | Distanz steht habe ich auf die schnelle jetzt allerdings nicht 400 | herausgefunden). 401 | ] 402 | 403 | #line(length: 100%) 404 | 405 | *Changelog*: 406 | - 1.0 #sym.arrow.r 1.0.1: Fix von Rechtschreibfehlern 407 | -------------------------------------------------------------------------------- /chap5.typ: -------------------------------------------------------------------------------- 1 | #import "template.typ": * 2 | 3 | #show: book-template.with( 4 | chapter: 5, 5 | version: "1.1", 6 | ) 7 | 8 | = Experimental Design 9 | 10 | Zuerst behandeln wir Experimente bzw. deren Aufbau. Die Motivation dahinter ist 11 | in Bezug auf Kapitel 4, dass wir eben Experimente brauchen, um unsere Daten und 12 | damit unsere Parameter zu bestimmen. Im folgenden werden wir uns also damit 13 | beschäftigen, wie ein guter Aufbau von Experimenten aussieht. 14 | 15 | 1. Erkennung und Formulierung des Problems 16 | 2. Auswahl der relevanten Ergebniswerte 17 | 3. Auswahl der Faktoren (Eingabevariablen) und deren Werte \ 18 | #sub[Dabei unterscheiden wir auch in un-/kontrollierbare Faktoren bzw. 19 | Variablen. Wobei wir dann die kontrollierbaren Variablen noch einmal 20 | unterteilen in Design Faktoren (welche, die wir ändern wollen) und 21 | Nuisance Faktoren (welche, die wir nicht ändern wollen weil sie zwar 22 | starken Einfluss haben, aber gerade nicht relevant sind.)] 23 | 4. Auswahl der Art des Experiments 24 | 5. Ausführung des Experiments 25 | 6. Statistische Analyse der Daten 26 | 7. Conclusion 27 | 28 | = Statistische Auswertung der Daten 29 | 30 | Zuerst einmal folgende Definitionen: 31 | 32 | - *Hypothese*: Eine Hypothese ist eine Behauptung über einen Paramter bzw. eine 33 | Variable 34 | - *Null Hypothesis*, *Alterntive Hypothesis*: Zwei Hypothesen über den 35 | gleichen Parameter, wobei diese sich wiedersprechen. \ 36 | Wir schreiben: $H_0: theta in Theta_0$ und $H_1: theta in Theta_0^C$. 37 | Dabei ist $Theta_0$ eine Teilmenge der gesamten Parameter $Theta$. 38 | - *Test*: In einem Test werden Daten ausgewertet und basierend darauf 39 | entschieden, welche der beiden Hypothesen wahr ist. Dazu nutzt man 40 | meist auch noch eine _rejection region_ $R$. 41 | - *Test statistic*: Eine test statistic $T: cal(X)^N -> bb(R)$, wobei $cal(X)$ 42 | der Ergebnisraum des Tests ist. Diese fasst die Testergebnisse in eine reelle 43 | Zahl zusammen. 44 | 45 | Basierend darauf sieht der Ablauf eines Tests wie folgt aus: 46 | 47 | 1. Vermutung über Verteilung aufstellen $X tilde P_theta$ 48 | 2. Null Hypothese aufstellen $H_0$ 49 | 3. Test statistic aufstellen $T: cal(X)^N -> bb(R)$ 50 | 4. Rejection region $R subset bb(R)$ auswählen, wobei die Wsk., dass ein 51 | Wert rejected wird minimal unter der Null Hypothesis sein sollte. 52 | $ 53 | P(T(X_1,...,X_N) in R) <= alpha 54 | $ 55 | $alpha$ nennen wir hierbei _significance value_ 56 | 57 | Und nun betrachten wir einmal verschiedene Methoden zur Auswertung von 58 | Testergebnissen. 59 | 60 | == Likelihood Ratio Test 61 | 62 | Zuerst erinnern wir uns zurück an Likelihood: 63 | $ 64 | L(theta | x_1,x_2,...,x_N) = L(theta | cal(D)) = p(cal(D) | theta) 65 | = product_(i=1)^N p(x_i | theta) 66 | $ 67 | #note[Wir nutzen hier den unüblichen Syntax $L(theta | cal(D))$ für Likelihood. 68 | Fragt nicht warum. Zudem bringt dies wieder eine i.i.d. Anforderung an die 69 | Testergebnisse] 70 | 71 | Dadurch stellen wir nun ein Likelihood Ratio auf, welches prüft, wie 72 | wahrscheinlich es ist, dass wir gerade die Null Hypothesis testen. 73 | $ 74 | lambda (cal(D)) = (sup {L(theta | cal(D)) : theta in Theta_0}) 75 | / (sup {L(theta | cal(D)) : theta in Theta}) 76 | $ 77 | #note[Hier genutzte Notation für $sup$ ist nicht einheitlich mit der von den 78 | Folien. Zudem nutzt Jan hier eigentlich $x$ für die Daten.] 79 | 80 | Ein Likelihood Ratio Test ist nun ein Test, bei dem primär Ergebnisse in 81 | ${cal(D) : lambda (cal(D)) <= c}$ mit $0 <= c <= 1$ verworfen werden. \ 82 | #sub[In den Folien steht hier was von rejection region. Allerdings macht es 83 | wenig Sinn, dass unsere rejection region aus einzelnen Datensätzen besteht.] 84 | 85 | *Normalverteilte Ergebnisse und simple Hypothesen*: \ 86 | Falls unsere Daten aus einer Normalverteilung $cal(N)(theta,1)$ stammen und 87 | unsere Hypothesen von der Form #box($H_0: theta = theta_0$), 88 | $H_1: theta != theta_0$ sind, können wir das ganze auch in folgendes verkürzen: 89 | $ 90 | lambda (cal(D)) = L(theta_0 | cal(D)) / L(hat(theta) | cal(D)) 91 | = exp {(-n (overline(x) - theta_0)^2) / 2} 92 | $ 93 | Dabei ist $hat(theta) = arg sup_(theta in Theta) L(theta | cal(D))$ per MLE 94 | bestimmt. Und da wir somit $Theta_0 = {theta_0}$ haben, können wir dieses direkt 95 | einsetzen. (Herleitung zu letztem Teil auf den Folien) 96 | 97 | #dangerous[Hierzu ist noch anzumerken: Bei MLE über Gauss ist der Sample Mean 98 | der Eingabedaten der optimale Mean. Entsprechend setzen wir das ganze hier auch 99 | so ein. Das ganze wurde auch in der Sprechstunde abgeklärt, habe es aber 100 | trotzdem mal als Warnung markiert, da ich mir unsicher bin, ob ich das ganze 101 | richtig wiedergebe.] 102 | 103 | Damit erhalten wir dann, dass alle Ergebnisse in 104 | ${cal(D) : |overline(x) - theta_0| >= sqrt(-2(log c) slash n)}$ abgelehnt 105 | werden sollten. 106 | 107 | #v(2em) 108 | 109 | Zudem kann man mittels LRT _"size $alpha$" LRT_ formen, indem man $c$ so wählt, 110 | dass $sup_(theta in Theta_0) P (lambda (cal(D)) <= c) = alpha$. 111 | 112 | == Gaussian Z-Test 113 | 114 | Mittels dem Gaussian Z-Test können wir vor allem Hypothesen über Normalverteilte 115 | Daten testen. Dabei testen wir ob der Erwartungswert einen gewissen Wert 116 | annimmt. Die Standardabweichung hingegen muss fest gewählt bzw. bekannt sein. 117 | 118 | #note[Entsprechend nimmt in einem Z-Test die test statistic auch eine 119 | Normalverteilung an.] 120 | 121 | Zur Hilfe führen wir zuerst die Variable $z_alpha$ ein. Diese gibt an, dass eine 122 | Normalverteilte Zufallsvariable mit Wsk. $alpha$ größer als $z_alpha$ ist. 123 | $ 124 | Z ~ cal(N) (0,1) quad "und" quad P(Z > z_alpha) = alpha 125 | $ 126 | 127 | Zuerst noch zwei Bedingungen: 128 | 1. Unsere Daten müssen dann entsprechend aus einer Normalverteilung stammen, 129 | also $X_1,...,X_N ~ cal(N) (mu, sigma_0^2)$ (dies sorgt auch für i.i.d.). 130 | $sigma_0$ muss erneut konstant sein. 131 | 2. Unsere null hypothesis muss eine der folgenden Formen haben: 132 | $ 133 | (i) H_0: mu = mu_0, quad (i i) H_0: mu <= mu_0, quad (i i i) H_0: mu >= mu_0 134 | $ 135 | 136 | Für die test statistic stellen wir folgende Formel auf: 137 | $ 138 | Z = T(X_1,...,X_N) = (sqrt(N))/sigma_0 (accent(X, macron) - mu_0) quad "mit" 139 | quad accent(X, macron) = 1/N sum_(n=1)^N X_n 140 | $ 141 | 142 | Bei unserer rejection region können wir uns einen aus folgenden 3 Fällen 143 | aussuchen: 144 | #grid(columns: (1fr,)*3, align: center)[ 145 | Two-sided 146 | 147 | $R := {z in RR : |z| > z_(alpha slash 2)}$ 148 | 149 | $p = 2 min {1-F(Z), F(Z)}$ 150 | ][ 151 | Left-sided 152 | 153 | $R := {z in RR : z < -z_alpha}$ 154 | 155 | $p = F(Z)$ 156 | ][ 157 | Right-sided 158 | 159 | $R := {z in RR : z > z_alpha}$ 160 | 161 | $p = 1-F(Z)$ 162 | ] 163 | 164 | #note[Für Visualisierungen der drei Fälle am besten auf die Folien schauen. F 165 | ist hierbei die CDF der Normalverteilung.] 166 | 167 | Diese Fälle geben dann an, welche Ausreiser wir ablehnen. Heißt ob wir 168 | Hypothesen ablehnen, bei denen der Erwartungswert in eine der beiden Richtungen 169 | abdriftet, oder eben nur nach links/rechts. \ 170 | $p$ ist hierbei der sogenannte p-value. Dieser wandelt unsere test statistic 171 | wieder in eine Wsk. um, sodass wir diese dann mit $alpha$ vergleichen können, 172 | um zu bestimmen, ob wir die null hypothesis annehmen/ablehnen. Gilt also 173 | $p < alpha$, bzw. $alpha/2$ im two sided, lehnen wir die null hypothesis ab. 174 | 175 | Und damit können wir dann unseren Z-Test durchführen. 176 | 177 | Wenn wir allerdings die Standardabweichung unserer Daten nicht wissen, oder nur 178 | eine geringe Anzahl an samples (< 30) haben, kommen wir mit dem Z-Test nicht 179 | weiter. Dafür gibt es dann aber andere Arten, wie z.B. den Student's t-Test. 180 | 181 | Weiterführend muss außerdem noch gesagt sein, dass Z-tests nicht nur stur 182 | einen Parameter mit einem fest vorgelegten vergleichen können, sondern wir auch 183 | aus zwei samples den mean vergleichen können. Dafür müssen allerdings beide 184 | Standardabweichungen der samples bekannt sein. Unsere test statistic sieht dann 185 | wie folgt aus: 186 | $ 187 | Z = ((accent(X, macron) - accent(Y, macron)) - (mu_X - mu_Y))/ 188 | (sqrt(sigma_X^2/N_X + sigma_Y^2/N_Y)) 189 | $ 190 | 191 | Der Rest ist allerdings analog zu oben. 192 | 193 | == A/B Testing 194 | 195 | Dazu sei auch noch einmal kurz A/B Testing angesprochen. Hier testen wir 196 | effektiv zwei Varianten: A und B, und vergleichen die Ergebnisse. Dies kann 197 | heißen, dass wir die Nutzer in zwei Gruppen unterteilen und jeweils die eine 198 | bzw. andere Sache testen. Man könnte dies aber auch so sehen, dass zuerst 199 | alle Nutzer in Gruppe A sind und dann nach einer Weile alle Nutzer in Gruppe B 200 | gewechselt werden. Wichtig ist hier jedoch, dass die Nutzer i.i.d. in die 201 | Gruppen eingeteilt werden. Mehr hierzu in der Übung. 202 | 203 | == Fehler in Hypothesis Testing 204 | 205 | Leider ist nicht alles fehlerfrei. Beim Testen unterscheiden wir dabei speziell 206 | folgende Fälle: 207 | 208 | #let vert(c) = rotate(-90deg, c, reflow: true) 209 | 210 | #align(center, block(width: 50%, breakable: false, table( 211 | columns: (auto,auto,1fr,1fr), 212 | stroke: (x,y) => if x > 1 or y > 1 { 1pt }, 213 | align: center + horizon, 214 | [], [], table.cell("Reality", colspan: 2), 215 | [], [], "Positive", "Negative", 216 | table.cell(vert[Study findings], rowspan: 2), 217 | vert[Positive], [True positive], [False positive \ #sub[Type I Error]], 218 | vert[Negative], [False negative \ #sub[Type II Error]], [True negative] 219 | ))) 220 | 221 | Um Type I Error zu reduzieren, können wir das _significance level_ $alpha$ 222 | reduzieren. Dies erhöht allerdings die Wsk. auf Type II Error. \ 223 | Für statistiche Behauptungen ist z.B. $alpha <= 0.05$ relevant. Mittlerweile 224 | wollen aber viele, dass dieser Wert weiter auf $alpha <= 0.005$ runtergesetzt 225 | wird, da trotzdem noch zu viele Falschaussagen entstehen. 226 | 227 | Um wiederum Type II Error zu reduzieren müssen wir die sample size erhöhen, 228 | also mehr testen. 229 | 230 | == Student's t-test 231 | Nun noch eine weitere Testmethode, die auf dem Z-Test aufbaut. Diese wurde zwar 232 | nicht in der Vorlesung behandelt, allerdings in der Übung und ist somit laut Jan 233 | auch klausurrelevant. 234 | 235 | Die Besonderheit am t-test im Vergleich zum Z-test ist, dass wir hier auch 236 | mit kleineren sample sizes arbeiten können. Für größere sample sizes konvergiert 237 | dieser test zum Z-test. Zudem muss hier die Standardabweichung nicht bekannt 238 | sein. Hier sei auch gesagt, dass dieser test noch sehr viel mehr zu bieten hat, 239 | als hier dargestellt. 240 | 241 | Wir betrachten nun nur den Fall, dass wir zwei samples $X$, $Y$ miteinander 242 | vergleichen wollen. Dazu sollen unsere Daten wieder aus Normalverteilungen 243 | stammen, und samples von $X$ und $Y$ müssen unabhängig voneinander sein. 244 | Außerdem müssen für den spezifischen test, den wir machen, die Varianzen 245 | ähnlich sein. 246 | 247 | Unsere test statistic hat dann folgende Form: 248 | $ 249 | t = (accent(X, macron) - accent(Y, macron))/(s_P sqrt(1/N_X + 1/N_Y)) 250 | $ 251 | wobei 252 | $ 253 | s_P = sqrt(((N_X - 1)s_X^2 + (N_Y - 1)s_Y^2)/(N_X + N_Y - 2)) 254 | $ 255 | und 256 | $ 257 | s_A = sqrt(1/N_A sum_(i=1)^(N_A) (x_i - accent(A, macron))^2) 258 | $ 259 | 260 | Dazu kommt noch die sog. _degrees of freedom_ $"df" = N_X + N_Y - 2$. 261 | 262 | Damit kann man dann mit ähnlichen rejection regions bzw. p Werten wie beim 263 | Z-Test arbeiten, nur dass hier die t-Verteilung genommen wird und nicht die 264 | Normalverteilung. Diese verbleibt als Selbststudium. 265 | 266 | = Evaluation 267 | 268 | Nachdem wir nun mittels Experiment unser Modell aufgestellt haben, gilt es nun 269 | noch zu überprüfen, dass dieses nicht ggf. doch unpassend ist. Also ob es z.B. 270 | sehr genau die gemessenen Datenpunkte beschreibt, dafür aber an allen anderen 271 | Punkten unbrauchbar ist. 272 | 273 | Begriffsklärung: Modell heißt hier vor allem erst einmal die Art von 274 | Funktion, die wir wählen, also z.B. Polynom, Gerade, etc. und dazu auch die 275 | Hyperparameter der Funktion, also z.B. Grad des Polynoms. 276 | 277 | Dazu kann man bereits einmal folgendes festhalten: es reicht nicht einen 278 | niedrigen Training Error zu haben, sondern man sollte dazu auch noch einen 279 | niedrigen Testing Error haben. Dafür braucht man eben einen (kleineren) 280 | Datensatz, der ausschließlich zum testen genutzt wird, und der disjunkt mit 281 | dem Trainings Datensatz ist. 282 | 283 | Aber was ist nun das beste Modell? \ 284 | Dies ist leider nicht gerade trivial. Ein Ansatz ist allerdings Occam's Razor: 285 | laut diesem sollen wir das simpelste Modell nehmen, welches unsere Daten gut 286 | abdeckt. "Simpelste" heißt hier das Modell mit der niedrigsten Komplexität. Wie 287 | genau man Komplexität beschreibt oder misst wird hier nicht erwähnt. Man kann 288 | sich diese allerdings stark als die Hyperparameter der einzelnen Fitting 289 | Methoden vorstellen. Also z.B. den Grad des Polynoms bei linear regression oder 290 | der Anzahl an Clustern beim Clustering. 291 | 292 | Speziell fürs Clustering gibt es aber noch andere Methoden: 293 | - #[ 294 | Elbow Method: 295 | 296 | Die gesamte within-cluster sum of square (WSS) in relation zur Anzahl an 297 | clustern plotten. Dabei wird es dann einen sog. "elbow point" geben. Dieser 298 | ist quasi der Punkt ab dem die Kurve stark abflacht und gibt dann 299 | die optimale Anzahl an. 300 | ] 301 | - #[ 302 | Gap statistics: 303 | 304 | Diese Methode baut wieder etwas mehr auf Vermutung auf. Hier stellt man eine 305 | test statistic und null hypothesis um den Erwartungswert für die \#Cluster auf 306 | und vergleicht die Wsk. Verteilung dieser null statistic mit WSS. #sub[Aber 307 | genaueres kann ich hierzu auch nicht sagen.] 308 | ] 309 | 310 | Allerdings sollte man hier alles als kritisch betrachten. Denn z.B. im Falle 311 | von deep learning gibt es das Phänomen "double descent". Dieses besagt im 312 | groben, dass zwar der Test error, wenn sich die Anzahl der Parameter der Anzahl 313 | an Datenpunkten annähert, steigt. Wenn man allerdings noch mehr Parameter wählt 314 | sinkt der Test error auf einmal noch stärker und man erhält ein noch genaueres 315 | Modell. 316 | 317 | == Model Validation 318 | 319 | Nun betrachten wir die Model Validation, also das überprüfen, dass unser Modell 320 | sinnvoll ist. Bzw. finden des sinnvollsten Modell. Dazu nehmen wir uns unser 321 | aktuelles Modell $f_theta$, wobei $theta$ die Parameter des Modell beschreibt. 322 | 323 | Für eine ordentliche Validierung müssen wir unseren Datensatz in drei Teile 324 | unterteilen: 325 | 326 | #let datasetbox(color, body) = box(fill: color.lighten(60%), inset: 2mm, 327 | width: 100%, radius: 2pt, stroke: color, body) 328 | 329 | #align(center, block(width: 60%, grid( 330 | columns: (1fr, ) * 4, column-gutter: 5pt, 331 | grid.cell(colspan: 2, datasetbox(blue, "Training set")), 332 | datasetbox(green, "Validation set"), 333 | datasetbox(fuchsia, "Test set") 334 | ))) 335 | 336 | Diese haben folgende nutzen: 337 | - Training set: Damit passen wir den Parameter $theta$ unseres Modells an 338 | - Validation set: Gucken, ob das gewählte Modell $f$ überhaupt sinnvoll ist und 339 | ggf. Hyperparameter anpassen 340 | - Test set: Am Ende das Modell noch einmal mit ganz frischen Daten testen 341 | 342 | Dabei findet Validaten noch eher während der Trainingsphase statt, während 343 | testing wirklich erst ganz am Ende durchgeführt wird. Zudem müssen all diese 344 | Datensätze disjunkt sein. Nachdem wir mit dem aktuellen test set getestet haben, 345 | müssen wir, sofern wir noch weiter trainieren wollen, ein neues test set holen. 346 | 347 | Zur Validation betrachten wir nun den *Cross Validation* Ansatz: \ 348 | Teile in jeder Iteration den gesamten Datensatz $cal(D)$ in $K$ gleich große 349 | Teile auf. $cal(D)_1,...,cal(D)_(K-1), cal(D)_K$. Dabei sind $cal(D)_1$ bis 350 | $cal(D)_(K-1)$ training sets und $cal(D)_K$ unser validation set. 351 | - Mit den training sets können wir unsere Parameter bestimmen 352 | - und mit dem validation set können wir unser Modell validieren: 353 | $ 354 | L_k (f_theta) = sum_((x,y) in D_k) cal(L) (f_theta (x),y) 355 | $ 356 | Dies wird nun mit jeder möglichen Partition gemacht. Am Ende nehmen wir dann 357 | das Modell, das am besten abgeschnitten hat. Dies ist allerdings sehr aufwendig, 358 | dafür haben wir dann allerdings eine gute Bewertung unseres Modells bzw. ein 359 | gutes Modell. 360 | 361 | Wenn man allerdings seine Lebenszeit/Stromrechnung etwas mehr wertet, kann man 362 | auch K-fold Cross Validation nutzen. 363 | 364 | *K-fold Cross Validation*: \ 365 | Hier teilen wir unsere Daten in $K$ gleich große Mengen, sog. "folds". In jeder 366 | Iteration nehmen wir dann einen anderen von diesen Folds als validation set 367 | und den Rest als training set. 368 | 369 | Damit bekommen wir dann folgendes für das optimale Modell: 370 | $ 371 | f^* = arg min_(f in cal(M)) 1/K sum_(k=1)^K L_k (f) 372 | $ 373 | 374 | Dies wird dann ggf. nicht so optimal sein, wie pure Cross Validation, dafür aber 375 | trotzdem noch gut genug. 376 | 377 | == Bias & Variance 378 | 379 | #let bias = math.op("bias") 380 | #let var = math.op("var") 381 | #let loss = math.op(math.cal("L")) 382 | #let f_est = $hat(f)_cal(D)$ 383 | 384 | #sub[Kann sich hier noch wer daran erinnern, was Aleatoric und Epistemic 385 | Uncertainty war? Nein? Gut ich auch nicht.] 386 | 387 | / Aleatoric: Unsicherheit wegen allgemeiner Zufälligkeit eines Events 388 | / Epistemic: Unsicherheit wegen fehlendem wissen 389 | 390 | Damit im Hinterkopf gucken wir uns nun noch den Bias & Variance tradeoff an. 391 | 392 | Hier auch erst einmal wieder Begriffsklärung. Dazu nehmen wir unser geschätztes 393 | Modell $#f_est$ über den Daten $cal(D)$ und das wahre Modell $f$. 394 | 395 | / bias: die erwartete Abweichung von unserem wahren Modell gemäß den Daten 396 | $ 397 | bias(#f_est) = expect_cal(D)[#f_est - f] 398 | $ 399 | / variance: wie davor auch schon ist dies eben einfach die Varianz des 400 | geschätzten Modell, allerdings nur gemäß den Daten. 401 | $ 402 | var(#f_est) = expect_cal(D)[(#f_est - expect_cal(D)[#f_est])^2] 403 | $ 404 | 405 | #dangerous[Jan definiert das ganze eher über den estimator bzw. dem Parameter. 406 | Sollte aber denke ich mal keinen großen Unterschied machen.] 407 | 408 | Man kann den $bias$ auch als Fehler im Ansatz sehen, sodass unser Modell einfach 409 | nicht besser sein kann. $var$ ist dazu der estimation error. Dieser wird 410 | immer vorhanden sein, wenn wir nur endliche Datensätze haben. 411 | 412 | Weicht unser erwartetes Modell von dem wahren ab 413 | ($expect_cal(D)[#f_est] != f$), so nennen wir unser Modell _biased_. 414 | Ansonsten _unbiased_. 415 | 416 | Ein estimator, der null bias und minimale Varianz hat, nennen wir _minimum 417 | variance unbiased estimator_ (MVUE). Ist solch ein estimator noch linear in 418 | seinen Parametern nennen wir diesen _best linear unbiased estimator_ (BLUE). 419 | 420 | Solch ein MVUE wäre nun erwünschenswert, ist aber leider nicht so einfach. Wenn 421 | wir nämlich eine hohe Varianz haben, kann unser Modell tendenziell besser neue 422 | Daten einbeziehen, und wir erhalten ein Modell, dass alle Daten gut beschreibt. 423 | Im Gegensatz dazu hat ein höheres Bias meist eine niedrigere Varianz, da wir 424 | ggf. nur weniger abweichende Daten einbeziehen, und dadurch dann manche Punkte 425 | weniger gut beschreiben. 426 | 427 | Man beachte zudem, dass wir nicht direkt Bias und Variance modifizieren können, 428 | sondern eher nur, wie sehr unser Estimator Datenpunkte einbezieht. Je nachdem, 429 | wie unser Estimator dies Daten also einbezieht erhalten wir einen der beiden 430 | Fälle. 431 | 432 | Das ganze kann man auch noch etwas in Formeln ausdrücken: \ 433 | Und zwar wollen wir den loss über einen Datenpunkt $(y_q, x_q)$ bestimmen. 434 | Dafür betrachten wir den _mean squared loss_ (MSE): 435 | $ 436 | loss(y_q, x_q) = expect_(cal(D),epsilon)[(y_q - #f_est (x_q))^2] 437 | $ 438 | 439 | Dazu nehmen wir an, dass unsere gemessenen Datenpunkte ein gewisses Rauschen 440 | beinhalten: 441 | $ 442 | y = f(x) + epsilon quad "mit" quad epsilon ~ cal(N) (0,sigma_epsilon^2) 443 | $ 444 | 445 | Setzen wir dies ein erhalten wir erst einmal: 446 | $ 447 | loss(y_q, x_q) &= expect_(cal(D),epsilon)[(y_q - #f_est (x_q))^2] \ 448 | &= expect_(cal(D),epsilon)[(f(x_q) + epsilon - #f_est (x_q))^2] \ 449 | &= sigma_epsilon^2 + expect_cal(D) [(f(x_q) - #f_est (x_q))^2] 450 | $ 451 | Um an den Anfang dieses Kapitel zurückzukommen: 452 | - $sigma_epsilon^2$ ist hier die aleatoric uncertainty 453 | - $expect_cal(D) [(f(x_q) - #f_est (x_q))^2]$ hingegen die epistemic uncertainty 454 | 455 | Schlussendlich erhalten wir aber: 456 | $ 457 | loss(y_q, x_q) = sigma_epsilon^2 + 458 | underbrace(expect_cal(D) [f(x_q) - #f_est (x_q)]^2, 459 | bias^2(#f_est (x_q))) + 460 | underbrace(expect_cal(D) [(#f_est (x_q) - expect_cal(D) [#f_est (x_q)])^2], 461 | var(#f_est (x_q))) 462 | $ 463 | 464 | Für eine Herleitung dieser Rechnung sei auf die Lösung von Übung 3 verwiesen. 465 | 466 | #line(length: 100%) 467 | 468 | *Changelog*: 469 | - 1.0 #sym.arrow.r 1.1: Fix von Rejection Regions bei Left/Right sided Z Test -------------------------------------------------------------------------------- /chap4.typ: -------------------------------------------------------------------------------- 1 | #import "template.typ": * 2 | 3 | #show: book-template.with( 4 | chapter: 4, 5 | version: "1.2" 6 | ) 7 | 8 | = Estimators 9 | 10 | Erneut befinden wir uns an dem Punkt, wo wir die genaue Verteilung zu etwas nicht 11 | wissen. Bzw. wir wissen ggf. was für eine Art von Verteilung haben, wissen dann 12 | aber nicht mit welchen Parametern diese Verteilung aufgebaut ist. Dieses Kapitel 13 | beschäftigt sich eben genau mit der Bestimmung solcher Parameter. 14 | 15 | Aber erst einmal was sind denn überhaupt diese Parameter? \ 16 | Visuell sind die Parameter einfach die Werte, die man der Verteilung übergibt. 17 | Bei $cal(N)(mu, sigma^2)$ sind z.B. $mu$ und $sigma^2$ die Parameter. Diese 18 | ganzen Parameter fassen wir dann in einen Vektor $theta$ zusammen: 19 | $theta = (mu, sigma^2)^T$. Nun einmal für alle uns bekannte Verteilungen: 20 | #notation-table(table( 21 | columns: (1fr,1fr), 22 | table.header([Verteilung], [Parameter]), 23 | $"Ber"(p)$, $theta=p$, 24 | $"Bin"(n,p)$, $theta=(n,p)^T$, 25 | $"Poi"(lambda)$, $theta=lambda$, 26 | $"Uniform"(a,b)$, $theta=(a,b)^T$, 27 | $cal(N)(mu, sigma^2)$, $theta=(mu, sigma^2)^T$ 28 | )) 29 | 30 | #note[Jan, genauso wie viele andere auch, verwenden oft auch eckige Klammern 31 | um den Vektor darzustellen. Um das ganze allerdings einheitlich mit Mathe I 32 | kompatibel zu machen wurden hier Runde Klammern gewählt.] 33 | 34 | Um diese Parameter zu schätzen gibt es nun zwei Arten von Estimators: 35 | 36 | #grid(columns: (1fr, 1fr), column-gutter: 2em)[ 37 | #definition("Point Estimators")[ 38 | *Point Estimators* nutzen gesammelte Daten und rechnen damit einen 39 | einzelnen geschätzten Wert für einen Parameter aus. Dieser ist dann die 40 | beste Schätzung. 41 | ] 42 | ][ 43 | #definition("Interval Estimators")[ 44 | *Interval Estimators* bestimmen im Kontrast dazu ein Intervall an 45 | möglichen Werten für einen Parameter. Typischerweise wird dieses Intervall 46 | durch eine Unter-/Obergrenze angegeben. 47 | ] 48 | ] 49 | 50 | // Zwei Folien geskippt, sehe aber für die keine relevanz, da wenig Inhalt. 51 | 52 | == Maximum Likelihood Estimation 53 | 54 | Hierfür brauchen wir zuerst unsere Beispieldaten $cal(D) = {x_i}_(i=1)^n$ 55 | 56 | Außerdem brauchen wir noch den Begriff der _Likelihood_ $L(theta)=p(D | theta)$. 57 | Diese gibt die Wsk. an, dass Daten $cal(D)$ mit den Parametern $theta$ 58 | generiert wurden. 59 | 60 | Nun ist unser Ziel hier diese _Likelihood_ zu maximieren, also 61 | $ 62 | arg max_theta L(theta) = p(cal(D) | theta) 63 | $ 64 | zu bestimmen. 65 | 66 | Dafür müssen die Daten allerdings *unabhängig* und *gleichmäßig verteilt* 67 | (i.i.d.) sein,heißt: 68 | - unabhängig: $P(X_1 <= alpha, X_2 <= beta)=P(X_1 <= alpha) P(X_2 <= beta) quad 69 | forall alpha, beta in bb(R)$ 70 | - gleichmäßig verteilt: $P(X_1 <= alpha) = P(X_2 <= alpha) quad 71 | forall alpha in bb(R)$ 72 | 73 | Aus dieser Bedingung erhalten wir dann: 74 | $ 75 | L(theta) = p(cal(D) | theta) 76 | = p(x_1,x_2,...,x_n | theta) 77 | =^"i.i.d." p(x_1 | theta) p(x_2 | theta) ... p(x_n | theta) 78 | = product_(k=1)^n p(x_k | theta) 79 | $ 80 | Für das Ergebnis der MLE schreiben wir auch $hat(theta)_"ML"$. Sofern wir nun 81 | nicht konkret bereits alle Werte zur Berechnung haben ist dies erst einmal 82 | wieder als Zufallsvariable ansehbar. Uns interessiert dabei dann der 83 | Erwartungswert und die Varianz. 84 | 85 | *Log Likelihood*: \ 86 | Da es meist einfacher zu berechnen ist, kann man auch den Logarithmus der 87 | Likelihood maximieren. Dies ist möglich, da der Logarithmus ordentlich 88 | runterskaliert und monoton ist. 89 | 90 | $ 91 | log L(theta) = log p(cal(D) | theta) = log product_(k=1)^n p(x_k | theta) = 92 | sum_(k=1)^n log p(x_k | theta) 93 | $ 94 | 95 | Das Maximum einer Summe zu bestimmen ist nun deutlich einfacher, da z.B. auch 96 | ableiten deutlich einfacher wird. Dazu ist es auch numerisch stabiler, 97 | da Werte nahe 0 im Logarithmus wieder etwas größer werden, wodurch wir die 98 | floating point precision unserer Rechner nicht ankratzen. 99 | 100 | == Bayesian Estimation 101 | 102 | Was man nun beobachten kann, ist dass in MLE die Parameter $theta$ als feste 103 | Werte angesehen werden, weswegen es sich dabei auch um Point Estimators handelt. 104 | Nun betrachten wir aber mal einen anderen Fall, bei dem wir unsere Parameter 105 | $theta$ als eine Zufallsvariable betrachten. Dabei kann dann erneut ein fester 106 | Wert entstehen, der am wahrscheinlichsten angenommen wird, es kann aber eben 107 | auch ein Bereich rauskommen -- also eine density estimation. 108 | 109 | // ggf. noch etwas mehr auf die Unterschiede zwischen Frequentist und Bayesian 110 | // eingehen? siehe Folie 23 111 | 112 | Bevor wir weiter in die Bayesion Estimation eintauchen gilt es noch zwei 113 | Begriffsklärungen zu machen: 114 | / Prior: Bezeichnet die Vermutung über die Parameter, bevor wir jegliche Daten 115 | beobachtet haben $p(theta)$ 116 | / Posterior: Der Posterior bezeichnet nun Widerum wie gut ein Prior gewählt 117 | wurde bzw. wie unsicher wir uns in unserem Prior sind, nachdem wir neue 118 | Daten beobachtet haben $p(theta | D)$ 119 | 120 | Laut Bayes Theorem können wir diesen Posterior eben wie folgt ausrechnen: 121 | $ 122 | p(theta | D) = (p(D | theta) p(theta))/(p(D)) 123 | $ 124 | 125 | Durch gewisse Umformungen erhalten wir dazu noch folgende Formel zur Bestimmung 126 | der Evidence $p(D)$: 127 | $ 128 | p(D) = integral p(D | theta)p(theta) dif theta 129 | = integral L(theta) p(theta) dif theta 130 | $ 131 | 132 | // Folie 27-29 sind sehr random. Laut Sprechstunde kann x hier beliebig sein. 133 | // Ggf. später noch einbauen, gerade noch nicht so relevant. 134 | // Siehe auch Bishops Buch S. 31 Formel 1.68 135 | 136 | // MLE betrachtet Parameter fix, Bayesian als Zufallsvariable 137 | 138 | Häufig schreibt man zum Posterior auch noch folgendes: 139 | $ "Posterior" prop "Prior" times "Likelihood" div "Evidence" $ 140 | #note[$prop$ heißt einfach proportianal, also $A prop B <=> A = k B$] 141 | 142 | Wirklich etwas damit anfangen können wir nicht. Aber vielleicht hat es ja einen 143 | nutzen #emoji.person.shrug 144 | 145 | #note[Bayesian Estimation wurde hier nur sehr gebrochen und wahrscheinlich 146 | unvollständig erklärt. Falls hier jemand noch was gutes zum ergänzen hat gerne 147 | melden oder selbst machen und dann PR.] 148 | 149 | Zuletzt noch die Begriffsklärung *Conjugate Priors*: Dies bedeutet lediglich, 150 | dass die Verteilungen des Prior und des Posterior zur selben Familie gehören. 151 | Also z.B. beide eine Normalverteilung haben. 152 | 153 | = Maximum A-Posteriori 154 | 155 | Jetzt haben wir aber nur darüber geredet, wie wir mit dem Posterior rechnen 156 | können. Aber wie können wir nun überhaupt ordentlich einen Wert -- oder etwas 157 | in die Richtung -- bestimmen? Dafür ist eben die Maximum A-Posteriori (MAP) 158 | Estimation da. 159 | 160 | Also wie macht man das nun? Jeder der hier große bedenken hat wird gleich mit 161 | großer trivialität enttäuscht: 162 | $ 163 | hat(theta)_"MAP" &= arg max_theta p(theta | D) \ 164 | &= arg max_theta (p(D | theta) p(theta)) / p(D) \ 165 | &= arg max_theta p(D | theta) p(theta) \ 166 | &= arg max_theta log p(D | theta) + log p(theta) \ 167 | (&= arg max_theta sum_(k=1)^n log p(x_k | theta) + p(theta)) 168 | $ 169 | 170 | Man beachte, dass wir den Nenner $p(D)$ einfach wegstreichen. Ich vermute mal, 171 | dass dies den Grund hat, dass $p(D)$ unabhängig von $theta$ ist und somit über 172 | $max$ ein konstanter, ignorierbarer Faktor ist. 173 | 174 | Jetzt wird man feststellen, dass diese Formel recht ähnlich zur MLE aussieht. 175 | Genauer kann MLE eine Form von MAP betrachtet werden, wobei allerdings der 176 | Prior $p(theta)$ immer einen konstanten Wert annimmt. Also 177 | $ 178 | p(theta) = "const" => hat(theta)_"MAP" = arg max_theta log p(D | theta) 179 | + "const" eq.est hat(theta)_"ML" 180 | $ 181 | 182 | = Supervised learning problems 183 | 184 | Nun kommen wir ggf. mal etwas mehr in Richtung KI -- wenn auch nur sehr 185 | mathematisch. 186 | 187 | Dafür können wir erstmal einen Grundsatz für KI aufstellen. In der 188 | uns bisher bekannten Mathematik und Informatik ist es hauptsächlich so: 189 | wir haben Eingabedaten $I$ und einen Algorithmus bzw. eine Funktion $f$ und 190 | bestimmen damit die Ausgabedaten $O$. Nun kann es aber eben sein, dass diese 191 | Funktion $f$ nicht so einfach realisierbar ist oder wir erst gar keine 192 | Anhaltspunkte zur Realisierung haben. Dann haben wir eher den Fall, dass wir 193 | bereits Beispiele an Input/Output Daten haben, aber keinen Anhaltspunkt, wie man 194 | diese ordentlich bestimmt. Entsprechend gilt es nun also unsere Funktion $f$ zu 195 | bestimmen. 196 | 197 | #note[Dieser Absatz ist so nicht auf Jans Folien zu finden, sondern eher ein 198 | eigener Abschweif. Über die Richtigkeit -- auch wenn das geschriebene eher 199 | Philosophisch ist -- kann ich keine Garantien machen.] 200 | 201 | Wir befinden uns hier bei supervised (de: beobachteten) Problemen. Das heißt 202 | konkret, dass wir die Datenbereiche bereits kennen bzw. diese gekennzeichnet 203 | (engl. labeled) sind, und nur unsere Funktion $f: I -> O$ bestimmen wollen. 204 | 205 | Hier gibt es nun noch die folgende Unterscheidung: 206 | / Regression: Hierbei ist der Ausgabebereich $O$ stetig, besteht also aus 207 | unendlich durchgehenden Werten 208 | / Classification: Hierbei ist $O$ diskret, besteht also nur aus festen Werten 209 | 210 | Jeweils ein Beispiel: 211 | - Den genauen Notendurchschnitt für die Promi Klausur vorhersagen. Dies ist ein 212 | Regression Problem, da es (zumindest bis zu einem gewissen Grad) eine 213 | beliebige Zahl im Intervall $[1,5]$ sein kann. 214 | - Die Anzahl der 1.0er der Promi Klausur zu bestimmen. Dies hingegen ist ein 215 | Classification Problem, da es nicht möglich ist eine 1.0 zu schreiben. \ 216 | Ein passenderes Beispiel ist hier jedoch sowas wie die Einordnung bzw. 217 | Klassifizierung einer Mail als Spam oder nicht Spam. 218 | 219 | == Regression aka. Curve Fitting 220 | 221 | Nun einmal verschiedene Methoden um bei Regression Problemen anhand von Daten 222 | eben solche Funktionen $f$ zu bestimmen. 223 | 224 | #dangerous[Dazu kommt im folgenden häufig Parameter $w$ vor. Diese kann man -- 225 | in Bezug auf KI -- auch als weights bezeichnen.] 226 | 227 | === Least Squares Linear Regression 228 | 229 | Zuerst wollen wir einmal eine Gerade $y = m x + b$ bzw. Ausgleichsgerade für 230 | unsere Daten bestimmen. Dafür nutzen wir die least squares linear regression. 231 | Diese sieht wie folgt aus: 232 | 233 | Wir haben nun folgende Daten beobachtet: 234 | - Eingaben $cal(X) = {x_1,...,x_n | x_i in bb(R)^d}$ 235 | - Ergebnisse $cal(Y) = {y_1,...,y_n | y_i in bb(R)^k}$ 236 | #note[Im allgemeinen sind $d$ und $k$ hier beliebig. Im folgenden betrachten 237 | wir nun den Fall $k=1$.] 238 | 239 | Diese Daten ordnen wir in Paare $(x_i, y_i)$ für $i in {1,...,n}$ 240 | 241 | Dazu nehmen wir noch: 242 | - Die uns unbekannten, zu bestimmenden Parameter $w$ in Form eines Vektor mit 243 | $d$ Elementen. Im Falle der Geradengleichung ist dies quasi unsere Steigung 244 | $m$. 245 | - Und Skalar $epsilon_0$, dass für eine uns unbekannte Zufallsvariablen steht 246 | und zur Fehlerminimierung dient. Was analog das $b$ der Gerade ist. 247 | // Eigentlich n viele epsilon? 248 | 249 | Dazu stellen wir dann für alle Paare $(x_i, y_i)$ folgende Gleichung auf: 250 | $ 251 | angle.l x_i | w angle.r + epsilon_0 = y_i 252 | $ 253 | #note[$angle.l dot | dot angle.r$ bezeichnet das Skalarprodukt] 254 | 255 | Nun wollen wir all diese Gleichungen nach $w$ auflösen. 256 | + #[ 257 | Dafür stellen wir zuerst zwei Vektoren auf, die unsere Gleichung homogen 258 | machen: 259 | $ 260 | hat(x)_i = vec(x_i, 1) quad hat(w) = vec(w, epsilon_0) 261 | $ 262 | ] 263 | + #[ 264 | Es ergibt sich: 265 | $ 266 | angle.l hat(x)_i | hat(w) angle.r = y_i 267 | $ 268 | ] 269 | + #[ 270 | Zuletzt fassen wir alle unsere Gleichungen in eine große Gleichung zusammen. 271 | Dafür definieren wir zuerst die Matrix $hat(X)$ und den Vektor $y$: 272 | $ 273 | hat(X) = (hat(x)_1, ..., hat(x)_n) quad y = (y_1, ..., y_n)^T 274 | $ 275 | $hat(X)$ hat also $hat(x)_1$ bis $hat(x)_n$ als Spalten. 276 | 277 | Damit ergibt sich: 278 | $ 279 | hat(X)^T hat(w) = y 280 | $ 281 | Alternativ hätten wir auch $hat(X)$ Zeilenweise definieren können, dann 282 | müssten wir hier nicht transponieren. 283 | ] 284 | + #[ 285 | Nun zum Herzstück dieser Methode: Wir wollen nun unsere Parameter $w$ so 286 | wählen, dass die Differenz zwischen unseren Eingabepunkten $hat(X)^T w$ und 287 | den Ergebnissen $y$ zum Quadrat hin recht niedrig ausfällt (least squares). 288 | Also: 289 | $ 290 | hat(w) = arg min_w norm(hat(X)^T w - y)_2^2 291 | = arg min_w sum_(i=1)^n (angle.l hat(x)_i | w angle.r - y_i)^2 292 | $ 293 | Dies gelingt eben durch Bestimmung der Extrempunkte des Gradienten über $w$: 294 | $ 295 | gradient_w norm(hat(X)^T w - y)_2^2 = 0 296 | $ 297 | // TODO: Genauer auf Formel eingehen 298 | Allgemein erhält man somit: 299 | $ 300 | hat(X)^T hat(w) = y <=> hat(X) hat(X)^T hat(w) = hat(X) y <=> 301 | hat(w) = (hat(X) hat(X)^T)^(-1) hat(X) y 302 | $ 303 | ] 304 | 305 | === Polynomial Regression 306 | 307 | An sich ist Polynomial Regression auch eine Art von Linear Regression. Grund 308 | dafür ist, dass sich das linear nicht unbedgint auf das Verhätlnis der Ein- und 309 | Ausgaben, sondern auf das Verhältnis der Funktion und der Parameter -- diese 310 | also linear einfließen -- bezieht. 311 | 312 | Ohne jetzt auf genaue Lösungsstrategien einzugehen wollen wir uns trotzdem mal 313 | den Ansatz angucken. Wir stellen nun folgende Gleichung auf: 314 | $ 315 | y(x,w) = sum_(i=0)^M w_i x^i 316 | $ 317 | Dies ist eben einfach die Gleichung eines Polynom $M$-ten Grades. Dazu bleibt 318 | wie gesagt die Herleitung von $w$ offen. 319 | 320 | Man beachte, dass für zu große $M$ dieser Ansatz zu overfitting führt. Also einer 321 | zu sehr an den Datenpunkten orientierten Funktion, die nicht mehr direkt ein 322 | Mittel aus den Punkten zieht sondern nur noch die Punkte selbst einbezieht. 323 | 324 | === MLE Regression bzw. Probabilistic Regression 325 | 326 | #block(breakable: false, 327 | note[Im folgenden verwenden wir nun die Schreibweise $p(x;theta)$, wobei 328 | das $;$ als Trennung zwischen "Eingabe" und Parametern der Wsk. steht. Dabei 329 | kann es abhängig von der Wsk. folgende zwei Sachen bedeuten: \ 330 | 1. $p(A; B)$ sofern noch keine konditionale Abhängigkeit vorkam steht $;$ für 331 | diese konditionale Abhängigkeit. Also $p(A | B)$ 332 | 2. $p(A | B; C)$ sofern bereits eine vorkam trennt hier $;$ Parameter und 333 | andere Abhängigkeiten. Also $p(A | B, C)$ 334 | #sub[Aber wirklich strikt ist hier nichts.] 335 | ]) 336 | 337 | // Auf Folie 60 scheint Jan ein wenig zu haluzinieren. 338 | 339 | #note[Der folgende Abschnitt orientiert sich etwas stärker an der Erklärung 340 | von Bishop (Seite 28f.)] 341 | 342 | Wir befinden uns also wieder am Punkt wo wir folgendes haben: 343 | - Eingabedaten $X = (x_1,...,x_n) in bb(R)^(d times n)$ 344 | - Ergebnisse $Y = (y_1,...,y_n)^T in bb(R)^n$ 345 | // Warum soll das ganze Matrix/Vektor sein? 346 | 347 | Unser Ziel ist es ja eine Grundlegende Struktur für die Funktion $f$ zu 348 | finden. Dazu wollen wir hier für beliebige $x$ einen entsprechenden Zielwert 349 | $f(x)=t$ bestimmen. Die Idee hier ist nun, mittels einer Gaußverteilung die Wsk. 350 | zu bestimmen, dass der Wert $t$ angenomen wird. 351 | 352 | Diese Gaußverteilung hat den Mittelwert $y(x,w)$ ($y$ aus Polynomial Regression, 353 | Grad $M$ scheint erstmal nicht so relevant zu sein) und die Standardabweichung 354 | eines gegebenen $sigma$ hat. 355 | 356 | Setzen wir das ganze zusammen erhalten wir: 357 | $ 358 | p(t|x; w, sigma) = cal(N) (t; y(x,w), sigma^2) 359 | $ 360 | 361 | Jetzt haben wir aber noch die unbekannten Parameter $w$, $sigma$. Diese können 362 | wir nun mit den uns bekannten Daten und MLE ausrechnen: 363 | 364 | $ 365 | p(Y | X; w, sigma) = product_(i=1)^n p(y_i | x_i; w, sigma) 366 | = product_(i=1)^n cal(N) (y_i; y(x_i, w), sigma^2) 367 | $ 368 | 369 | Das Ergebnis können wir mittels Log Likelihood simplifizieren: 370 | $ 371 | log p(Y | X; w, sigma) &= sum_(i=1)^n log cal(N) (y_i; y(x_n, w), sigma^2) \ 372 | &= sum_(i=1)^n (log (1/sqrt(2 pi sigma^2)) - 1/(2 sigma^2) (y_i-y(x_i,w))^2) \ 373 | &= -n log (sqrt(2 pi sigma^2)) 374 | - 1/(2 sigma^2) sum_(i=1)^n (y_i - y(x_i,w))^2 375 | $ 376 | 377 | Davon können wir dann eben erneut den Gradient bilden und damit die Extremwerte 378 | berechnen. 379 | 380 | Zur Hilfe nehmen wir noch die Funktion $phi_M (x)=(1,x,x^2,...,x^M)^T$. Damit 381 | ergibt sich auch $y(x,w)=angle.l phi_M (x) | w angle.r$ 382 | 383 | $ 384 | gradient_w log p(Y | X; w, sigma) &= 0 &<=> \ 385 | - 1/(sigma^2) sum_(i=1)^n (y_i - y(x_i, w)) phi_M (x_i) &= 0 &<=> \ 386 | sum_(i=1)^n (y_i - y(x_i, w)) phi_M (x_i) &= 0 &<=> \ 387 | sum_(i=1)^n y_i phi_M (x_i) &= sum_(i=1)^n y(x_i, w) phi_M (x_i) & \ 388 | $ 389 | 390 | Um wieder lineare Algebra anwenden zu können definieren wir uns: 391 | $ 392 | Phi = mat(|, , |; phi_M (x_1), dots.c, phi_M (x_n); |, , |) 393 | $ 394 | und damit können wir dann obige Gleichung weiter runterbrechen: 395 | $ 396 | sum_(i=1)^n y_i phi_M (x_i) &= sum_(i=1)^n y(x_i, w) phi_M (x_i) &<=> \ 397 | Phi Y &= sum_(i=1)^n y(x_i, w) phi_M (x_i) &<=> \ 398 | Phi Y &= sum_(i=1)^n angle.l phi_M (x_i) | w angle.r phi_M (x_i) &<=>^(*) \ 399 | Phi Y &= Phi Phi^T w &<=> \ 400 | w_"ML" &= (Phi Phi^T)^(-1) Phi Y & 401 | $ 402 | 403 | Man beachte, dass dies sehr ähnlich zu unserem Ansatz bei der Least Squares 404 | regression aussieht. 405 | 406 | $ 407 | *: sum_(i=1)^n angle.l phi_M (x_i) | w angle.r phi_M (x_i) 408 | = sum_(i=1)^n angle.l phi_M (x_i) | phi_M (x_i) angle.r w 409 | = Phi Phi^T w 410 | $ 411 | 412 | Allerdings ermöglicht MLE es uns nun damit auch $sigma^2$ auszurechnen. Der 413 | genaue Weg dafür wird hier nicht gezeigt. Das Ergebnis sollte allerdings 414 | ungefähr so aussehen: 415 | $ 416 | sigma_"ML"^2 = 1/n sum_(i=1)^n (y_i - y(x_i, w_"ML"))^2 417 | $ 418 | #sub[Jan hats hier irgendwie hinbekommen $sigma (x_i)$ zu schreiben.] 419 | 420 | Damit ergibt sich dann also die Wsk.-Verteilung $p(t|x; w_"ML", sigma_"ML")$, 421 | dass unsere gesuchte Funktion an $x$ den Wert $t$ annimmt. 422 | 423 | #dangerous[Ab hier kommt etwas mehr Freitext bzw. freihändigere Interpretation 424 | von Jans Folien. Zudem wird die obige Rechnung nicht mehr wirklich fortgeführt.] 425 | 426 | Nun haben wir auf der einen Seite die Funktion $t=f(x)=y(x,w_"ML")$ zur 427 | Bestimmung des Werts von Datenpunkten und damit verbunden die Wsk. 428 | $p(t|x; w, sigma)$, dass $t$ der richtige Wert für $x$ ist. 429 | 430 | Unser Ziel ist es eine tatsächliche Schätzung über den Funktionswert $t$ für 431 | einen Datenpuntk $x$ abzugeben. Dafür können wir sogenannte *Loss Functions* 432 | nutzen: 433 | 434 | Im allgemeinen ist eine loss function erstmal eine Funktion 435 | $L: bb(R) times bb(R) -> bb(R)^+$, die unsere Schätzung $t$ und den 436 | tatsächlichen Funktionswert $f(x)$ als Eingabe bekommt. Also $L(t,f(x))$. Diese 437 | gibt an, wie falsch unsere Schätzung liegt bzw. was für einen Verlust wir im 438 | Vergleich zum eigentlichen Wert haben. 439 | 440 | Diese loss function, bzw. den Erwartungswert davon, wollen wir über alle Werte 441 | minimieren. Dafür stellen wir zuerst einmal wieder die Gleichung dafür auf: 442 | $ 443 | bb(E) [L] = integral integral L(t,f(x))p(x,t) dif x dif t 444 | $ 445 | 446 | Dazu betrachten wir jetzt einmal einen sehr simplen Fall der loss function und 447 | zwar squared loss bzw. quadratic loss: 448 | $ 449 | L(t,f(x)) = (t - f(x))^2 => 450 | bb(E) [L] = integral integral (t - f(x))^2 p(x,t) dif x dif t 451 | $ 452 | 453 | Nun können wir wieder analystisch ein Minimum finden: 454 | 455 | $ 456 | diff / (diff f(x)) bb(E) [L] &= -2 integral (t - f(x)) p(x,t) dif t = 0 &<=> \ 457 | integral t p(x,t) dif t &= f(x) integral p(x,t) dif t &<=> \ 458 | integral t p(x,t) dif t &= f(x) p(x) &=> \ 459 | f(x) &= integral t p(x,t)/p(x) dif t = integral t p(t | x) dif t \ 460 | f(x) &= bb(E)_(t ~ p(t | x)) [t] = bb(E) [t | x] 461 | $ 462 | 463 | Damit erhalten wir für squared loss, dass die optimale regression Funktion 464 | $bb(E) [t | x]$ von der Verteilung $p(t | x)$ ist. 465 | 466 | Basierend auf unserem vorherigen Beispiel erhalten wir damit: 467 | $ 468 | f(x) = integral t p(t | x; y(x, w_"ML"), sigma) dif t 469 | = integral t cal(N) (t; y(x, w_"ML"), sigma^2) dif t = y(x,w_"ML") 470 | $ 471 | 472 | === Bayesian Linear Regression 473 | 474 | Nun haben wir wohl wieder die üblichen Probleme, dass wir nur eine 475 | Punktschätzung machen. Darum wollen wir jetzt mal einen etwas mehr Bayesian 476 | Ansatz probieren. 477 | 478 | Dafür haben wir wieder Eingaben $X$, Ergebnisse $Y$ und Parameter $w$. Basierend 479 | darauf können wir nun allgemein erstmal folgendes aufstellen: 480 | - Prior: $p(w)$ 481 | - Likelihood: $p(Y | X,w)$ 482 | - Posterior: $p(w | X,Y)$ 483 | 484 | In unserem Beispiel packen wir erst einmal wieder Gaußverteilung auf die 485 | Parameter. Also $w ~ cal(N)(0,sigma_0^2 I)$. $sigma_0$ gibt dabei die 486 | Genauigkeit der Verteilung vor. Genaueres dazu kommt später noch. 487 | 488 | #note[$I$ steht für die Einheitsmatrix. Somit ist die Varianz auch eine Matrix, 489 | weswegen es sich hier um eine Multivariate Gaußverteilung handelt. Wird hier 490 | jetzt nicht genauer erklärt.] 491 | 492 | #note[Wir verwenden den Erwartungswert $0$, um die Abweichung zu beschränken. 493 | An sich ist hier aber eine beliebige Zahl möglich.] 494 | 495 | Wir erhalten somit die genauen Verteilungen: 496 | - Prior $p(w; sigma_0) = cal(N) (w; 0, sigma_0^2 I)$ 497 | - Posterior $p(w | X,Y; sigma_0, sigma)$ 498 | - Likelihood $p(Y | X,w; sigma)$ 499 | 500 | Sigma ist eben analog zu oben auch wieder die Standardabweichung der 501 | Gaußverteilung. 502 | 503 | Nun können wir gemäß MAP lösen, indem wir über $w$ maximieren. Dafür stellen 504 | wir erstmal wieder den Logarithmus vom Posterior auf: 505 | $ 506 | log p(w | X,Y; sigma_0, sigma) &= log p(Y | X, w; sigma) 507 | + log cal(N) (w; 0, sigma_0^2 I) \ 508 | &= sum_(i=1)^n log cal(N) (y_i | x_i, w; y(x_i,w),sigma^2) 509 | + log cal(N) (w; 0, sigma_0^2 I) \ 510 | &= - 1/(2 sigma^2) sum_(i=1)^n (y_i - y(x_i,w))^2 - 1/(2sigma_0^2) 511 | angle.l w | w angle.r 512 | $ 513 | 514 | #note[Laut Jan ist hier noch ein $+ "const"$. Ist aber nicht wirklich relevant, 515 | da wir eh gleich ableiten, wobei das wegfällt.] 516 | 517 | Und wieder Gradient bilden und gleich 0 setzen: 518 | 519 | $ 520 | gradient_w log p(w | X, Y; sigma_0, sigma) 521 | &= 1/sigma^2 sum_(i=1)^n (y_i - y(x_i,w)) - 1/sigma_0^2 w = 0 &<=> \ 522 | &dots.v "(Folien)" &<=> \ 523 | sigma^(-2) Phi Y &= (sigma^(-2) Phi Phi^T + sigma_0^(-2) I) w &<=> \ 524 | w_"MAP" &= (Phi Phi^T + sigma^2/sigma_0^2 I)^(-1) Phi Y 525 | $ 526 | 527 | #sub[JUHU endlich mal was neues.] 528 | 529 | Zuerst fassen wir den Term $sigma^2 slash sigma_0^2$ zu $lambda$ zusammen. 530 | 531 | Nun fragt sich bestimmt jeder vom Dorf bis zur Stadt: was macht dieses 532 | $lambda I$. Wie man in @lambda_complexity sehen kann, hat least squares (die 533 | bisher genutzte Loss/Error Function, die wir minimiert haben, siehe auch unsere 534 | Parameter Schätzungen von MLE) das "Problem", dass es für viele Punkte einen 535 | recht ähnlichen Wert annimmt. Dies ist eben dieses Tal im Graphen. Das ist eben 536 | ein Problem, weil dann bereits leichte Abweichung z.B. durch Rundungsfehler etc. 537 | bereits einen größeren Effekt auf die Wahl unserer Parameter haben, was eben 538 | schnell zu inkonsistenz (overfitting) führen kann. Deshalb fügen wir eben die 539 | "Bestrafung" $lambda I$ hinzu, damit wir dieses lange Tal in ein großes Minimum 540 | umwandeln, welches eben darauf abzielt unsere Parameter auf $0$ zu bewegen. 541 | Dadurch haben eben kleinere Änderungen nicht mehr so einen großen Effekt. 542 | 543 | #figure( 544 | caption: [Effekt von $lambda$ auf Least Squares], 545 | image("images/lambda_complexity.png", height: 4cm) 546 | ) 547 | 548 | $"beta1"$, $"beta2"$ sind eben einfach Parameter von der visualisierten 549 | Funktion und die z Achse beschreibt die Loss Function, also wie schlecht unsere 550 | Parameter sind. 551 | 552 | Damit können wir nun den allgemeinen Term für least squares error aufstellen: 553 | $ 554 | E_D (w) = 1/2 norm(Phi^T w - y)_2^2 = 1/2 sum_(i=1)^n (phi(x_i)^T w - y_i)^2 555 | $ 556 | #sub[(wann auch immer wir den kennengelernt haben.)] 557 | Dieser stellt eben den linken Graphen dar. 558 | 559 | Dazu können wir nun unseren regression error aufstellen: 560 | $ 561 | E_W (w) = lambda/2 norm(w)_2^2 = lambda/2 sum_(i=1)^n w_i^2 562 | $ 563 | #sub[Genauer wird jetzt hier nicht drauf eingegangen.] 564 | 565 | Zusammen erhalten wir den rechten Graphen: 566 | $ 567 | E(w) = E_D (w) + E_W (w) 568 | $ 569 | 570 | Jetzt würde man vermuten, dass man $lambda$ relativ hoch wählen sollte, damit 571 | wir jegliche Fehler vermeiden. Das sorgt nur für ein gewisses Problem. 572 | 573 | Denn was bisher noch nicht gesagt wurde, ist das $lambda$ bei uns auch 574 | kontrolliert, ob wir eher unseren beobachteten Daten, oder unserem Prior 575 | vertrauen. Wählen wir ein relativ hohes $lambda$ vertrauen wir zu sehr unserem 576 | Prior, wodurch wir eher eine Gerade Schätzen. Wählen wir hingegen ein zu kleines 577 | $lambda$ bekommen wir eben wieder overfitting, beziehen also zu viele 578 | Datenpunkte ein. Wir sagen auch, dass $lambda$ die komplexität unseres Modells 579 | kontrolliert. Dabei bedeutet ein kleineres $lambda$ eine größere Komplexität 580 | und ein größeres $lambda$ eine niedrigere Komplexität. 581 | 582 | Dazu betrachten wir nochmal $sigma^2 slash sigma_0^2$. $sigma^2$ ist hier der 583 | Parameter für die Gaußverteilung unserer Daten. Dieser ist fix und wir können 584 | diesen nicht anpassen. $sigma_0^2$ können wir hingegen anpassen. Wir erinnern 585 | uns: Dieser kontrolliert die Varianz unseres Priors. Die obige Behauptung 586 | können wir also hier auch wiederfinden: wählen wir ein kleines $sigma_0^2$ hat 587 | unser prior eine geringe Varianz, wodurch dieser sehr stark zu einem konkreten 588 | Wert tendiert -- wir legen also quasi einen festen Wert für den Prior fest. 589 | Unser $lambda$ wird auch entsprechend groß, da der Nenner klein wird. Senken 590 | wir anders herum unser $sigma_0^2$ erhöhen wir die Varianz auf unserem Prior -- 591 | dieser kann also eine größere Spanne an Werten annehmen und ist nicht mehr 592 | konkret festgelegt. Dadurch haben wir also mehr Fähigkeit unsere Parameter an 593 | unsere Daten anpassen, was sich analog in unserem $lambda$ wiederspiegelt. 594 | 595 | Laut Jan ist ein $lambda$ zwischen $10^(-6) N$ bis $10^(-8) N$, wobei $N$ die 596 | Größe des Datensatzes ist, am besten geeigent. $0.1 N$ ist hingegen schon ein 597 | sehr niedrige Komplexität bzw. sehr viel vertrauen in den Prior. 598 | 599 | #note[Jan teasert hiernach den Full Bayesian Regression Ansatz. Sofern dieser 600 | später nochmal ausführlicher kommt wird er dort aufgehührt. Hier ist das gerade 601 | nur unnötig Komplexität.] 602 | 603 | == Probabilistic Classification 604 | 605 | #note[Bitte nicht stark hier reinsteigern, man wird nur umso stärker 606 | enttäuscht.] 607 | 608 | Nun betrachten wir eine Methode, mit der man diese Funktion $f$ in einem 609 | Classification Problem bestimmen kann. Dabei betrachten wir jedoch nur eine 610 | sehr simple Methode. Diese heißt *Logistic Regression*. Diese hat die sehr 611 | simple Voraussetzung, dass wir auf nur zwei Werte abbilden. Also $O={C_1,C_2}$. 612 | Wir bezeichnen die einzelnen Komponenten unseres Bildbereich als Klassen, 613 | weswegen wir diese auch als $C_i$ kennzeichnen. 614 | 615 | Dafür wollen wir wieder ähnlich zu Bayesian Regression folgende Wsk. aufstellen: 616 | - Posterior $p(C_1 | x)$ 617 | - Likelihood $p(x | C_1)$ 618 | - Prior $p(C_1)$ 619 | - Evidence $p(x)$ 620 | 621 | Damit können wir dann folgendes berechnen: 622 | $ 623 | p(C_1 | x) &= (p(x | C_1) p(C_1)) /p(x) = (p(x | C_1) p(C_1)) / 624 | (sum_i p(x,C_i)) \ 625 | &= (p(x | C_1) p(C_1))/(sum_(i=1)^2 p(x | C_i) p(C_i)) \ 626 | &= (p(x |C_1) p(C_1)) / (p(x |C_1) p(C_1) + p(x | C_2) p(C_2)) \ 627 | &= 1/(1+exp (-a)) = sigma(a) "mit" 628 | a = log (p(x | C_1) p(C_1)) / (p(x | C_2) p(C_2)) 629 | $ 630 | $sigma(a)$ bezeichnet dabei die Sigmoid Funktion. Diese quetscht eine beliebige 631 | relle Zahl in das Intervall $[0,1]$. 632 | 633 | Nun ist es unser Ziel bestimmen zu können, ob eine Eingabe $x$ zu einer der 634 | beiden Klassen gehört. Wenn man sich mehrere Datenpunkte in einem Graphen 635 | vorstellt (siehe Folie 86) wollen wir anschaulich diese Trennlinie in der 636 | Mitte bestimmen. Damit sagen wir dann, dass alles auf der einen Seite zur einen 637 | und alles auf der anderen Seite zur anderen Klasse gehört. 638 | 639 | Wir setzen also $a=w x + epsilon_0$ und damit dann: 640 | $ 641 | p(C_1 | x) = sigma (w x + epsilon_0) 642 | $ 643 | 644 | #dangerous[Man beachte, dass dies ein lineare Linie zieht. Theoretisch könnten wir 645 | hier wahrscheinlich auch andere Funktionen einsetzen.] 646 | 647 | #note[Wieso genau wir das ganze über $a$ einsetzen können habe ich noch nicht 648 | verstanden. Man beachte zudem, dass auf den Folien wieder $w$ als Vektor 649 | angesehen wird.] 650 | 651 | Für bekannte Daten $X={x_1,...,x_n}$ und $Y={y_1,...,y_n}$, wobei für alle $y_i$ 652 | gilt: 653 | $ 654 | y_i = cases(0 quad &x_i "belongs to" C_1, 1 &x_i "belongs to" C_2) 655 | $ 656 | 657 | Mit Maximum Likelihood Regression erhalten wir dann: 658 | $ 659 | p(Y | X; w, epsilon_0) &= product_(i=1)^n p(y_i | x_i; w, epsilon_0) \ 660 | &=^* product_(i=1)^n p(C_1 | x_i; w, epsilon_0)^(1-y_i) 661 | p(C_2 | x_i; w, epsilon_0)^(y_i) \ 662 | &= product_(i=1)^n sigma (w x_i + epsilon_0)^(1-y_i) 663 | (1-sigma (w x_i + epsilon_0))^(y_i) 664 | $ 665 | 666 | $*$: Wir können dies anwenden, da einer der beiden Wsk. einen Exponenten von 0 667 | und der andere einen von 1 hat, wodurch wir am Ende wieder nur eine der beiden 668 | Wsk. haben, aber halt nun entsprechend der Klasse geordnet. 669 | 670 | Und ab hier bricht Jan dann ab. Seine Referenz zu Bishop scheint auch nur 671 | bedingt zu passen, da dort noch viel abgefahreners gemacht wird. 672 | 673 | == Probabilistic Clustering 674 | 675 | Im Vergleich zu davor haben wir nun nicht mehr so genaue Infos zu unseren 676 | Datenpunkten. Wir wissen also z.B. nicht, zu welchen Klassen diese gehören 677 | oder welche Klassen wir überhaupt haben. Dazu haben wir eben auch nicht mehr 678 | unbedingt nur 2 mögliche Klassen sondern eben ggf. mehr. 679 | 680 | Was wir also nun machen wollen ist Cluster -- also Gruppierungen -- in diesen 681 | gemessenen Daten zu finden und basierend darauf Klassen zu erstellen. 682 | Entsprechend betrachten wir die Cluster als latente Variablen, die es zu 683 | bestimmen gilt. 684 | 685 | Wir gehen also wieder in der Vermutung, dass unsere Daten von einer Verteilung 686 | generiet wurden -- bzw. einer Mischverteilung aus mehreren Verteilungen. Und nun 687 | wollen wir wieder von diesen Verteilungen die Parameter und Gewichtungen 688 | bestimmen. \ 689 | Wie zuvor auch verwenden wir hier wieder Gaußverteilungen. 690 | 691 | Nun kann man mal naiv versuchen mit MLE die Erwartungswerte $mu_j$ zu bestimmen. 692 | Die Standardabweichungen $sigma_j$ sind erstmal weniger relevant, da es uns 693 | primär um den Ort der Cluster geht. 694 | 695 | // TODO Basierend auf Forum aktualisieren. 696 | 697 | Wir haben also $n$ Datenpunkte ${x_1,...,x_n}$. Dazu haben wir $K$ Klassen 698 | $C_1,...,C_K$. 699 | 700 | Wir erhalten dann: 701 | $ 702 | cal(L) = log L(theta) &= sum_(i=1)^n log p(x_i | theta) \ 703 | (diff cal(L)) / (diff mu_j) &= 0 \ 704 | => hat(mu)_j &= (sum_(i=1)^n p(C_j | x_i) x_i)/(sum_(i=1)^n p(C_j | x_i)) 705 | $ 706 | 707 | Hier stoßen wir aber nun auf ein Problem. Unser Ziel ist es mittels diesen $mu$ 708 | die Zuteilung in die einzelnen Klassen zu bestimmen. Jetzt brauchen wir aber 709 | eben dafür bereits eine Zuteilung in diese Cluster, wodurch wir eine zyklische 710 | Abhängigkeit haben. Wenn wir unsere Daten jedoch bereits gut kennen -- also 711 | wieder Classification, wäre dies ein guter Ansatz zur Bestimmung der Klassen. 712 | 713 | #note[Ich kann keine Garantie geben, dass die Variablen korrekt benannt wurden, 714 | Jans Folien sind hier sehr komisch. Siehe ggf. Forenpost] 715 | 716 | Ein anderer Ansatz ist, dass wir ähnlich zu davor wieder die Ableitung bestimmen 717 | und uns dann wie eine Art Hill-Climbing Algorithmus zu einem Punkt bewegen, an 718 | dem der Gradient 0 wird. Dazu haben wir durch die Ableitung bereits die 719 | Steigung, wodurch wir nicht stichprobenartig um unsere aktuellen Position herum 720 | testen müssen, sondern direkt darüber die optimale Richtung bestimmen können. 721 | 722 | Ähnlich zu diesem Ansatz betrachten wir nun einmal den Expectation-Maximation 723 | (kurz EM) Algorithmus. 724 | 725 | Zuerst einmal stellen wir dafür die sogenannte "Responsibility" auf. Denn unser 726 | aktuelles Problem ist, dass wir nicht wissen, von welcher konkreten Verteilung 727 | bzw. welchen konkreten Parametern unser Datenpunkt erstellt bzw. maßgeblich 728 | beeinflusst wurde. Wenn wir uns jedoch einzelne Datenpunkte $x$ angucken bzw. 729 | diese analysieren können wir den Posterior über unsere Parameter bilden: 730 | $ 731 | p(j | x,theta) = p(j,x | theta)/p(x | theta) 732 | = (p(x | theta_j)p(j))/(sum_(i=1)^K p(x | theta_i) p(i)) = gamma_j (x) 733 | $ 734 | Die "Responsibility" gibt also an, wie wahrscheinlich es ist, dass die $j$-te 735 | Verteilung für unseren Datenpunkt verantwortlich ist. 736 | 737 | Um dies jedoch wirklich ausrechnen zu können, brauchen wir erneut entweder 738 | unsere Parameter oder eben die oben genutzten Wsk. Hier setzen wir nun an, indem 739 | wir diese zuerst schätzen. Und damit kommen wir auch schon zum genauen Ablauf 740 | des Algorithmus. 741 | 742 | #note[Es scheint so, als ob wir auch die Anzahl der Cluster $K$ schätzen, wie 743 | genau wird jedoch nur minimal in Kapitel 5 Folie 69f. behandelt.] 744 | 745 | + Parameter (in unserem Fall Erwartungswerte $mu_k$, Kovarianzmatrizen 746 | $Sigma_k$ und Gewichte $pi_k$) initialisieren 747 | + E-Step: Basierend auf diesen Parametern die responsibilities ausrechnen: 748 | $ 749 | gamma_j (x_i) = (pi_j cal(N) (x_i; mu_j, Sigma_j))/ 750 | (sum_(k=1)^K pi_k cal(N) (x_i; mu_k, Sigma_k)) "für alle" j in {1,...,K}, 751 | i in {1,...,n} 752 | $ 753 | + M-Step: Parameter basierend auf responsibilities neu schätzen: 754 | $ 755 | hat(n)_j &= sum_(i=1)^n gamma_j (x_i) \ 756 | hat(pi)_j &= hat(n)_j / n \ 757 | hat(mu)_j &= 1/hat(n)_j sum_(i=1)^n gamma_j (x_i) x_i \ 758 | hat(Sigma)_j &= 1/hat(n)_j sum_(i=1)^n gamma_j (x_i) (x_i - hat(mu)_j) 759 | (x_i - hat(mu)_j)^T (*) 760 | $ 761 | #note[$hat(n)_j$ bezeichnet dabei die Schätzung, wie viele Datenpunkte von 762 | der $j$-ten Verteilung erstellt wurden.] 763 | + Mittels Likelihood die neuen Parameter evaluieren und dann mit neuen 764 | Parametern wieder bei Schritt 2 starten. Dies solange machen bis keine starke 765 | Änderung mehr auftritt. 766 | 767 | Und damit erhalten wir dann am Ende auch gute Parameter. Wir laufen jedoch hier 768 | wieder in die Gefahr nur ein lokales Maximum zu finden. 769 | 770 | #digression([_Outer Product_])[ 771 | Als Hilfe zur Berechnung von $(*)$ sei noch das _Outer Product_ gezeigt. Auch 772 | wenn man sich die Struktur davon durch ausrechnen sehr leicht selbst herleiten 773 | kann, sei diese hier trotzdem einmal gezeigt: 774 | $ 775 | u v^T = vec(u_1, u_2, u_3, u_4) mat(v_1, v_2, v_3) = mat( 776 | u_1 v_1, u_1 v_2, u_1 v_3; 777 | u_2 v_1, u_2 v_2, u_2 v_3; 778 | u_3 v_1, u_3 v_2, u_3 v_3; 779 | u_4 v_1, u_4 v_2, u_4 v_3; 780 | ) 781 | $ 782 | Dies kann man dann eben auf beliebig große, reelle Vektoren übertragen. 783 | ] 784 | 785 | #line(length: 100%) 786 | 787 | *Changelog*: 788 | - 1.0 #sym.arrow.r 1.1: Fix von Formel für $hat(Sigma)_j$ in M-Step von EM 789 | Algorithmus und hinzufügen von _Outer Product_ Exkurs. 790 | - 1.1 #sym.arrow.r 1.1.1: Fix von Startindex bei Funktion $y$ und 791 | Rechtschreibfehler 792 | - 1.1.1 #sym.arrow.r 1.2: Fix von Erklärung für $;$ in Wsk und bessere Sprache 793 | 794 | // Ggf. noch einbauen: 795 | 796 | // MLE vs MAP: 797 | // MLE mit limitierten Daten ist gefährlich, da Varianz dann sehr niedrig. Somit 798 | // ggf. Division durch 0. MAP hingegen durch Subjektivität robuster. 799 | 800 | // Evidence $p(D)$ #sym.checkmark 801 | 802 | // $p(theta,D)$ nonsense 803 | 804 | // Alles auf probability density estimation reduzierbar --------------------------------------------------------------------------------