dominic/forschungstage-2023
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update

Browse Source
This commit is contained in:
Dominic Zimmer 2023-06-13 09:56:01 +02:00
parent 0781754674
commit 5ff87c07aa
2 changed files with 345 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

412
jupyter/The Art of Memory Loss.html
View File

@ -15534,9 +15534,9 @@ $$
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<p>Da die Übergangswahrscheinlichkeiten zum Zeitpunkt $t$ nur von $X_t$ abhängen, schreiben wir kurzerhand</p>
<p>Da die Übergangswahrscheinlichkeiten von Zeitpunkt $t$ zu Zeitpunkt $t+1$ nur von $X_t$ abhängen, schreiben wir kurzerhand</p>
$$
P(X_t = R | X_{t-1} = L) = P(L \to R) = m_{L R}
P(X_{t+1} = R | X_{t} = L) = P(L \to R) = m_{L R}
$$
</div>
</div>
@ -15568,7 +15568,7 @@ $$
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<p>Wir schreiben die Wahrscheinlichkeiten, dass der Frosch zum Zeitpunkt $t$ in $L$ oder $R$ ist, als Vektoren.</p>
$$
X_0 = \begin{pmatrix}1 \\ 0\end{pmatrix}
X_0 = \begin{pmatrix}1 &amp; 0\end{pmatrix}
$$
</div>
</div>
@ -15582,165 +15582,240 @@ $$
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<p>Ein Zeitschritt $t=0 \to t=1$ verändert die Verteilung gemäß $M$:</p>
$$
X_0 = \begin{pmatrix}1 \\ 0\end{pmatrix} \to \begin{pmatrix}1-p \\ p \end{pmatrix} = X_1
X_0 = \begin{pmatrix}1 &amp; 0\end{pmatrix} \to \begin{pmatrix}1-p &amp; p \end{pmatrix} = X_1
$$
</div>
</div>
</div>
</div><div id="cell-id=e9f7e2f6" class="jp-Cell jp-CodeCell jp-Notebook-cell jp-mod-noOutputs ">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea">
<div class="jp-InputPrompt jp-InputArea-prompt">In&nbsp;[11]:</div>
<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
<div class="CodeMirror cm-s-jupyter">
<div class=" highlight hl-ipython3"><pre><span></span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span> <span class="k">as</span> <span class="n">S</span><span class="p">,</span> <span class="n">Matrix</span> <span class="k">as</span> <span class="n">Mat</span>
<span class="n">p</span><span class="p">,</span> <span class="n">q</span> <span class="o">=</span> <span class="n">S</span><span class="p">(</span><span class="s2">&quot;p q&quot;</span><span class="p">)</span>
<span class="n">M</span> <span class="o">=</span> <span class="n">Mat</span><span class="p">([[</span><span class="mi">1</span><span class="o">-</span><span class="n">p</span><span class="p">,</span> <span class="n">p</span><span class="p">],</span> <span class="p">[</span><span class="n">q</span><span class="p">,</span> <span class="mi">1</span><span class="o">-</span><span class="n">q</span><span class="p">]])</span>
</pre></div>
</div>
</div>
</div>
</div>
</div>
<div id="cell-id=0d56b780" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div id="cell-id=713b6dda" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<h1 id="Matrixmultiplikation">Matrixmultiplikation<a class="anchor-link" href="#Matrixmultiplikation">&#182;</a></h1>
</div>
</div>
</div>
</div><div id="cell-id=c8a105d0" class="jp-Cell jp-CodeCell jp-Notebook-cell ">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea">
<div class="jp-InputPrompt jp-InputArea-prompt">In&nbsp;[19]:</div>
<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
<div class="CodeMirror cm-s-jupyter">
<div class=" highlight hl-ipython3"><pre><span></span><span class="kn">from</span> <span class="nn">numpy.linalg</span> <span class="kn">import</span> <span class="n">matrix_power</span>
<span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">simplify</span>
<span class="n">x_0</span> <span class="o">=</span> <span class="n">Mat</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">]])</span>
<span class="p">[</span> <span class="p">(</span><span class="n">x_0</span> <span class="o">@</span> <span class="p">(</span><span class="n">matrix_power</span><span class="p">(</span><span class="n">M</span><span class="p">,</span> <span class="n">i</span><span class="p">)))</span><span class="o">.</span><span class="n">subs</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="mf">0.6</span><span class="p">)</span><span class="o">.</span><span class="n">subs</span><span class="p">(</span><span class="n">q</span><span class="p">,</span> <span class="mf">0.2</span><span class="p">)</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">)]</span>
</pre></div>
</div>
</div>
</div>
</div>
<div class="jp-Cell-outputWrapper">
<div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
</div>
<div class="jp-OutputArea jp-Cell-outputArea">
<div class="jp-OutputArea-child jp-OutputArea-executeResult">
<div class="jp-OutputPrompt jp-OutputArea-prompt">Out[19]:</div>
<div class="jp-RenderedText jp-OutputArea-output jp-OutputArea-executeResult" data-mime-type="text/plain">
<pre>[Matrix([[1, 0]]),
Matrix([[0.4, 0.6]]),
Matrix([[0.28, 0.72]]),
Matrix([[0.256, 0.744]]),
Matrix([[0.2512, 0.7488]]),
Matrix([[0.25024, 0.74976]]),
Matrix([[0.250048, 0.749952]]),
Matrix([[0.2500096, 0.7499904]]),
Matrix([[0.25000192, 0.74999808]]),
Matrix([[0.250000384, 0.749999616000001]])]</pre>
</div>
</div>
</div>
</div>
</div>
<div id="cell-id=5db5186d" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<p>Den Folgezustand von $X = \begin{pmatrix}L &amp; R\end{pmatrix}$ mit Übergangsmatrix $M$ berechnen wir als</p>
<p>Aus einem gegebenen</p>
$$
X_0 = \begin{pmatrix}1 &amp; 0 \end{pmatrix}
$$<p>können wir das <em>Vektor-Matrix-Produkt</em></p>
$$
\begin{align*}
\begin{pmatrix}L' \\ R'\end{pmatrix}^T &amp;= \begin{pmatrix}L &amp; R\end{pmatrix} \cdot M \\
&amp;= \begin{pmatrix}L &amp; R\end{pmatrix} \cdot \begin{pmatrix} \color{green}{1 - p} &amp; \color{orange}{p} \\ \color{green}{q} &amp; \color{orange}{1-q} \end{pmatrix} \\
=&amp; \begin{pmatrix}L \cdot \color{green}{(1 - p)} + R \cdot \color{green}{q} \\
L \cdot \color{orange}{p} + R \cdot \color{orange}{(1-q)}
\end{pmatrix}^T
X_1 &amp;= X_0 \cdot M \\
&amp;= \begin{pmatrix} 1 &amp; 0 \end{pmatrix}\cdot{}\begin{pmatrix}1-p &amp; p \\q &amp; 1-q\end{pmatrix} = \begin{pmatrix}1-p &amp; p \end{pmatrix}
\end{align*}
$$
$$<p>ausrechnen.</p>
</div>
</div>
</div>
</div>
<div id="cell-id=782d4f7a" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div id="cell-id=5d09684e" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<blockquote>
<p>Man berechnet die neuen Einträge als &quot;Zeile mal Spalte&quot;</p>
<p>Matrixmultiplikation rechnet &quot;Zeile mal Spalte&quot;</p>
</blockquote>
$$
\begin{align*}
&amp; X_0 \cdot M \\
&amp;= \begin{pmatrix} 1 &amp; 0 \end{pmatrix} \cdot{} \begin{pmatrix} \color{green}{1 - p} &amp; \color{orange}{p} \\ \color{green}{q} &amp; \color{orange}{1-q} \end{pmatrix} \\
&amp;= \begin{pmatrix}
\begin{pmatrix} 1 &amp; 0 \end{pmatrix}\bullet{}\begin{pmatrix} \color{green}{1 - p} \\ \color{green}{q}\end{pmatrix} &amp;
\begin{pmatrix} 1 &amp; 0 \end{pmatrix}\bullet{}\begin{pmatrix} \color{orange}{p} \\ \color{orange}{1-q} \end{pmatrix}
\end{pmatrix}\\
&amp;= \begin{pmatrix} \color{green}{1 - p}&amp; \color{orange}{p}
\end{pmatrix}
\end{align*}
$$<p>Die Einträge von $X_1 = X_0 \cdot M$ errechnen sich genau so, wie die Folgezustände $L'$ und $R'$ aus $L$ und $R$.</p>
</div>
</div>
</div>
</div>
<div id="cell-id=77e76bcd" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<h1 id="Wetterfr%C3%B6sche">Wetterfr&#246;sche<a class="anchor-link" href="#Wetterfr%C3%B6sche">&#182;</a></h1>
</div>
</div>
</div>
</div>
<div id="cell-id=acbfdea5" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<div class="alert alert-info">
<p>In Froschland ändert sich das Wetter jeden Tag. Es gibt <strong>Sonnenschein</strong>, <strong>Regen</strong> und <strong>bewölkte</strong> Tage.</p>
<p>Je nach heutigem Wetter variiert die Wahrscheinlichkeit für das morgige Wetter:</p>
<ul>
<li>30% der Tage verschlechtert sich das Wetter $S \to B \to R$</li>
<li>30% der Tage bleibt es nach wolkigen Tagen wolkig</li>
<li>10% der Tage schwingt das Wetter <em>extrem</em> um</li>
<li>40% der Tage regnet es nach Regen weiter</li>
</ul>
</div>
</div>
</div>
</div>
</div>
<div id="cell-id=c3ebdfd9" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<div class="alert alert-success">
<ol>
<li>Zeichne den Graphen und stelle die Übergangsmatrix $M$ auf</li>
<li>Implementiere das Froschwetter in python</li>
<li>Was ist das erwartete Wetter 14 Tage nach Regen, Wolken oder Sonne?</li>
</ol>
</div>
</div>
</div>
</div>
</div>
<div id="cell-id=30f295ea" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<p>Die Übergangsmatrix des Froschwetters</p>
$$
\begin{align*}
M = \frac{1}{10} \begin{pmatrix}6 &amp; 3 &amp; 1 \\ 4 &amp; 3 &amp; 3 \\ 1 &amp; 5 &amp; 4 \end{pmatrix}
= \begin{pmatrix}0.6 &amp; 0.3 &amp; 0.1 \\ 0.4 &amp; 0.3 &amp; 0.3 \\ 0.1 &amp; 0.5 &amp; 0.4 \end{pmatrix}
\end{align*}
$$<p>Wenn es heute regnet $X_0 = \begin{pmatrix}1 &amp; 0 &amp; 0 \end{pmatrix}$, ist die Wettervorschau für morgen $X_0 \cdot M$, bzw für in einer Woche $X_0 \cdot M \cdot \dots M = X_0 \cdot M^{14}$.</p>
</div>
</div>
</div>
</div>
<div id="cell-id=e4cb8f44" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<h1 id="Matrixmultiplikation">Matrixmultiplikation<a class="anchor-link" href="#Matrixmultiplikation">&#182;</a></h1>$$
\begin{align*}
X_1 &amp;= \begin{pmatrix}1 &amp; 0 &amp; 0\end{pmatrix} \cdot \begin{pmatrix}0.6 &amp; 0.3 &amp; 0.1 \\ 0.4 &amp; 0.3 &amp; 0.3 \\ 0.1 &amp; 0.5 &amp; 0.4 \end{pmatrix} \\
&amp;=
\begin{pmatrix}
\begin{pmatrix}1 &amp; 0 &amp; 0\end{pmatrix}\bullet \begin{pmatrix} 0.6 \\ 0.4 \\ 0.1 \end{pmatrix} &amp;
\begin{pmatrix}1 &amp; 0 &amp; 0\end{pmatrix}\bullet \begin{pmatrix} 0.3 \\ 0.3 \\ 0.5 \end{pmatrix} &amp;
\begin{pmatrix}1 &amp; 0 &amp; 0\end{pmatrix}\bullet \begin{pmatrix} 0.1 \\ 0.3 \\ 0.4 \end{pmatrix}
\end{pmatrix}
\end{align*}
$$<p>Wir können also $X_{t+1} = X_t \cdot{} M$ ausrechnen. Allerdings könnten wir auch $M^{14}$ ausrechnen und einmal $X_0 \cdot M^{14}$ berechnen.</p>
<p>Wir rechnen $v \cdot M$ als</p>
<blockquote>
<p>Zeile mal Spalte, für alle Spalten von $M$</p>
</blockquote>
</div>
</div>
</div>
</div>
<div id="cell-id=daddfd1e" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<h2 id="Beispiele">Beispiele<a class="anchor-link" href="#Beispiele">&#182;</a></h2>$$
\begin{pmatrix}1 &amp; 0\end{pmatrix}\cdot M = \begin{pmatrix}1-p &amp; p\end{pmatrix}
$$
</div>
</div>
</div>
</div>
<div id="cell-id=c1a6597e" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div id="cell-id=da04fda2" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<p>Ein Matrixprodukt $M_1 \cdot M_2$ berechnet sich als</p>
<blockquote>
<p>für jede Zeile von $M_1$: Zeile mal Spalte, für alle Spalten von $M_2$</p>
</blockquote>
$$
\begin{align*}
\begin{pmatrix}1 \\ 1\end{pmatrix}^T\cdot M &amp;= \begin{pmatrix} (1-p) + q \\ p + (1-q)\end{pmatrix}^T \\
&amp; = \begin{pmatrix} (1-p) + q \\ p +(1-q)\end{pmatrix}^T \\
M^2 &amp;= \begin{pmatrix}0.6 &amp; 0.3 &amp; 0.1 \\ 0.4 &amp; 0.3 &amp; 0.3 \\ 0.1 &amp; 0.5 &amp; 0.4 \end{pmatrix} \cdot \begin{pmatrix}0.6 &amp; 0.3 &amp; 0.1 \\ 0.4 &amp; 0.3 &amp; 0.3 \\ 0.1 &amp; 0.5 &amp; 0.4 \end{pmatrix} \\
&amp;=
\begin{pmatrix}
\begin{pmatrix}0.6 &amp; 0.3 &amp; 0.1 \end{pmatrix}\bullet \begin{pmatrix} 0.6 \\ 0.4 \\ 0.1 \end{pmatrix} &amp;
\begin{pmatrix}0.6 &amp; 0.3 &amp; 0.1\end{pmatrix}\bullet \begin{pmatrix} 0.3 \\ 0.3 \\ 0.5 \end{pmatrix} &amp;
\begin{pmatrix}0.6 &amp; 0.3 &amp; 0.1\end{pmatrix}\bullet \begin{pmatrix} 0.1 \\ 0.3 \\ 0.4 \end{pmatrix}\\
\begin{pmatrix}0.4 &amp; 0.3 &amp; 0.3 \end{pmatrix}\bullet \begin{pmatrix} 0.6 \\ 0.4 \\ 0.1 \end{pmatrix} &amp;
\begin{pmatrix}0.4 &amp; 0.3 &amp; 0.3\end{pmatrix}\bullet \begin{pmatrix} 0.3 \\ 0.3 \\ 0.5 \end{pmatrix} &amp;
\begin{pmatrix}0.4 &amp; 0.3 &amp; 0.3\end{pmatrix}\bullet \begin{pmatrix} 0.1 \\ 0.3 \\ 0.4 \end{pmatrix}\\
\begin{pmatrix}0.1 &amp; 0.5 &amp; 0.4\end{pmatrix}\bullet \begin{pmatrix} 0.6 \\ 0.4 \\ 0.1 \end{pmatrix} &amp;
\begin{pmatrix}0.1 &amp; 0.5 &amp; 0.4 \end{pmatrix}\bullet \begin{pmatrix} 0.3 \\ 0.3 \\ 0.5 \end{pmatrix} &amp;
\begin{pmatrix}0.1 &amp; 0.5 &amp; 0.4 \end{pmatrix}\bullet \begin{pmatrix} 0.1 \\ 0.3 \\ 0.4 \end{pmatrix}
\end{pmatrix}
\end{align*}
$$
</div>
</div>
</div>
</div><div id="cell-id=aa2e9aca" class="jp-Cell jp-CodeCell jp-Notebook-cell ">
</div>
<div id="cell-id=72e9e966" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<p>Um $X_{14}$ auszurechnen könnten wir 14 Vektor-Matrix multiplikationen rechnen
$$
X_{14} = X_0 \cdot M \cdot \dots \cdot M
$$</p>
<p>Oder stattdessen $M^{14}$ berechnen und mit einer Vektor-Matrix multiplikation
$$
X_{14} = X_0 \cdot M^{14}
$$
ausrechnen.</p>
<div class="alert alert-danger">
Matrix-Matrix multiplikationen sind schlimmer als Vektor-Matrix multiplikationen.
</div>
<div class="alert alert-warning">
Können wir $M^{14}$ irgendwie effizienter ausrechnen als $M \cdot M \cdot \dots \cdot M = M^{14}$
</div>
<div class="alert alert-success">
$$
M^{14} = {(M^7)}^2 = {(M \cdot M^6)}^2 = {(M \cdot {(M^3)}^2)}^2 = {(M \cdot {(M \cdot M \cdot M)}^2)}^2
$$
</div>
</div>
</div>
</div>
</div>
<div id="cell-id=4bcc0720" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<p>$\leadsto$ Insgesamt fünf M-M Multiplikationen und eine V-M Multiplikation.</p>
</div>
</div>
</div>
</div><div id="cell-id=e9f7e2f6" class="jp-Cell jp-CodeCell jp-Notebook-cell ">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea">
<div class="jp-InputPrompt jp-InputArea-prompt">In&nbsp;[4]:</div>
<div class="jp-InputPrompt jp-InputArea-prompt">In&nbsp;[9]:</div>
<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
<div class="CodeMirror cm-s-jupyter">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">v1</span> <span class="o">=</span> <span class="n">Mat</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">]])</span>
<span class="n">v1</span> <span class="o">*</span> <span class="n">M</span>
<div class=" highlight hl-ipython3"><pre><span></span><span class="c1">#from sympy import symbols as S, Matrix as Mat</span>
<span class="kn">from</span> <span class="nn">numpy</span> <span class="kn">import</span> <span class="n">array</span>
<span class="n">M</span> <span class="o">=</span> <span class="n">array</span><span class="p">([[</span><span class="mf">0.6</span><span class="p">,</span> <span class="mf">0.3</span><span class="p">,</span> <span class="mf">0.1</span><span class="p">],</span> <span class="p">[</span><span class="mf">0.4</span><span class="p">,</span> <span class="mf">0.3</span><span class="p">,</span> <span class="mf">0.3</span><span class="p">],</span> <span class="p">[</span><span class="mf">0.1</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">,</span> <span class="mf">0.4</span><span class="p">]])</span>
<span class="n">x0</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]</span>
<span class="n">x0</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span> <span class="o">@</span> <span class="n">M</span>
</pre></div>
</div>
@ -15756,13 +15831,13 @@ $$
<div class="jp-OutputArea jp-Cell-outputArea">
<div class="jp-OutputArea-child jp-OutputArea-executeResult">
<div class="jp-OutputPrompt jp-OutputArea-prompt">Out[4]:</div>
<div class="jp-OutputPrompt jp-OutputArea-prompt">Out[9]:</div>
<div class="jp-RenderedLatex jp-OutputArea-output jp-OutputArea-executeResult" data-mime-type="text/latex">
$\displaystyle \left[\begin{matrix}1 - p &amp; p\end{matrix}\right]$
<div class="jp-RenderedText jp-OutputArea-output jp-OutputArea-executeResult" data-mime-type="text/plain">
<pre>array([0.40909225, 0.3484844 , 0.24242335])</pre>
</div>
</div>
@ -15771,16 +15846,71 @@ $\displaystyle \left[\begin{matrix}1 - p &amp; p\end{matrix}\right]$
</div>
</div><div id="cell-id=b31deb83" class="jp-Cell jp-CodeCell jp-Notebook-cell ">
</div><div id="cell-id=ae437f47" class="jp-Cell jp-CodeCell jp-Notebook-cell jp-mod-noOutputs ">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea">
<div class="jp-InputPrompt jp-InputArea-prompt">In&nbsp;[5]:</div>
<div class="jp-InputPrompt jp-InputArea-prompt">In&nbsp;[&nbsp;]:</div>
<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
<div class="CodeMirror cm-s-jupyter">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">v2</span> <span class="o">=</span> <span class="n">Mat</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">]])</span>
<span class="n">v2</span> <span class="o">*</span> <span class="n">M</span>
<div class=" highlight hl-ipython3"><pre><span></span><span class="kn">from</span> <span class="nn">numpy</span> <span class="kn">import</span> <span class="n">linalg</span>
<span class="n">x0</span> <span class="o">@</span> <span class="n">linalg</span><span class="o">.</span><span class="n">matrix_power</span><span class="p">(</span><span class="n">M</span><span class="p">,</span> <span class="mi">14</span><span class="p">)</span>
</pre></div>
</div>
</div>
</div>
</div>
</div>
<div id="cell-id=90ae2b14" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<h4 id="Mehr-als-die-halbe-Wahrheit">Mehr als die halbe Wahrheit<a class="anchor-link" href="#Mehr-als-die-halbe-Wahrheit">&#182;</a></h4><p>Sehr brave Markovketten konvergieren mit $t \to \infty$ gegen eine eindeutige stationäre Verteilung $X^*$.
Mathematisch lässt sich diese Verteilung durch</p>
$$
X^* \cdot M \overset{!}{=} X^*
$$<p>ausdrücken und explizit als Lösung des Gleichungssystems (denn Matrizen stellen mehrere Gleichungen dar) ausrechnen.
Um eine stochastische Verteilung zu erhalten, brauchen wir die zusätzliche Gleichung</p>
$$
1 = \sum_{i} X^*_i.
$$<p>Allgemein drückt man Lösungen der oberen Gleichung durch die Form</p>
$$
v^* M = \lambda v^*
$$<p>aus. Hierbei ist $\lambda != 0$ eine Zahl, die man auch <em>Eigenwert</em> nennt. Eine Lösung für die Eigenwertgleichung ist also ein Vektor $v^*$, der sich nach Matrixmultiplikation mit $M$ um den Faktor $\lambda$ streckt, allerdings seine Richtung beibehält. Da in der obigen Gleichung der Streckfaktor $\lambda = 1$ ist, nennen wir $X^*$ <em>Eigenvektor von $M$ zum Eigenwert $1$</em>.</p>
<p>In python können wir die Eigenwerte und -Vektoren berechnen lassen:</p>
</div>
</div>
</div>
</div><div id="cell-id=aa7a66a1" class="jp-Cell jp-CodeCell jp-Notebook-cell ">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea">
<div class="jp-InputPrompt jp-InputArea-prompt">In&nbsp;[13]:</div>
<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
<div class="CodeMirror cm-s-jupyter">
<div class=" highlight hl-ipython3"><pre><span></span><span class="c1"># linalg.eig berechnet Rechts-Eigenvektoren von Matrizen, wir suchen allerdings Links-Eigenvektoren</span>
<span class="c1"># Um zum richtigen Ergebnis zu kommen, müssen wir M also spiegeln (M.transpose())</span>
<span class="n">ews</span><span class="p">,</span> <span class="n">evs</span> <span class="o">=</span> <span class="n">linalg</span><span class="o">.</span><span class="n">eig</span><span class="p">(</span><span class="n">M</span><span class="o">.</span><span class="n">transpose</span><span class="p">())</span> <span class="c1"># berechnet Eigenwerte und Eigenvektoren</span>
<span class="c1"># Wir sehen, dass ews[0] der Eigenwert 1 ist</span>
<span class="nb">print</span><span class="p">(</span><span class="n">ews</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
<span class="c1"># Folglich ist die 0-te Spalte von evs der dazugehörige Eigenvektor</span>
<span class="n">v</span> <span class="o">=</span> <span class="n">evs</span><span class="p">[:,</span><span class="mi">0</span><span class="p">]</span>
<span class="c1"># Wir müssen v auf Länge 1 skalieren, dass v ein stochastischer Vektor ist</span>
<span class="n">v</span> <span class="o">/=</span> <span class="nb">sum</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="c1"># Wir sehen, dass v und v@M der gleiche Vektor sind.</span>
<span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">v</span> <span class="o">@</span> <span class="n">M</span><span class="p">)</span>
</pre></div>
</div>
@ -15794,15 +15924,17 @@ $\displaystyle \left[\begin{matrix}1 - p &amp; p\end{matrix}\right]$
<div class="jp-OutputArea jp-Cell-outputArea">
<div class="jp-OutputArea-child jp-OutputArea-executeResult">
<div class="jp-OutputArea-child">
<div class="jp-OutputPrompt jp-OutputArea-prompt">Out[5]:</div>
<div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
<div class="jp-RenderedLatex jp-OutputArea-output jp-OutputArea-executeResult" data-mime-type="text/latex">
$\displaystyle \left[\begin{matrix}- p + q + 1 &amp; p - q + 1\end{matrix}\right]$
<div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain">
<pre>0.9999999999999989
[0.40909091 0.34848485 0.24242424]
[0.40909091 0.34848485 0.24242424]
</pre>
</div>
</div>
</div>
@ -15810,9 +15942,7 @@ $\displaystyle \left[\begin{matrix}- p + q + 1 &amp; p - q + 1\end{matrix}\right
</div>
</div>
</div>
<div id="cell-id=e9c1e7e7" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div id="cell-id=b7f0b716" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
@ -15828,7 +15958,7 @@ Wie können wir aus den 7 Fröschen <strong>fair</strong> einen auswählen?</p>
</div>
</div>
</div>
<div id="cell-id=a372acd0" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div id="cell-id=ddfdfa5e" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
@ -15933,6 +16063,24 @@ Wie können wir aus den 7 Fröschen <strong>fair</strong> einen auswählen?</p>
<li>jede Zeile summiert sich zu $1$</li>
</ul>
</div>
</div>
</div>
</div>
<div id="cell-id=786f76e8" class="jp-Cell jp-MarkdownCell jp-Notebook-cell">
<div class="jp-Cell-inputWrapper">
<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
</div>
<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
$$
\begin{align*}
X_1 &amp;= X_0 \cdot{} M \\
X_2 &amp;= X_1 \cdot{} M = (X_0 \cdot M) \cdot{} M = X_0 \cdot M^2 \\
&amp; \vdots \\
X_n &amp;= X_0 \cdot \underbrace{M \cdot{} \dots \cdot M}_{\text{$n$ mal}} = X_0 \cdot M^n
\end{align*}
$$
</div>
</div>
</div>

240
jupyter/The Art of Memory Loss.ipynb
View File

@ -870,7 +870,7 @@
},
{
"cell_type": "markdown",
"id": "d7a2f813",
"id": "da04fda2",
"metadata": {
"hideCode": false,
"hidePrompt": false,
@ -909,7 +909,10 @@
"hidePrompt": false,
"slideshow": {
"slide_type": "subslide"
}
},
"tags": [
"hide_cell"
]
},
"source": [
"Um $X_{14}$ auszurechnen könnten wir 14 Vektor-Matrix multiplikationen rechnen\n",
@ -934,13 +937,16 @@
},
{
"cell_type": "markdown",
"id": "80c060ae",
"id": "f0d467f4",
"metadata": {
"hideCode": false,
"hidePrompt": false,
"slideshow": {
"slide_type": "fragment"
}
},
"tags": [
"hide_cell"
]
},
"source": [
"<div class=\"alert alert-success\">\n",
@ -952,7 +958,7 @@
},
{
"cell_type": "markdown",
"id": "a6633c2b",
"id": "72e9e966",
"metadata": {
"hideCode": false,
"hidePrompt": false,
@ -988,7 +994,7 @@
},
{
"cell_type": "markdown",
"id": "72f34537",
"id": "4bcc0720",
"metadata": {
"slideshow": {
"slide_type": "fragment"
@ -1033,7 +1039,7 @@
{
"cell_type": "code",
"execution_count": null,
"id": "73dd4797",
"id": "ae437f47",
"metadata": {
"slideshow": {
"slide_type": "fragment"
@ -1046,171 +1052,74 @@
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2454075a",
"cell_type": "markdown",
"id": "d628c382",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"# Alternatively using linalg\n",
"# v = linalg.eig(M.transpose())[1][:,0]\n",
"# v /= sum(v)\n",
"# v @ M"
]
},
{
"cell_type": "markdown",
"id": "0d56b780",
"metadata": {
"hideCode": false,
"hidePrompt": false,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Matrixmultiplikation"
]
},
{
"cell_type": "markdown",
"id": "5db5186d",
"metadata": {
"hideCode": false,
"hidePrompt": false,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Den Folgezustand von $X = \\begin{pmatrix}L & R\\end{pmatrix}$ mit Übergangsmatrix $M$ berechnen wir als\n",
"#### Mehr als die halbe Wahrheit\n",
"\n",
"Sehr brave Markovketten konvergieren mit $t \\to \\infty$ gegen eine eindeutige stationäre Verteilung $X^*$.\n",
"Mathematisch lässt sich diese Verteilung durch\n",
"\n",
"$$\n",
"\\begin{align*}\n",
"\\begin{pmatrix}L' \\\\ R'\\end{pmatrix}^T &= \\begin{pmatrix}L & R\\end{pmatrix} \\cdot M \\\\\n",
"&= \\begin{pmatrix}L & R\\end{pmatrix} \\cdot \\begin{pmatrix} \\color{green}{1 - p} & \\color{orange}{p} \\\\ \\color{green}{q} & \\color{orange}{1-q} \\end{pmatrix} \\\\\n",
"=& \\begin{pmatrix}L \\cdot \\color{green}{(1 - p)} + R \\cdot \\color{green}{q} \\\\\n",
"L \\cdot \\color{orange}{p} + R \\cdot \\color{orange}{(1-q)} \n",
"\\end{pmatrix}^T\n",
"\\end{align*}\n",
"$$"
]
},
{
"cell_type": "markdown",
"id": "782d4f7a",
"metadata": {
"hideCode": false,
"hidePrompt": false,
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"> Man berechnet die neuen Einträge als \"Zeile mal Spalte\""
]
},
{
"cell_type": "markdown",
"id": "daddfd1e",
"metadata": {
"hideCode": false,
"hidePrompt": false,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## Beispiele\n",
" X^* \\cdot M \\overset{!}{=} X^*\n",
"$$\n",
"\n",
"ausdrücken und explizit als Lösung des Gleichungssystems (denn Matrizen stellen mehrere Gleichungen dar) ausrechnen.\n",
"Um eine stochastische Verteilung zu erhalten, brauchen wir die zusätzliche Gleichung\n",
"\n",
"$$\n",
"\\begin{pmatrix}1 & 0\\end{pmatrix}\\cdot M = \\begin{pmatrix}1-p & p\\end{pmatrix}\n",
"$$"
]
},
{
"cell_type": "markdown",
"id": "c1a6597e",
"metadata": {
"hideCode": false,
"hidePrompt": false,
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"1 = \\sum_{i} X^*_i.\n",
"$$\n",
"\\begin{align*}\n",
"\\begin{pmatrix}1 \\\\ 1\\end{pmatrix}^T\\cdot M &= \\begin{pmatrix} (1-p) + q \\\\ p + (1-q)\\end{pmatrix}^T \\\\\n",
"& = \\begin{pmatrix} (1-p) + q \\\\ p +(1-q)\\end{pmatrix}^T \\\\\n",
"\\end{align*}\n",
"$$"
"\n",
"Allgemein drückt man Lösungen der oberen Gleichung durch die Form\n",
"\n",
"$$\n",
"v^* M = \\lambda v^*\n",
"$$\n",
"\n",
"aus. Hierbei ist $\\lambda != 0$ eine Zahl, die man auch *Eigenwert* nennt. Eine Lösung für die Eigenwertgleichung ist also ein Vektor $v^*$, der sich nach Matrixmultiplikation mit $M$ um den Faktor $\\lambda$ streckt, allerdings seine Richtung beibehält. Da in der obigen Gleichung der Streckfaktor $\\lambda = 1$ ist, nennen wir $X^*$ *Eigenvektor von $M$ zum Eigenwert $1$*.\n",
"\n",
"In python können wir die Eigenwerte und -Vektoren berechnen lassen:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "aa2e9aca",
"metadata": {
"hideCode": false,
"hidePrompt": false,
"slideshow": {
"slide_type": "fragment"
}
},
"execution_count": 13,
"id": "947ce4b1",
"metadata": {},
"outputs": [
{
"data": {
"text/latex": [
"$\\displaystyle \\left[\\begin{matrix}1 - p & p\\end{matrix}\\right]$"
],
"text/plain": [
"Matrix([[1 - p, p]])"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
"name": "stdout",
"output_type": "stream",
"text": [
"0.9999999999999989\n",
"[0.40909091 0.34848485 0.24242424]\n",
"[0.40909091 0.34848485 0.24242424]\n"
]
}
],
"source": [
"v1 = Mat([[1, 0]])\n",
"v1 * M"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "b31deb83",
"metadata": {
"hideCode": false,
"hidePrompt": false,
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/latex": [
"$\\displaystyle \\left[\\begin{matrix}- p + q + 1 & p - q + 1\\end{matrix}\\right]$"
],
"text/plain": [
"Matrix([[-p + q + 1, p - q + 1]])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"v2 = Mat([[1, 1]])\n",
"v2 * M"
"# linalg.eig berechnet Rechts-Eigenvektoren von Matrizen, wir suchen allerdings Links-Eigenvektoren\n",
"# Um zum richtigen Ergebnis zu kommen, müssen wir M also spiegeln (M.transpose())\n",
"ews, evs = linalg.eig(M.transpose()) # berechnet Eigenwerte und Eigenvektoren\n",
"\n",
"# Wir sehen, dass ews[0] der Eigenwert 1 ist\n",
"print(ews[0])\n",
"\n",
"# Folglich ist die 0-te Spalte von evs der dazugehörige Eigenvektor\n",
"v = evs[:,0]\n",
"\n",
"# Wir müssen v auf Länge 1 skalieren, dass v ein stochastischer Vektor ist\n",
"v /= sum(v)\n",
"\n",
"# Wir sehen, dass v und v@M der gleiche Vektor sind.\n",
"print(v)\n",
"print(v @ M)"
]
},
{
@ -1272,7 +1181,9 @@
},
"source": [
"<div class=\"alert alert-warning\">\n",
"Von allen Fröschen ist einer am unvertrauenswürdigsten. Die anderen sieben Frösche haben sich geeinigt, dass unter ihnen ausgelost werden soll. \n",
" \n",
"Von allen Fröschen ist einer am unvertrauenswürdigsten. Die anderen sieben Frösche haben sich geeinigt, dass unter *ihnen* ausgelost werden soll. \n",
" \n",
"</div>"
]
},
@ -1405,27 +1316,6 @@
"- jede Zeile summiert sich zu $1$"
]
},
{
"cell_type": "markdown",
"id": "786f76e8",
"metadata": {
"hideCode": false,
"hidePrompt": false,
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"$$\n",
"\\begin{align*}\n",
"X_1 &= X_0 \\cdot{} M \\\\\n",
"X_2 &= X_1 \\cdot{} M = (X_0 \\cdot M) \\cdot{} M = X_0 \\cdot M^2 \\\\\n",
"& \\vdots \\\\\n",
"X_n &= X_0 \\cdot \\underbrace{M \\cdot{} \\dots \\cdot M}_{\\text{$n$ mal}} = X_0 \\cdot M^n\n",
"\\end{align*}\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": 7,
@ -1490,7 +1380,7 @@
}
],
"metadata": {
"celltoolbar": "Slideshow",
"celltoolbar": "Tags",
"hide_code_all_hidden": false,
"kernelspec": {
"display_name": "Python 3 (ipykernel)",