Commit 5099faeb authored by Konrad Völkel's avatar Konrad Völkel
Browse files

fixed stupid variance/std

parent c53d49d9
Pipeline #93396 passed with stages
in 4 minutes and 18 seconds
%% Cell type:markdown id:fcbdd137-53b6-4407-9db8-7583a9e04a91 tags:
## Wichtigste stetige Verteilungen
Nachdem wir ausführlich über die Gaussverteilung gesprochen haben, wollen wir einen Überblick über einige der wichtigsten stetigen Verteilungen bekommen, ähnlich wie wir ihn bereits für diskrete Verteilungen gewonnen haben. Dazu benutzen wir das Python-Modul `scipy.stats`.
%% Cell type:markdown id:91efdf3d-a441-4b69-84b8-614c57e29986 tags:
### SciPy Statistics
%% Cell type:code id:fe446f00-6f77-459e-a994-340e80d88445 tags:
``` python
import numpy as np
np.random.seed(12321)
import scipy.stats as st
# Zufallsvariable mit N(3,2)-Verteilung erzeugen:
# Zufallsvariable mit N(3,2^2)-Verteilung erzeugen:
X = st.norm(loc=3, scale=2)
# samples ziehen:
Xsamples = X.rvs(size=4)
print("some examples:",Xsamples)
```
%% Output
some examples: [4.02801895 1.9033209 6.49477125 1.83362523]
%% Cell type:code id:dedb9580-1b87-4e59-917e-ca0865c0c379 tags:
``` python
# Verteilung checken:
Xsamples = X.rvs(size=1000)
print("mean:", np.mean(Xsamples), "expected", X.mean()) # 3
print("std:", np.std(Xsamples), "expected", X.std()) # 2
print("3rd moment:", X.moment(3))
print("4th moment:", X.moment(4))
print("entropy:", X.entropy())
```
%% Output
mean: 3.0004822746684243 expected 3.0
std: 1.9994507762900595 expected 2.0
3rd moment: 62.99999999999999
4th moment: 344.99999999999994
entropy: 2.112085713764618
%% Cell type:code id:0bbb8d6a-9cae-48a2-a197-ee6ff8458fdf tags:
``` python
# Daten fitten:
mu, sigma = st.norm.fit(Xsamples)
print(mu, sigma)
```
%% Output
3.0004822746684243 1.9994507762900595
%% Cell type:markdown id:e51c0170-cdf2-4b52-a1b7-dd240895caab tags:
Es gibt noch weitere praktische Methoden, etwa `st.norm.sf`, die 'survival function', definiert als 1-cdf oder `st.norm.logpdf`, falls man direkt den Logarithmus der Dichtefunktion verwenden möchte (beide Methoden sind potentiell schneller, als das von Hand / zu Fuß auszurechnen).
%% Cell type:markdown id:78b5821b-84e5-468c-a368-7b93c22f8117 tags:
### Matplotlib
Wir werden uns von den Verteilungen jeweils Plots der Dichtefunktionen (pdf) und der kumulierten Verteilungsfunktionen (cdf) anschauen. Dazu verwenden wir das Python-Modul `matplotlib.pyplot`. Es emuliert das Verhalten von MATLAB. Wir werden uns noch ausführlicher mit Matplotlib beschäftigen.
%% Cell type:code id:2ce85da0-8c6f-4f83-9339-195fda4982bf tags:
``` python
from matplotlib import pyplot as plt
```
%% Cell type:code id:76221be7-043b-41e2-93a8-ae908de80132 tags:
``` python
# Größe der Plotausgabe anpassen:
plt.rcParams["figure.figsize"] = (16,9)
# Sample der Verteilung von einer früheren Übungsaufgabe:
sample = np.random.choice(3, 10000, p=[4/7,2/7,1/7]) + 5 + np.random.random(10000)
print("sample[:10] =", sample[:10])
# Histogramm plotten:
plt.hist(sample, bins=100)
plt.ylabel("Häufigkeit")
plt.xlabel("Mittelwert="+str(np.mean(sample))+" (erwartet: "+str(6+1/14)+"), Standardabweichung²="+str(np.std(sample)**2))
plt.show()
plt.hist(sample, bins=100, density=True)
plt.ylabel("Dichte")
plt.xlabel("Mittelwert="+str(np.mean(sample))+" (erwartet: "+str(6+1/14)+"), Standardabweichung²="+str(np.std(sample)**2))
plt.show()
# Histogramm mit wenig bins:
plt.hist(sample, bins=3)
plt.ylabel("Häufigkeit")
plt.show()
```
%% Output
sample[:10] = [5.96301841 5.60942173 5.72908826 5.80068973 5.59819708 5.35377228
6.093922 6.36189002 5.42430139 5.87334923]
%% Cell type:markdown id:6b91accc-856e-46b0-8d19-e91af14aeda0 tags:
Zum Plotten einer Funktion definieren wir diese als Python-Methode und rechnen hinreichend viele Werte aus, zwischen denen dann interpoliert wird:
%% Cell type:code id:fd4df7ae-888f-4f8b-aad5-794ebdc870ac tags:
``` python
# Funktion x |-> 3+2x+x²-x³ auf Intervall [-80,90] plotten:
def f(x):
return 3 + 2*x + x**2 - x**3
x = np.linspace(-80, 90, 100)
plt.plot(x, f(x), color='red')
plt.show()
```
%% Output
%% Cell type:markdown id:c9a1de69-9590-4ef4-b708-c202dfda6d50 tags:
Damit kümmern wir uns nun um die wichtigsten stetigen Verteilungen:
### Normalverteilung
* Parameter $\mu,\sigma$, Notation $\mathcal{N}(\mu,\sigma^2)$
* Dichte $\phi(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{(x-\mu)^2}{2\sigma^2}}$
* Erwartungswert $\mu$
* Varianz $\sigma^2$
* Höhere ungerade zentrale Momente sind alle $0$ \
(daher sind ungerade Momente ein Maß für nicht-Normalität)
* Maximale Entropie bei festem Erwartungswert und fester Varianz und Träger ganz $\mathbb{R}$
* ZGWS: Folge iid Zufallsvariablen $X_i$, dann $\sum_{i=1}^N X_i \xrightarrow{N \to \infty} \mathcal{N}(\mu,\sigma^2)$
* Anwendungsbeispiele:
* Messfehler in physikalischen Systemen
* Fertigungsgenauigkeit
* Biologische Größen (Körperlänge etc.)
%% Cell type:code id:334bb8a6-1046-454b-ac1c-9b921d5136b4 tags:
``` python
# Für Plots:
def plotX(x, X, name, params):
# Zuerst die Dichtefunktion:
plt.plot(x, X.pdf(x))
plt.ylabel('Dichte')
plt.title("PDF von "+name+" mit Parametern "+repr(params))
plt.show()
# Dann die kumulative Verteilungsfunktion:
plt.plot(x, X.cdf(x))
plt.ylabel('Dichte')
plt.title("CDF von "+name+" mit Parametern "+repr(params))
plt.show()
x = np.linspace(-3,3,100)
mu, sigma = 0, 1
X = st.norm(loc=mu, scale=sigma)
name = "Normalverteilung"
plotX(x, X, name, (mu, sigma))
```
%% Output
%% Cell type:code id:4a044db8-d054-4673-a359-4f494274d1ce tags:
``` python
X = st.norm(loc=3, scale=2)
Xsamples = X.rvs(size=10000)
plt.hist(Xsamples, bins=200, density=True)
plt.xlabel("10000 Samples von N(3,2), in 200 Bins")
plt.ylabel("Dichte")
plt.show()
```
%% Output
%% Cell type:markdown id:f32228ff-f857-4f93-9774-3739af73a8a0 tags:
### Kontaminierte Normalverteilung
Die kontaminierte Normalverteilung ist ein einfacher Fall eines sogenannten *gemischten Modells*, genauer einer *Gaussschen Mischung*.
* Parameter $\varepsilon,\mu_1,\sigma_1,\mu_2,\sigma_2$, Notation $\varepsilon\mathcal{N}(\mu_1,\sigma_1^2) + (1-\varepsilon)\mathcal{N}(\mu_2,\sigma_2^2)$
* Dichte $\phi(x) = \frac{\varepsilon}{\sigma\sqrt{2\pi}} e^{-\frac{(x-\mu_1)^2}{2\sigma_1^2}} + \frac{1 - \varepsilon}{\sigma\sqrt{2\pi}} e^{-\frac{(x-\mu_2)^2}{2\sigma_2^2}}$
* Erwartungswert $\varepsilon\mu_1 + (1-\varepsilon)\mu_2$
* Varianz $\varepsilon\sigma_1^2 + (1 - \varepsilon)\sigma_2^2 + \varepsilon(1 - \varepsilon)(\mu_1-\mu_2)^2$
* Anwendungsbeispiele: Ein zweistufiger Prozess, je nach Ausgang eines Bernoulli-Experiments wird eine andere Normalverteilung gesampelt. Ein konkreter Versuchsaufbau wäre etwa, in einer Informatikvorlesung die Körpergröße der Teilnehmer\*innen zu messen. Das Geschlecht ist (näherungsweise!) Bernoulli-verteilt (voraussichtlich nicht gleichverteilt), innerhalb der Geschlechtergruppen ist die Körpergröße dann normalverteilt (aber mit verschiedenen Mittelwerten). An diesem Beispiel sieht man auch, dass jede Modellierung das Potential birgt, einen Teil der Realität unsichtbar zu machen, den man möglicherweise gar nicht unsichtbar machen möchte. Zum Glück kann man gemischte Modelle auch mit mehr als einem Parameter $\varepsilon$ aufstellen.
%% Cell type:code id:9753d0fd-a039-4d72-8fd1-f80c58ba4c56 tags:
``` python
name = "0.6*N(0,1) + 0.4*N(2,0.5)"
def f(x, epsilon=0.6, mu1=0, sigma1=1, mu2=2, sigma2=0.5):
norm1 = st.norm(loc=mu1, scale=sigma1)
norm2 = st.norm(loc=mu2, scale=sigma2)
return epsilon*norm1.pdf(x) + (1-epsilon)*norm2.pdf(x)
x = np.linspace(-3,3,100)
plt.plot(x, f(x))
plt.ylabel('Dichte')
plt.title("PDF von "+name)
plt.show()
```
%% Output
%% Cell type:markdown id:941767a6-1f68-4bc8-8c43-b6acf078eef3 tags:
### Dirac-Verteilung
* Parameter $\xi$, Notation $\delta(\xi)$
* Ohne Dichte, aber $P(X = \xi) = 1$
* Erwartungswert $\xi$
* Varianz $0$
* Entropie $0$
* Anwendungsbeispiele:
* 'Dichtefunktionen' im stetigen Sinne für diskrete Verteilungen hinschreiben
* Fotos vom Sternenhimmel (z.B. mit Hubble) - jeder Stern ist ein verschmierter Pixelhaufen (normalverteilt), aber die 'eigentliche' Verteilung der Sterne dahinter ist eine Summe von Dirac-Maßen, denn jeder Stern ist an genau einem Punkt (die tatsächliche Ausdehnung des Sterns ist aufgrund der Entfernung irrelevant). Mit dieser Modellierung arbeiten manche Superresolution-Techniken.
Die Dirac-Verteilung ist strenggenommen unplotbar (denn es gibt ja keine Dichte). Manche zeichnen zur Illustration einen Pfeil der Länge $1$ bei $\xi$ ein.
Die kumulative Verteilungsfunktion ist eine Heaviside-Step-Funktion:
%% Cell type:code id:0da093d7-7476-4088-9ea8-ae9192e436fb tags:
``` python
name = "Dirac-Verteilung bei ξ=0"
plt.plot(x, np.heaviside(x, 1))
plt.ylabel('Dichte')
plt.title("CDF von "+name)
plt.show()
```
%% Output
%% Cell type:markdown id:5f9e0ec5-2781-4e56-8258-9979887a30bd tags:
### Stetige Gleichverteilung
* Parameter $a,b$, Notation $Uni(a,b)$
* Dichte $\frac{1}{b-a}$
* Erwartungswert $\frac{a+b}{2}$
* Varianz $\frac{(a+b)^2}{12}$
* Varianz $\frac{(a-b)^2}{12}$
* Maximale Entropie unter allen Verteilungen mit Träger $[a,b]$
* Anwendungsbeispiele:
* Wenn ein Bus an Ihrer Haltestelle extrem pünktlich jede Stunde kommt, Sie aber nicht wissen, wann er das letzte Mal gefahren ist, so ist ihre Wartezeit an der Haltestelle in Minuten gleichverteilt in $[0,60]$.
* Die Temperatur ihrer CPU ab der dritten Nachkommastelle `(T * 100 - int(T * 100))` ist annähernd gleichverteilt.
%% Cell type:code id:94ab9253-19e3-4256-94b6-0132cdf2790f tags:
``` python
a, b = -1, 2
X = st.uniform(loc=a, scale=b-a)
print(X.mean(), X.var())
name = "Gleichverteilung"
plotX(x, X, name, (a, b))
```
%% Output
0.5 0.75
%% Cell type:markdown id:e48381a4-8aea-42a5-ace1-ca83ab4e6c14 tags:
### Exponentialverteilung
* Parameter $\lambda$, Notation $Exp(\lambda)$
* Dichte $\lambda e^{-\lambda x}$
* Erwartungswert $\dfrac{1}{\lambda}$
* Varianz $\dfrac{1}{\lambda^2}$
* Maximale Entropie unter allen Verteilungen mit Träger $[0,\infty)$ und Erwartungswert $\dfrac{1}{\lambda}$
* Anwendungsbeispiele:
* Wie lange dauert es, bis auf dem Server das nächste Paket ankommt?
%% Cell type:code id:dc79a2c7-07ac-4dc7-8bed-859ad3a629bf tags:
``` python
name = "Exponentialverteilung"
lamda = 2
X = st.expon(scale = 1/lamda)
x = np.linspace(-1,5,100)
plotX(x,X,name,(lamda))
```
%% Output
%% Cell type:markdown id:2eadac49-cfe0-4715-9f65-743a969eefad tags:
### Lognormalverteilung
* Parameter $\mu, \sigma$, Notation $Lognormal(\mu,\sigma^2)$
* Dichte $\frac{1}{x\sigma\sqrt{2\pi}} e^{-\frac{(log(x)-\mu)^2}{2\sigma^2}}$
* Erwartungswert $e^{\mu + \frac{\sigma^2}{2}}$ aber $\mathbb{E}(log X) = \mu$
* Varianz $(e^{\sigma^2}-1)e^{2\mu + \sigma^2}$ aber $\mathbb{V}(log X) = \sigma^2$
* Maximale Entropie unter allen Verteilungen mit Träger $(0,\infty)$ und $\mathbb{E}(\log X) = \mu$ und $\mathbb{V}(\log X) = \sigma^2$
* Anwendungsbeispiele:
* Die Länge eines Schachspiels ist log-normalverteilt
* Viele (!) weitere Beispiele hat die [Wikipedia zur Lognormalverteilung](https://en.wikipedia.org/wiki/Log-normal_distribution#Occurrence_and_applications)
%% Cell type:code id:c6db802c-3fd7-4d8b-a4fb-fe13950dfc46 tags:
``` python
name = "Log-normalverteilung"
mu, sigma = 1, 2
X = st.lognorm(s=sigma, scale = np.exp(mu))
x = np.linspace(0,2,1000)
plotX(x,X,name,(mu, sigma))
```
%% Output
%% Cell type:markdown id:7c3b2bd4-ded0-4f92-bbce-7870a067a626 tags:
### Weibull-Verteilung
* Parameter $\lambda>0, k>0$, Notation $Weibull(\lambda,k)$
* Dichte $f(x) = \dfrac{k}{\lambda} {\left(\frac{x}{\lambda}\right)}^{k-1} e^{-{\left(\frac{x}{\lambda}\right)}^k}$ für $x \geq 0$ \
und $f(x)=0$ für $x < 0$
* Erwartungswert $\lambda \Gamma(1+\frac{1}{k})$ (wobei $\Gamma(n+1) = n!$)
* Maximale Entropie unter allen Verteilungen mit einer Bedingung an alle Momente: $\mathbb{E}(X^n) = \lambda^n$ und einer Bedingung an $\mathbb{E}(\log X)$.
* Anwendungsbeispiele:
* Wie lange läuft eine Wärmepumpe, bis sie kaputt geht?
* Wie hoch ist die Windgeschwindigkeit?
* Was ist die höchste Niederschlagsmenge an einem einzelnen Tag im Jahr?
%% Cell type:code id:859f3280-1451-48d6-8632-ab225a7d09cf tags:
``` python
name = "Weibull-verteilung"
lamda, k = 1, 0.5
X = st.lognorm(s=k, scale = lamda)
x = np.linspace(0,2,1000)
plotX(x,X,name,(lamda, k))
```
%% Output
%% Cell type:markdown id:924ecdb7-fcb3-4cd9-b93a-687780a6edaf tags:
### Daten zum plotten und fitten
Damit wir ein bisschen üben können, Daten zu plotten und Verteilungen auf Daten zu fitten (und das dann wiederum im Plot zu visualisieren), brauchen wir Spielzeugdaten.
Ein sehr einfacher und daher sehr instruktiver Datensatz ist Fisher-Anderson's 'iris flower dataset', den wir z.B. über Scikit-Learn beziehen können:
%% Cell type:code id:c6fc6939-434a-4cd7-957c-ed09626cc5e9 tags:
``` python
from sklearn import datasets
iris = datasets.load_iris()
print(iris["data"][:5])
```
%% Output
[[5.1 3.5 1.4 0.2]
[4.9 3. 1.4 0.2]
[4.7 3.2 1.3 0.2]
[4.6 3.1 1.5 0.2]
[5. 3.6 1.4 0.2]]
%% Cell type:code id:a01fd47d-0f25-47f9-9c3d-328be854fcfa tags:
``` python
first_feature = iris["data"][:,0]
plt.hist(first_feature, bins=30, density=True)
# Jetzt die best-fitting-Normalverteilung rein:
mu, sigma = st.norm.fit(first_feature)
X = st.norm(loc=mu, scale=sigma)
x = np.linspace(3,9,100)
plt.plot(x, X.pdf(x))
plt.xlabel("Erstes Feature Iris-Datensatz")
plt.ylabel("Dichte")
plt.show()
```
%% Output
%% Cell type:markdown id:25e1bab3-afe7-4bb4-a1fd-bc05f1e75abe tags:
Eine Quelle für relativ gut gepflegte Spielzeugdaten, die auch viel diskutiert werden, ist [Kaggle](https://www.kaggle.com/datasets).
Um diese Daten zu verarbeiten, muss man meist CSV-Dateien in Numpy-Arrays verwandeln. Besonders entspannt geht das mit Pandas (das auf Numpy aufbaut), womit wir uns noch beschäftigen werden. Für den Anfang reicht auch Numpy's eingebautes `np.genfromtxt`.
Der deutsche Wetterdienst DWD hat mit dem [Climate Data Center](https://cdc.dwd.de/portal/) eine große Sammlung gut dokumentierter, teilweise täglich aktualisierter Wetter- und Klimadaten. Darin sind Variablen mit räumlicher Verteilung und Zeitreihen verschiedenster physikalischer Größen und statistischer Verteilungen zu finden. Interessant (und beantwortbar) ist z.B. die Frage, ob Starkregenereignisse in Düsseldorf in den letzten Jahrzehnten zugenommen haben.
Schauen Sie sich diese (und andere!) Daten an, finden Sie heraus, wie die Variablen verteilt sein könnten, plotten und fitten Sie Verteilungen. Besonders durch den Vergleich des Histogramms mit der Dichtefunktion der gefitteten Verteilung sehen Sie, wie nah wir liegen.
Da sehr viele Daten nicht einer der hier aufgezählten Verteilungen genügen, benötigen wir noch komplexere Modelle. Diese sind allerdings zumeist mehrstufig aus den einfachen Modellen zusammengesetzt, wie bei der kontaminierten Normalverteilung. Eines der wichtigsten Modelle wird später die Mischung multivariater Normalverteilungen sein, anhand dessen wir einige Prinzipien des maschinellen Lernens betrachten können.
Wenn Sie sich weiter mit den Zusammenhängen zwischen den Verteilungen beschäftigen wollen, und dabei nicht übersehen haben, dass sich einige Verteilungen durchaus verschieden parametrisieren lassen (z.B. die Normalverteilung mit $\mu,\sigma$ aber auch mit $\mu,\sigma^2$), könnte ProbOnto das Richtige sein. Es handelt sich dabei um eine Ontologie und Wissensbasis, die ursprünglich für die Pharmakologie entwickelt wurde. Die Übersichtsgrafik ist bereits eine gute Gedächtnisstütze:
![ProbOnto 2.5 (2017)](images/ProbOnto2.5.jpg)
[ProbOnto 2.5](https://commons.wikimedia.org/wiki/File:ProbOnto2.5.jpg) CC-BY-SA [Wikipedia user Fuzzyrandom](https://commons.wikimedia.org/w/index.php?title=User:Fuzzyrandom)
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment