Skip to content
Snippets Groups Projects
Commit c10e22d0 authored by Christian Rohlfing's avatar Christian Rohlfing
Browse files

- added Fehlerwahrscheinlichkeit to index and bugfix

parent 06691980
No related branches found
No related tags found
No related merge requests found
%% Cell type:code id: tags:
``` python
# Copyright 2020 Institut für Nachrichtentechnik, RWTH Aachen University
%matplotlib widget
from ipywidgets import interact, interactive, fixed, interact_manual
import ipywidgets as widgets
from IPython.display import clear_output, display, HTML
import scipy.special as special # erfc
from scipy import signal # convolution
from ient_nb.ient_plots import *
from ient_nb.ient_signals import *
def convolution(s, h):
# Convolve s and h numerically
g = signal.convolve(s, h, mode='same')*deltat; #g = g[0:len(s)];
return g
plt.close('all')
```
%% Cell type:markdown id: tags:
<div>
<img src="figures/rwth_ient_logo@2x.png" style="float: right;height: 5em;">
</div>
# Fehlerwahrscheinlichkeit bei Korrelationsfilter-Empfang gestörter Binärsignale
Zum Starten: Im Menü: Run <span class="fa-chevron-right fa"></span> Run All Cells auswählen.
## Einleitung
%% Cell type:code id: tags:
``` python
# Wahrscheinlichkeiten
Pa0 = 0.25 # Prob(an = 0)
Pa1 = 1-Pa0 # Prob(an = 1)
# Augenblicksleistungen
Sa = 3**2 # Nutzsignal
N = 3 # Störsignal
# Entscheidungsschwelle
C = np.sqrt(Sa)/2
```
%% Cell type:markdown id: tags:
Betrachte Signale am *Ausgang* des Korrelationsfilters. Gesamtsignal am Ausgang zum Abtastzeitpunkt $T$: $y(T) = g(T) + n_\mathrm{e}(T)$. $g(T)$ ist gefiltertes Nutzsignal und $n_\mathrm{e}(T)$ gefiltertes Störsignal. Desweitern kann unterschieden werden:
* Wenn $a_n=1$: $y_1(T) = g(T) + n_\mathrm{e}(T)$. Verteilungsdichte $p_{y1}(x)$ ist Gauß-Verteilung mit Mittelwert $\sqrt{S_\mathrm{a}}$ und Varianz $N$.
* Wenn $a_n=0$: $y_0(T) = 0 + n_\mathrm{e}(T)$. Verteilungsdichte $p_{y0}(x)$ ist Gauß-Verteilung mit Mittelwert $0$ und Varianz $N$.
%% Cell type:code id: tags:
``` python
def calculate_pdfs(x, Sa, N):
Gauss_PDF = lambda x, m, v: 1/np.sqrt(2*np.pi*v)*np.exp(-(x-m)**2/(2*v)) # mean v and variance v
py0 = Gauss_PDF(x, 0, N); # a_n = 0
py1 = Gauss_PDF(x, np.sqrt(Sa), N); # a_n = 1
return py0,py1
x,deltax = np.linspace(-10,15,1e5, retstep=True); # x-axis
x,deltax = np.linspace(-10,15,int(1e5), retstep=True); # x-axis
py0,py1 = calculate_pdfs(x, Sa, N); # PDFs
```
%% Cell type:markdown id: tags:
Nach Filterung wird anhand von Schwelle $C$ entschieden. Dabei entstehen Fehler in zwei Fällen
* Fehlerwahrscheinlichkeiten für "Alarm verpasst" ("1" wurde gesendet, allerdings "0" erkannt)
$$P_{\mathrm{e}1} = \mathrm{Prob}\left[y_1(T) \leq C\right] = \frac{1}{2}\mathrm{erfc}\left(\frac{\sqrt{S_\mathrm{a}}-C}{\sqrt{2N}}\right)$$
* und "Fehlalarm" ("0" wurde gesendet, allerdings "1" erkannt)
$$P_{\mathrm{e}0} = \mathrm{Prob}\left[y_0(T) > C\right] = \frac{1}{2}\mathrm{erfc}\left(\frac{C}{\sqrt{2N}}\right) \text{.}$$
%% Cell type:code id: tags:
``` python
# Fehlerwahrscheinlichkeiten
def calculate_error_probs(C, Sa, N):
Pe0 = 0.5*special.erfc(C/np.sqrt(2*N)) # integral from C to inf over p_y0, detected 1, but 0 was sent
Pe1 = 0.5*special.erfc((np.sqrt(Sa)-C)/np.sqrt(2*N)) # integral from -inf to C over p_y1, detected 0, but 1 was sent
return Pe0, Pe1
Pe0, Pe1 = calculate_error_probs(C, Sa, N) # Error probabilities, depending on C
# PLot
fig,ax = plt.subplots()
ax.plot(x,py0, 'rwth', LineStyle='--', label='$p_{y0}(x)$'); ax.plot(x,py1, 'rwth', label='$p_{y1}(x)$')
ax.axvline(C, Color='rot-75', LineStyle='-.', label='$C$'); ient_axis(ax);
ax.fill_between(x[x>C], 0, py0[x>C], facecolor="none", hatch="//", edgecolor='k', linewidth=0.0, label='$P_{\mathrm{e}0}$');
ax.fill_between(x[x<=C], 0, py1[x<=C], facecolor="none", hatch="\\\\", edgecolor='k', linewidth=0.0, label='$P_{\mathrm{e}1}$');
ax.legend();
```
%% Cell type:markdown id: tags:
## Verallgemeinerung
Bis jetzt galt $\mathrm{Prob}\left[a_n=0\right] = \mathrm{Prob}\left[a_n=1\right] = \frac{1}{2}$. Nun soll dies verallgemeinert werden. Ferner kürzen wir ab $P_{a0}=\mathrm{Prob}\left[a_n=0\right]$ und $P_{a1}=\mathrm{Prob}\left[a_n=1\right] = 1-P_{a0}$.
$g(T)$ bei unipolarer Übertragung nimmt entweder den Wert $0$ oder $\sqrt{S_\mathrm{a}}$ an. Damit ist die Verteilungsdichte
$$
p_g(x) = P_{a0} \cdot \delta(x) + P_{a1} \cdot \delta\left(x-\sqrt{S_\mathrm{a}} \right)
$$
$n_\mathrm{e}(T)$ ist Gauß-verteilt mit
$$
p_n(x) = \frac{1}{\sqrt{2\pi N}} \exp\left[-x^2/(2N)\right]
$$
Für $y(T) = g(T) + n_\mathrm{e}(T)$ gilt für dessen Verteilungsdichte
$$p_y(x) = p_g(x) \ast p_n(x) = P_{a0} \cdot p_{y0}(x) + P_{a1} \cdot p_{y1}(x)$$
### Interaktive Demo
Zusätzlich zu den Verteilungsdichten wird die sogenannte "receiver operating characteristic" (ROC) betrachtet. Hier wird auf der x-Achse $P_{e0}$ (Fehlalarm) und auf der y-Achse $1-P_{e1}$ (Alarm richtig erkannt) für verschiedene Werte von $C$ aufgetragen.
| Erkannt \ Gesendet | 0 | 1 |
|------|------|------|
| 0 | Ablehnung $1-P_{\mathrm{e}0}$ (true negative) | Alarm verpasst $P_{\mathrm{e}1}$ (false negative) |
| 1 | Fehlalarm $P_{\mathrm{e}0}$ (false positive) | Alarm erkannt $1-P_{\mathrm{e}1}$ (true positive) |
%% Cell type:code id: tags:
``` python
Cvec = np.linspace(-10,15,1e5) # all regarded values of C
Savec = np.linspace(0, 50,1e5) # all regarded values of Sa
Cvec = np.linspace(-10,15,int(1e5)) # all regarded values of C
Savec = np.linspace(0, 50,int(1e5)) # all regarded values of Sa
Pe0, Pe1 = calculate_error_probs(Cvec, Sa, N)
ind = np.argsort(Pe0)
fig,axs = plt.subplots(2,2,figsize=(8,6)); fig.tight_layout()
@interact(C = widgets.FloatSlider(min=np.min(Cvec), max=np.max(Cvec), step=0.01, value=2,
description=r'$C$', readout_format='.3f'),
Sa = widgets.FloatSlider(min=np.min(Savec), max=np.max(Savec), step=0.01, value=9,
description=r'$S_\mathrm{a}$', readout_format='.3f'),
Pa0 = widgets.FloatSlider(min=0, max=1, step=0.01, value=.5,
description=r'$\mathrm{Prob}[a_n=0]$', readout_format='.3f', style=ient_wdgtl_style))
def update_plots(C, Sa, Pa0):
# Received signal probability
Pa1 = 1-Pa0
py0,py1 = calculate_pdfs(x, Sa, N);
py = Pa0*py0 + Pa1*py1 # total probability p_y(x)
# Error probabilities
Pe0c, Pe1c = calculate_error_probs(C, Sa, N)
Pec = Pa0*Pe0c + Pa1*Pe1c
Pe0, Pe1 = calculate_error_probs(Cvec, Sa, N) # recalculate for different Sa and Pa0
Pe = Pa0*Pe0 + Pa1*Pe1
# Optimal threshold
Copt = np.sqrt(Sa)/2 + N/(np.sqrt(Sa)+eps)*np.log(Pa0/(1-Pa0+eps)+eps)
print('Copt={:f}'.format(Copt))
# Plot
if not axs[0,0].lines: # draw and decorate
ax = axs[0,0]; ient_axis(ax); # PDFs of y0 and y1
ax.plot(x,py0, 'rwth', LineStyle='--', label='$p_{y0}(x)$'); p2=ax.plot(x,py1, 'rwth', label='$p_{y1}(x)$');
ax.fill_between(x[x>C], 0, py0[x>C], facecolor="none", hatch="//", edgecolor='k', linewidth=0.0, label='$P_{\mathrm{e}0}$');
ax.fill_between(x[x<=C], 0, py1[x<=C], facecolor="none", hatch="\\\\", edgecolor='k', linewidth=0.0, label='$P_{\mathrm{e}1}$');
ax.axvline(C, Color='rot-75', LineStyle='-.'); # threshold
ax.set_xlabel(r'$\rightarrow x$'); ax.legend();
ax = axs[0,1]; ient_axis(ax); # Receiver Operating Characteristic (ROC)
ax.plot(Pe0, 1-Pe1, 'rwth');
ax.plot(Pe0c, 1-Pe1c, 'o', color='rot-75');
ax.set_xlim([-.1,1.1]); ax.set_ylim([-.1,1.1]);
ax.set_xlabel(r'$\rightarrow P_{\mathrm{e}0}(C)$ (Fehlalarm)', fontsize=10);
ax.set_ylabel(r'$\uparrow 1-P_{\mathrm{e}1}(C)$ (Alarm erkannt)', fontsize=10);
ax = axs[1,0]; ient_axis(ax); ax.set_ylim([0,.25]) # PDFs of y
ax.plot(x, Pa0*py0, 'k--'); ax.plot(x, Pa1*py1, 'k-')
ax.plot(x, py); ax.axvline(C, Color='rot-75', LineStyle='-.');
ax.set_xlabel(r'$\rightarrow x$');
ax.legend(['$P_{a0}p_{y0}(x)$', '$P_{a1}p_{y1}(x)$', '$p_{y}(x)$']);
ax = axs[1,1]; ient_axis(ax); ax.set_ylim([0,1.1]) # PDFs of e
ax.plot(Cvec, Pa0*Pe0, 'k--'); ax.plot(Cvec, Pa1*Pe1, 'k-')
ax.plot(Cvec, Pe); ax.plot(C, Pec, 'o', color='rot-75')
ax.set_ylim([0,1.1]); ax.set_xlabel(r'$\rightarrow C$');
ax.legend(['$P_{a0}p_{\mathrm{e}0}(C)$', '$P_{a1}p_{\mathrm{e}1}(C)$', '$P_{e}(C)$']);
else: # update lines
ax = axs[0,0];
ax.lines[0].set_ydata(py0); ax.lines[1].set_ydata(py1);
ax.lines[2].set_xdata([C,C]);
if ax.collections: ax.collections[0].remove(); ax.collections[0].remove(); # update integrand
ax.fill_between(x[x>C], 0, py0[x>C], facecolor="none", hatch="//", edgecolor='k', linewidth=0.0);
ax.fill_between(x[x<=C], 0, py1[x<=C], facecolor="none", hatch="\\\\", edgecolor='k', linewidth=0.0);
ax = axs[0,1];
ax.lines[0].set_data(Pe0, 1-Pe1);
ax.lines[1].set_data(Pe0c, 1-Pe1c);
ax = axs[1,0];
ax.lines[0].set_ydata(Pa0*py0); ax.lines[1].set_ydata(Pa1*py1);
ax.lines[2].set_ydata(py); ax.lines[3].set_xdata([C,C]);
ax = axs[1,1];
ax.lines[0].set_ydata(Pa0*Pe0); ax.lines[1].set_ydata(Pa1*Pe1);
ax.lines[2].set_ydata(Pe);
ax.lines[3].set_data(C, Pec);
```
%% Cell type:markdown id: tags:
This notebook is provided as [Open Educational Resource](https://en.wikipedia.org/wiki/Open_educational_resources) (OER). Feel free to use the notebook for your own purposes. The code is licensed under the [MIT license](https://opensource.org/licenses/MIT).
Please attribute the work as follows:
*Christian Rohlfing, Übungsbeispiele zur Vorlesung "Informationsübertragung"*, gehalten von Jens-Rainer Ohm, 2020, Institut für Nachrichtentechnik, RWTH Aachen University.
......
figures/thumbs/fehlerwahrscheinlichkeit.png

31.7 KiB

figures/thumbs/fehlerwahrscheinlichkeit.thumb.png

17.4 KiB

%% Cell type:markdown id: tags:
<div>
<img src="figures/rwth_ient_logo@2x.png" style="float: right;height: 5em;">
</div>
# Übungsbeispiele zur Vorlesung Informationsübertragung
## Jupyter Quick Start
* Zum Ausführen aller Cells eines Notebooks: Im Menü: Run <span class="fa-chevron-right fa"></span> Run All Cells
* Zum Neustart: <span class="fa-refresh fa"></span>-Button
* Zum Ausführen einer einzelnen Cell: <span class="fa-play fa"></span> Run-Button
## Inhaltsverzeichnis
* [Autokorrelationsfunktion Binäre Rechteckfolge
![Thumbnail](figures/thumbs/akf_rechteckfolge.thumb.png)](IUE%20Autokorrelationsfunktion%20Binäre%20Rechteckfolge.ipynb)
* [Unipolare Amplitudenabtastung
![Thumbnail](figures/thumbs/amplitudenabtastung.thumb.png)](IUE%20Amplitudenabtastung.ipynb)
* [Augendiagramm
![Thumbnail](figures/thumbs/augendiagramm.thumb.png)](IUE%20Augendiagramm.ipynb)
* [Fehlerwahrscheinlichkeit
![Thumbnail](figures/thumbs/fehlerwahrscheinlichkeit.thumb.png)](IUE%20Fehlerwahrscheinlichkeit.ipynb)
* [Rayleigh-Verteilung
![Thumbnail](figures/thumbs/rayleigh.thumb.png)](IUE%20Rayleigh-Verteilung.ipynb)
* [Pulsamplitudenmodulation
![Thumbnail](figures/thumbs/pam.thumb.png)](IUE%20Pulsamplitudenmodulation.ipynb)
* [Quantisierung
![Thumbnail](figures/thumbs/quantization.thumb.png)](IUE%20Quantisierung.ipynb)
* [Entropie Ternäre Quelle
![Thumbnail](figures/thumbs/ternary_source.thumb.png)](IUE%20Entropie%20Ternäre%20Quelle.ipynb)
Weiterhin sind Notebooks zu ausgewählten Themen der Kapitel 1 bis 7 des Buchs Signalübertragung von Jens-Rainer Ohm [hier](https://git.rwth-aachen.de/ient/gdet3-demos) verfügbar.
## Mitwirkende
* [Christian Rohlfing](http://www.ient.rwth-aachen.de/cms/c_rohlfing/)
* [Jens Schneider](http://www.ient.rwth-aachen.de/cms/j_schneider/)
%% Cell type:markdown id: tags:
This notebook is provided as [Open Educational Resource](https://en.wikipedia.org/wiki/Open_educational_resources) (OER). Feel free to use the notebook for your own purposes. The code is licensed under the [MIT license](https://opensource.org/licenses/MIT).
Please attribute the work as follows:
*Christian Rohlfing, Übungsbeispiele zur Vorlesung "Informationsübertragung"*, gehalten von Jens-Rainer Ohm, 2020, [Institut für Nachrichtentechnik](http://www.ient.rwth-aachen.de), RWTH Aachen University.
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment