Wahrscheinlichkeitstheorie und Statistik

WS 2023 / 2024

WuS Hausaufgabe 1

Abgabetermin

Die Abgabefrist dieser Hausaufgabe ist 2023-10-23 12:00 (Montag Mittag)!

Vergessen Sie nicht Ihre Übung abzugeben (Assignment Tab / Submit Button). Einfaches Speichern reicht nicht! Sie können beliebig oft abgeben, die letzte Abgabe vor der Deadline wird gewertet.

Viel Erfolg!

Hinweise zur Bearbeitung der Übung

Allgemeine Informationen:

Schreiben Sie Ihre Antwort an die Stelle YOUR CODE HERE.
Fügen Sie keine neuen Zellen hinzu oder löschen Zellen.

Angabe von Ergebnissen

Runden Sie Ihre Ergebnisse nicht. Bei den Tests werden bis zu 6 Nachkommastellen geprüft.
Prozentzahlen werden immer als Zahl zwischen 0 und 1 angegeben. 30% wird somit als 0.3 angegeben.
Fließkommazahlen werden mit einem Dezimalpunkt angegeben, nicht mit einem Komma. $\frac{1}{4} \rightarrow 0.25$ .

Programmcode

Das Ergebnis einer Funktion muss mittels return zurückgegeben werden. Ein print Statement ist keine gültige Rückgabe.
Stellen Sie sicher, dass sich Ihr Code ausführen lässt. Code der nicht läuft kann nicht automatisch bewertet werden.
Bevor Sie abgeben: Klicken Sie im Menü auf Kernel > Restart & Run All (oder den Button in der Toolbar). Damit führen Sie das Notebook linear von oben nach unten aus. Alle Fehler die dann auftreten, treten auch beim Bewerten auf.
Entfernen Sie die raise NotImplementedError(), wenn Sie eine Aufgabe bearbeiten. Ansonsten wird beim Bewerten eine Exception ausgelöst, die uns sagt, dass Sie die Aufgabe nicht bearbeitet haben!

1# execute this for default imports
2import math
3import random as rd
4import numpy as np
5import pandas as pd
6from matplotlib import pyplot as plt
7from scipy import stats

Task 1¶

[40 Point(s)]

Deskriptive Statistik: Body Mass Index¶

Gegeben sind die Größe und das Gewicht aus einer Gesundheitsumfrage unter Jugendlichen und jungen Erwachsenen aus den USA (https://www.icpsr.umich.edu/icpsrweb/DSDR/studies/21600).

In der nächsten Zelle werden die Daten in zwei numpy arrays mit den Namen gewicht und groesse eingelesen.

Task 1.1¶

[1 Point(s)]

 1import numpy as np
 2import pickle
 3from matplotlib import pyplot as plt
 4%matplotlib inline
 5
 6# lädt den Datensatz in 2 arrays
 7with open('WuS_Hausaufgabe_1_files/data/gewicht.pkl', 'rb') as f:
 8    gewicht = pickle.loads(f.read())
 9    
10with open('WuS_Hausaufgabe_1_files/data/groesse.pkl', 'rb') as f:
11    groesse = pickle.loads(f.read())

1gewicht

array([113.9, 107.8,  68. , ...,  80.6,  75.3,  78.2])

1groesse

array([180., 202., 161., ..., 178., 165., 180.])

Merkmalsskalen ¶

Gewicht und Größe sind:

Task 1.2¶

[1 Point(s)]

Anzahl der Datenpunkte¶

Berechnen Sie die Anzahl der Datenpunkte und speichern Sie sie in der Variablen n. Bedenken Sie, dass ein Datenpunkt mehrere Merkmale haben kann.

1## Überprüfen ob arrays gleiche länge haben
2print(len(groesse) == len(gewicht))
3
4n = len(groesse)

True

 1### BEGIN HIDDEN TESTS
 2
 3# reload gewicht and groesse as refs for tests so they don't break in case students mess them up
 4with open('WuS_Hausaufgabe_1_files/data/gewicht.pkl', 'rb') as f:
 5    __gewicht_ref__ = pickle.loads(f.read())
 6with open('WuS_Hausaufgabe_1_files/data/groesse.pkl', 'rb') as f:
 7    __groesse_ref__ = pickle.loads(f.read())
 8__bmi_ref__ = __gewicht_ref__ / ((__groesse_ref__/100)**2)
 9__ref_dict__ = {
10    'gewicht': __gewicht_ref__,
11    'groesse': __groesse_ref__,
12    'bmi': __bmi_ref__,
13}
14
15from assignmenttest import VariableTest, FunctionTest, grade_report
16from numbers import Number
17grade_report(VariableTest(namespace=globals(), r_tol=0).test([
18    {
19        'name': 'n',
20        'expected': len(__gewicht_ref__),
21        'expected_type': Number
22    },
23]), points=1)
24### END HIDDEN TESTS

============================================================
Variable Test

============================================================
1 / 1 tests passed!
============================================================
### BEGIN GRADE
1.0
### END GRADE

Task 1.3¶

[4 Point(s)]

min und max¶

Berechnen Sie die Mini- und Maximalwerte von gewicht und groesse und speichern Sie sie in den Variablen min_gewicht, max_gewicht, min_groesse, max_groesse

1min_gewicht = min(gewicht)
2max_gewicht = max(gewicht) 
3min_groesse = min(groesse)
4max_groesse = max(groesse)
5print(min_gewicht, max_gewicht, min_groesse, max_groesse)

37.7 999.0 122.5 999.0

 1### BEGIN HIDDEN TESTS
 2from assignmenttest import VariableTest, FunctionTest, grade_report
 3from numbers import Number
 4
 5
 6def expected(name):
 7    a = __ref_dict__[name.split('_')[-1]]
 8    if name.startswith('min'):
 9        return a.min()
10    else:
11        return a.max()
12
13grade_report(VariableTest(namespace=globals(), r_tol=0.0001).test([
14    {
15        'name': name,
16        'expected': expected(name),
17        'expected_type': Number
18    } for name in "min_gewicht, max_gewicht, min_groesse, max_groesse".split(', ')
19]), points=4)
20### END HIDDEN TESTS

============================================================
Variable Test

============================================================
4 / 4 tests passed!
============================================================
### BEGIN GRADE
4.0
### END GRADE

Task 1.4¶

[5 Point(s)]

Berechnung des Merkmals BMI¶

Der Body Mass Index ist definiert als $\textrm{BMI} = \frac{\textrm{Gewicht}}{\textrm{Größe}^2}$ , wobei das Gewicht in kg und die Größe in Metern anzugeben ist.

Berechnen Sie ein neues Merkmal bmi, in dem Sie das zugehörige numpy array speichern.

1bmi = gewicht / ((groesse/100)**2)
2bmi

array([35.15432099, 26.41897853, 26.2335558 , ..., 25.43870723,
       27.6584022 , 24.13580247])

 1### BEGIN HIDDEN TESTS
 2from assignmenttest import VariableTest, FunctionTest, grade_report, comparators
 3from numbers import Number
 4
 5
 6def grade():
 7    percentage = 1
 8    if 'bmi' not in globals():
 9        print("Test for variable bmi failed.\nVariable bmi is not defined!")
10        return 0
11    
12    try:
13        if len(bmi) != len(__bmi_ref__):
14            print("Länge von bmi falsch, kann leider nicht verglichen werden")
15            return 0
16    except Exception:
17        print("len(bmi) nicht verfügbar --> kein iterable?")
18        return 0
19    
20    _bmi = bmi
21    if type(bmi) != type(__bmi_ref__):
22        print("Typ von bmi falsch, kein np.array!")
23        percentage -= .2
24        print("Versuche eins draus zu machen...")
25        try:
26            _bmi = np.array(bmi)
27        except Exception:
28            print("hat leider nicht geklappt.")
29            return 0
30        print("hat geklappt, kann weitergehen.")
31    
32    if np.allclose(_bmi, __bmi_ref__):
33        return percentage
34    
35    if np.allclose(_bmi, __gewicht_ref__ / (__groesse_ref__**2)):
36        print("Es wurde vergessen Größe durch 100 zu teilen (Größe liegt in cm, nicht m vor).")
37        percentage -= .4
38        return percentage
39
40    print("Ich weiß nicht, was Sie berechnet haben, aber es hat immerhin die richtige Länge.")
41    percentage -= .6
42    return percentage
43
44grade_report(grade(), points=5)
45### END HIDDEN TESTS

### BEGIN GRADE
5
### END GRADE

Task 1.5¶

[5 Point(s)]

Modus¶

Berechnen Sie den Modus, also den häufigsten Wert je Merkmal, und speichern Sie ihn in modus_gewicht, modus_groesse und modus_bmi:

 1from collections import Counter
 2
 3## Check ob es mehrere ergebnisse gibt
 4for a in [gewicht, groesse, bmi]:
 5    c = Counter(a)
 6    print(c.most_common(3))
 7## -> gibt es nicht also kann stats Funktion genutzt werden
 8
 9modus_gewicht = stats.mode(gewicht)[0]
10modus_groesse = stats.mode(groesse)[0]
11modus_bmi = stats.mode(bmi)[0]
12print(modus_gewicht, modus_groesse, modus_bmi)

[(996.0, 40), (69.0, 19), (85.0, 19)]
[(170.0, 154), (165.0, 150), (169.0, 137)]
[(10.04016064257028, 32), (26.993938308101164, 3), (31.79012345679012, 3)]

996.0 170.0 10.04016064257028

 1### BEGIN HIDDEN TESTS
 2from assignmenttest import VariableTest, FunctionTest, grade_report
 3from numbers import Number
 4from math import isclose
 5
 6
 7def expected(name):
 8    a = __ref_dict__[name.split('_')[-1]]
 9    return stats.mode(a).mode
10
11def comparator(result, target):
12    abs_err, rel_err = 0, 0
13    
14    # handle special case of singleton list or set being returned:
15    try:
16        if len(result) == 1 and isclose(list(result)[0], target):
17            print("Es gibt hier nur einen Modus, aber gut aufgepasst, hätten mehrere sein können, daher volle Punkte.")
18            return 0, 0
19    except Exception:
20        pass
21    
22    if isclose(result, target):
23        return 0, 0
24    return 1,1
25
26grade_report(VariableTest(namespace=globals(), r_tol=0.0001).test([
27    {
28        'name': name,
29        'expected': expected(name),
30        'comparator': comparator,
31    } for name in "modus_gewicht, modus_groesse, modus_bmi".split(', ')
32]), points=5)
33### END HIDDEN TESTS

============================================================
Variable Test

============================================================
3 / 3 tests passed!
============================================================
### BEGIN GRADE
5.0
### END GRADE

Task 1.6¶

[3 Point(s)]

Median¶

Berechnen Sie für jedes Merkmal den Median und speichern ihn in median_gewicht, median_groesse, median_bmi:

1median_gewicht = np.median(gewicht)
2median_groesse = np.median(groesse)
3median_bmi = np.median(bmi)
4print(median_gewicht, median_groesse, median_bmi)

81.4 170.0 27.644023375032077

 1### BEGIN HIDDEN TESTS
 2from assignmenttest import VariableTest, FunctionTest, grade_report
 3from numbers import Number
 4from math import isclose
 5
 6
 7def expected(name):
 8    a = __ref_dict__[name.split('_')[-1]]
 9    return np.median(a)
10
11def comparator(result, target):
12    abs_err, rel_err = 0, 0
13    
14    if isclose(result, target):
15        return 0, 0
16    return 1,1
17
18grade_report(VariableTest(namespace=globals(), r_tol=0.0001).test([
19    {
20        'name': name,
21        'expected': expected(name),
22        'comparator': comparator,
23    } for name in "median_gewicht, median_groesse, median_bmi".split(', ')
24]), points=3)
25
26
27### END HIDDEN TESTS

============================================================
Variable Test

============================================================
3 / 3 tests passed!
============================================================
### BEGIN GRADE
3.0
### END GRADE

Task 1.7¶

[3 Point(s)]

Quantile¶

Berechnen Sie das 50 % und das 95 % quantil jedes Merkmals und speichern Sie es in q50_gewicht, q50_groesse, q50_bmi, q95_gewicht, q95_groesse, q95_bmi:

1q50_gewicht = np.percentile(gewicht, 50, method='averaged_inverted_cdf')
2q50_groesse = np.percentile(groesse, 50, method='averaged_inverted_cdf')
3q50_bmi = np.percentile(bmi, 50, method='averaged_inverted_cdf')
4
5q95_gewicht = np.percentile(gewicht, 95, method='averaged_inverted_cdf')
6q95_groesse = np.percentile(groesse, 95, method='averaged_inverted_cdf')
7q95_bmi = np.percentile(bmi, 95, method='averaged_inverted_cdf')
8
9print(q50_gewicht, q50_groesse, q50_bmi, q95_gewicht, q95_groesse, q95_bmi)

81.4 170.0 27.644023375032077 133.0 187.0 44.165271273024

 1### BEGIN HIDDEN TESTS
 2from assignmenttest import VariableTest, FunctionTest, grade_report
 3from numbers import Number
 4from math import isclose
 5
 6
 7def expected(name, perc):
 8    a = __ref_dict__[name.split('_')[-1]]
 9    return np.quantile(a, perc, method='averaged_inverted_cdf')
10
11def comparator(result, target):
12    abs_err, rel_err = 0, 0
13    
14    if isclose(result, target):
15        return 0, 0
16    return 1, 1
17
18grade_report(VariableTest(namespace=globals(), r_tol=0.0001).test([
19    {
20        'name': name,
21        'expected': expected(name, int(name[1:3])/100),
22        'comparator': comparator,
23    } for name in "q50_gewicht, q50_groesse, q50_bmi, q95_gewicht, q95_groesse, q95_bmi".split(', ')
24]), points=3)
25
26
27### END HIDDEN TESTS

============================================================
Variable Test

============================================================
6 / 6 tests passed!
============================================================
### BEGIN GRADE
3.0
### END GRADE

Task 1.8¶

[3 Point(s)]

Mittelwert¶

Berechnen Sie für jedes Merkmal den Mittelwert und speichern ihn in mean_gewicht, mean_groesse, mean_bmi:

1mean_gewicht = np.mean(gewicht)
2mean_groesse = np.mean(groesse)
3mean_bmi = np.mean(bmi)
4
5print(mean_gewicht, mean_groesse, mean_bmi)

96.81206491982792 176.69499413375047 30.813351613293023

 1### BEGIN HIDDEN TESTS
 2from assignmenttest import VariableTest, FunctionTest, grade_report
 3from numbers import Number
 4from math import isclose
 5
 6
 7def expected(name):
 8    a = __ref_dict__[name.split('_')[-1]]
 9    return np.mean(a)
10
11def comparator(result, target):
12    abs_err, rel_err = 0, 0
13    
14    if isclose(result, target):
15        return 0, 0
16    return 1,1
17
18grade_report(VariableTest(namespace=globals(), r_tol=0.0001).test([
19    {
20        'name': name,
21        'expected': expected(name),
22        'comparator': comparator,
23    } for name in "mean_gewicht, mean_groesse, mean_bmi".split(', ')
24]), points=3)
25
26### END HIDDEN TESTS

============================================================
Variable Test

============================================================
3 / 3 tests passed!
============================================================
### BEGIN GRADE
3.0
### END GRADE

Task 1.9¶

[5 Point(s)]

Varianz¶

Berechnen Sie für jedes Merkmal die Varianz $\sigma^2$ und die korrigierte Stichprobenvarianz $s^2$ und speichern Sie sie in var_gewicht, var_groesse, var_bmi, ss_gewicht, ss_groesse, ss_bmi:

1var_gewicht = np.var(gewicht)
2var_groesse = np.var(groesse)
3var_bmi = np.var(bmi)
4
5ss_gewicht = np.var(gewicht, ddof=1)
6ss_groesse = np.var(groesse, ddof=1)
7ss_bmi = np.var(bmi, ddof=1)
8print(var_gewicht, var_groesse, var_bmi, ss_gewicht, ss_groesse, ss_bmi)

11297.81589471929 5394.408680455578 600.4529502594262 11300.025520358782 5395.463718335581 600.5703867840223

 1### BEGIN HIDDEN TESTS
 2from assignmenttest import VariableTest, FunctionTest, grade_report
 3from numbers import Number
 4from math import isclose
 5
 6
 7def expected(name,d):
 8    a = __ref_dict__[name.split('_')[-1]]
 9    d = 0 if "var" in d else 1
10    return np.var(a,ddof=d)
11
12def comparator(result, target):
13    abs_err, rel_err = 0, 0
14    
15    if isclose(result, target):
16        return 0, 0
17    return 1,1
18
19grade_report(VariableTest(namespace=globals(), r_tol=0.0001).test([
20    {
21        'name': name,
22        'expected': expected(name,name[0:3]),
23        'comparator': comparator,
24    } for name in "var_gewicht, var_groesse, var_bmi, ss_gewicht, ss_groesse, ss_bmi".split(', ')
25]), points=5)
26
27
28### END HIDDEN TESTS

============================================================
Variable Test

============================================================
6 / 6 tests passed!
============================================================
### BEGIN GRADE
5.0
### END GRADE

Task 1.10¶

[4 Point(s)]

Kovarianz¶

Berechnen Sie die Kovarianz $\sigma_\text{Gewicht,Größe}$ zwischen Gewicht und Größe und speichern sie in cov_gewicht_groesse:

1cov_gewicht_groesse = np.cov(gewicht, groesse, ddof=0)[0, 1]
2cov_gewicht_groesse

5632.9333005205235

 1### BEGIN HIDDEN TESTS
 2from assignmenttest import VariableTest, FunctionTest, grade_report, comparators
 3from numbers import Number
 4
 5def expected(name):
 6    return np.cov(gewicht, groesse, ddof=0)
 7
 8
 9def grade():
10    percentage = 1
11    exp = expected("gewicht_groesse")
12    
13    if 'cov_gewicht_groesse' not in globals():
14        print("Test for variable cov_gewicht_groesse failed.\nVariable cov_gewicht_groesse is not defined!")
15        return 0
16    
17    if type(cov_gewicht_groesse) == np.ndarray and np.allclose(cov_gewicht_groesse,exp):
18        percentage -= 0.5
19        print("Richtiger Ansatz, aber es ist nur nach der Kovarianz von Gewicht und Größe gefragt, nicht der ganzen Matrix")
20        return percentage
21            
22    
23    if type(cov_gewicht_groesse) == np.float64 and isclose(cov_gewicht_groesse,exp[0,1]):
24        return 1
25    
26    try:
27        if isclose(cov_gewicht_groesse, exp[0,1]):
28            return 1
29    except Exception:
30        print("Wrong result, expected:\n%s, but got:\n%s" % (exp, cov_gewicht_groesse))
31        return 0
32    
33    
34    return percentage
35
36grade_report(grade(), points=4)
37### END HIDDEN TESTS

### BEGIN GRADE
4
### END GRADE

Task 1.11¶

[3 Point(s)]

Visualisierung der Daten (ohne Ausreißer)¶

(Bei der Benotung wird natürlich auch auf die korrekte Beschriftung der Achsen, sowie den Titel des Diagramms geachtet.)

Gewicht:¶

Visualisieren Sie das Gewicht als Histogramm, beschränken Sie sich dabei jedoch auf Werte innerhalb des 95 % Quantils.

 1# imports und setup, falls nicht weiter oben schon passiert
 2from matplotlib import pyplot as plt
 3%matplotlib inline
 4
 5# Beispiel Array mit 200 zufälligen Werten im Bereich [0, 100)
 6bsp_array = np.random.rand(200) * 100
 7
 8# Beispiel-Code für einen Histogramm-Plot:
 9plt.hist(bsp_array)  # Histogramm
10plt.grid()  # Gitterlinien
11plt.xlabel('X Werte')  # Achsenbeschriftung
12plt.ylabel('Y Werte')  # Achsenbeschriftung
13plt.title('Beispielplot')  # Titel
14plt.show()  # Plot Anzeigen

1plt.hist(gewicht, range=[min(gewicht),q95_gewicht], rwidth=.8, align='right') # ist das richtig? wie berechne ich das 95% Quantil für den rage eines Plots
2plt.grid()  # Gitterlinien
3plt.xlabel('Gewicht')  # Achsenbeschriftung
4plt.ylabel('Anzahl an Testpersonen mit Gewicht')  # Achsenbeschriftung
5plt.title('Gewichtsverteilung')  # Titel
6plt.show()  # Plot Anzeigen

Task 1.12¶

[3 Point(s)]

Größe:¶

Visualisieren Sie die Größe als Histogramm, beschränken Sie sich dabei jedoch auf Werte innerhalb des 95 % Quantils.

1plt.hist(groesse, range=[min(groesse),q95_groesse], rwidth=.8, align='right') # ist das richtig? wie berechne ich das 95% Quantil für den rage eines Plots
2plt.grid()  # Gitterlinien
3plt.xlabel('Größe')  # Achsenbeschriftung
4plt.ylabel('Anzahl an Testpersonen mit Größe')  # Achsenbeschriftung
5plt.title('Größenverteilung')  # Titel
6plt.show()  # Plot Anzeigen

Task 2¶

[10 Point(s)]

Fairer Würfel¶

Programmierung eines fairen Würfels

Task 2.1¶

[7 Point(s)]

Fairer Würfel a)¶

Schreiben Sie eine Funktion myDice(numSeiten, anzahl), welche einen Würfel mit numSeiten Seiten simuliert.

Die Funktion soll dabei anzahl viele Würfe simulieren und als Liste, Tupel oder numpy Array zurückgeben.

Beispiel:

myDice(6, 3) --> (1, 4, 6)

Hinweis:

Für die Generierung von Zufallszahlen kann die Bibilothek random oder numpy.random benutzt werden.

from random import randint oder from numpy.random import randint.

Für Informationen zum Aufruf der randint Funktion führen Sie randint? aus und lesen Sie die Dokumentation. Die Definition der randint Funktion aus der random Bibliothek unterscheidet sich von der Definition der randint Funtkion aus der numpy Bibliothek!

 1def myDice(numSeiten: int, anzahl: int) -> [int]:
 2    """
 3    Werfe einen Wuerfel mehrmals
 4    
 5    Arguments:
 6        numSeiten  -- Anzahl der Seiten des Wuerfels
 7        anzahl     -- Wie oft der Wuerfel geworfen wird
 8    Returns:
 9        ergebnisse -- Liste der gewuerfelten Augenzahlen
10    """        
11    return [(rd.randint(1,numSeiten)) for _ in range(anzahl)]
12
13myDice(6,3)

[4, 3, 6]

 1### BEGIN HIDDEN TESTS
 2from collections import Counter
 3import numpy as np
 4
 5def testMyDice(numFaces, numThrows, meanErrorLimit):
 6    expectedCount = numThrows // numFaces
 7
 8    throws = myDice(numFaces, numThrows)
 9    count = Counter(throws)
10    
11    # Assert each face is contained in the throws at least once
12    for i in range(1, numFaces + 1):
13        assert i in throws, 'Face {} not in throws!'.format(i)
14        
15    # Calculate the difference from the expected value
16    diff = []
17    for i in range(1, numFaces + 1):
18        diff.append(abs(expectedCount - count[i]))
19
20    meanError = np.mean(diff)/expectedCount
21    
22    assert meanError <= meanErrorLimit, \
23        'Mean difference from expected value is more than {:.2f}% ({:.2f}%)'\
24            .format(meanErrorLimit*100, meanError*100)
25    
26
27
28testMyDice(6, 10000, 0.05)
29testMyDice(4, 10000, 0.05)
30testMyDice(60, 10000, 0.1)
31### END HIDDEN TESTS

Task 2.2¶

[3 Point(s)]

Fairer Würfel b) - Visualisierung¶

Erstellen Sie ein Histogramm des Würfels für numSeiten = 6 und anzahl = 1200.

(Bei der Benotung wird neben sinnvoller Anzahl und Positionierung der bins natürlich auch auf die korrekte Beschriftung der Achsen, sowie den Titel des Diagramms geachtet.)

 1# imports und setup, falls nicht weiter oben schon passiert
 2from matplotlib import pyplot as plt
 3%matplotlib inline
 4
 5# Beispiel-Code für einen Histogramm-Plot mit 5 Bins:
 6plt.hist([1, 1, 1, 3, 3, 4, 5, 5, 5, 5], range=(.5, 5.5), bins=5)  # Histogramm
 7plt.grid()  # Gitterlinien
 8plt.xlabel('X Werte')  # Achsenbeschriftung
 9plt.ylabel('Y Werte')  # Achsenbeschriftung
10plt.title('Beispielplot')  # Titel
11plt.show()  # Plot Anzeigen

1plt.hist(myDice(6,1200), bins=range(1,8), rwidth=0.8, align='left')  # Histogramm
2plt.grid()  # Gitterlinien
3plt.xlabel('Augenzahl')  # Achsenbeschriftung
4plt.ylabel('Würfel mit Augenzahl')  # Achsenbeschriftung
5plt.title('Würfelverteilung mit 6 Augen und 1200 Würfeln')  # Titel
6plt.show()  # Plot Anzeigen

Task 3¶

[20 Point(s)]

Summe mehrerer Würfel¶

Task 3.1¶

[10 Point(s)]

Summe mehrerer Würfel a) - Implementierung¶

Schreiben Sie eine Funktion, die mehrere Würfel gleichzeitig wirft und die Summen der Augenzahlen zurückgibt.

Die Funktion myDiceSum(numSeiten, anzahlWuerfel, anzahlWuerfe) soll anzahlWuerfel mit numSeiten gleichzeitig werfen, die Summe berechnen und dieses Experiment anzahlWuerfe oft wiederholen.

Beispiel:

myDiceSum(6, 2, 5) --> (4, 7, 12, 10, 8)

Der Rückgabewert soll also ein Tupel, eine Liste oder ein numpy Array der Summen der Augenzahlen sein.

 1import numpy as np
 2
 3def myDiceSum(numSeiten: int, anzahlWuerfel: int, anzahlWuerfe: int) -> [int]:
 4    """
 5    Werfe mehrere Wuerfel mehrmals gleichzeitig und bestimme die Summen
 6    
 7    Arguments:
 8        numSeiten     -- Anzahl der Seiten pro Wuerfel
 9        anzahlWuerfel -- Anzahl der gleichzeitig geworfenen Wuerfel
10        anzahlWuerfe  -- Wie oft die Wuerfel geworfen werden
11    Returns:
12        summen        -- Liste der Summen der Augenzahlen der Wuerfel
13    
14    """
15    return([(sum([rd.randint(1,numSeiten) for _ in range(anzahlWuerfel)])) for _ in range(anzahlWuerfe)])
16
17myDiceSum(6, 2, 5)

[8, 6, 5, 8, 9]

 1### BEGIN HIDDEN TESTS
 2from itertools import product
 3from collections import Counter
 4
 5def probSum(numFaces, numDie):
 6    '''
 7    Probability of the sum of the faces when rolling several die
 8    '''
 9    faces = list(range(1, numFaces+1))
10    lists = []
11    for i in range(numDie):
12        lists.append(faces)
13    prod = product(*lists)
14    countOfSum = Counter([sum(p) for p in prod])
15    num = sum([countOfSum[c] for c in countOfSum])
16    probs = {c: countOfSum[c]/num for c in countOfSum}
17    return probs
18
19def testDiceSum(numFaces, numDie, numThrows, meanErrorLimit):
20    throws = myDiceSum(numFaces, numDie, numThrows)
21    
22    # Make sure the sum is in proper bounds
23    assert min(throws) >= numDie, \
24        'The minimum sum can\'t be smaller than the number of die!'
25    assert max(throws) <= numFaces*numDie, \
26        'The maximum sum can\'t be bigger than the number of faces times the number of die!'
27    
28    # Get the expected number each sum is rolled
29    probs = probSum(numFaces, numDie)
30    expected = {s: probs[s]*numThrows for s in probs}
31    actual = Counter(throws)
32    meanError = np.mean([abs(actual[s] - expected[s])/expected[s] for s in expected])
33    
34    assert meanError <= meanErrorLimit, \
35        'Mean difference from expected value is more than {:.2f}% ({:.2f}%)'\
36            .format(meanErrorLimit*100, meanError*100)
37    
38    
39# Test 1
40numFaces = 6
41numDie = 2
42numThrows = 100000
43meanErrorLimit = 0.05
44
45testDiceSum(numFaces, numDie, numThrows, meanErrorLimit)
46
47# Test 2
48numFaces = 4
49numDie = 4
50numThrows = 100000
51meanErrorLimit = 0.05
52
53testDiceSum(numFaces, numDie, numThrows, meanErrorLimit)
54### END HIDDEN TESTS

Task 3.2¶

[5 Point(s)]

Summe mehrerer Würfel b) - Histogramm¶

Erstellen Sie ein Histogramm für die Summe mehrerer Würfel.

Nehmen Sie dafür zwei Würfel mit je 6 Seiten und insgesamt 1000 Würfen.

Hinweis:

Die Funktion plt.hist hat die Parameter range und bins. Stellen Sie sicher, dass für jedes Würfelergebnis genau ein Bin existiert, auch wenn es nicht vorkommt. (Bei der Benotung wird neben sinnvoller Anzahl und Positionierung der Bins natürlich auch auf die korrekte Beschriftung der Achsen, sowie den Titel des Diagramms geachtet.)

1import matplotlib.pyplot as plt
2
3plt.hist(myDiceSum(6,2,1200), bins=range(2,14), rwidth=0.8, align='left')  # Histogramm
4plt.grid()  # Gitterlinien
5plt.xlabel('Augenzahl')  # Achsenbeschriftung
6plt.ylabel('Würfel mit Augenzahl')  # Achsenbeschriftung
7plt.title('Würfelverteilung mit 2 Würfeln mit 6 Augen und 1200 Würfen')  # Titel
8plt.show()  # Plot Anzeigen

Task 3.3¶

[3 Point(s)]

Summe mehrerer Würfel c) - Histogramm¶

Wiederholen Sie das Experiment aus b) mit zehn Würfeln mit je 4 Seiten und insgesamt 10000 Würfen.

1import matplotlib.pyplot as plt
2data = myDiceSum(4,10,10000)
3plt.hist(data, bins=range(10,41), rwidth=0.8, align='left')  # Histogramm
4plt.grid()  # Gitterlinien
5plt.xlabel('Augenzahl')  # Achsenbeschriftung
6plt.ylabel('Würfel mit Augenzahl')  # Achsenbeschriftung
7plt.title('Würfelverteilung mit 10 Würfeln mit 4 Augen und 10000 Würfen')  # Titel
8plt.show()  # Plot Anzeigen

Task 3.4¶

[1 Point(s)]

Summe mehrerer Würfel d) - Minimale Augensumme ¶

Was ist beim Experiment aus c) die minimal mögliche Augensumme?

Task 3.5¶

[1 Point(s)]

Summe mehrerer Würfel e) - Maximale Augensumme ¶

Was ist beim Experiment aus c) die maximal mögliche Augensumme?

Task 4¶

[30 Point(s)]

Münzwurf¶

Münzen eignen sich, um eine faire Entscheidung zu treffen. Dazu wählt eine Person Kopf und die andere Zahl. Jedes der beiden Ereignisse ist gleich wahrscheinlich.

Anstatt nur einen Münzwurf zu betrachten, kann man auch eine Folge von Münzwürfen betrachten. Ein Freund schlägt Ihnen folgendes Spiel vor:

Jeder der zwei Spieler wählt das Ergebnis zwei aufeinander folgender Münzwürfe. Beispielsweise wählt der erste Spieler die Folge Kopf-Kopf ( $KK$ ), der zweite Spieler die Folge Zahl-Zahl ( $ZZ$ ).

Nun wird eine Münze solange geworfen bis eines der beiden Ereignisse auftritt. Beispielweise kann sich die Folge $ZKZKZKZZ$ ergeben, bei der Spieler 2 gewinnt (da die letzten beiden Würfe Zahl-Zahl sind).

Wählt Spieler 1 $ZK$ und Spieler 2 $KK$ und lautet die Folge $KZZZK$ hätte Spieler 1 gewonnen.

Task 4.1¶

[15 Point(s)]

Münzwurf a)¶

Um ein Gefühl für die Wahrscheinlichkeiten zu bekommen, bietet es sich an ein Spiel zu simulieren.

Schreiben Sie hierzu eine Funktion muenzSpiel(folge1, folge2) welche genau ein Spiel simuliert und den Gewinner zurückgibt (entweder den String 'Spieler 1' falls folge1 zuerst auftritt oder den String 'Spieler 2' falls folge2 zuerst auftritt).

Benutzen Sie in Ihrer Funktion die Funktion muenze() die das Ergebnis genau eines zufälligen Münzwurfs zurückgibt.

Beispiel:

muenzSpiel('KK', 'ZZ') --> 'Spieler 1'

muenzSpiel('KK', 'ZZ') --> 'Spieler 2'

Hinweis: Der Rückgabewerte ist also ein String. Er enthält ein Space vor der Zahl! ...

 1import numpy as np
 2
 3def muenze() -> str:
 4    """
 5    Werfe eine Muenze einmal
 6    
 7    Returns:
 8        seite -- Seite die oben liegt (entweder Z oder K)
 9    """
10    seiten = ['K', 'Z']
11    return seiten[np.random.randint(0, 2)]
12
13def muenzSpiel(folge1: str, folge2: str) -> str:
14    """
15    Werfe eine Muenze solange, bis eine der beiden Eingabefolgen auftritt
16    
17    Arguments:
18        folge1   -- Folge fuer Spieler 1
19        folge2   -- Folge fuer Spieler 2
20    Returns:
21        gewinner -- Wessen Folge zuerst auftritt 
22    """
23    folge = ""
24    while True:
25        folge+=muenze()
26        if folge.endswith(folge1):
27            return "Spieler 1"
28        if folge.endswith(folge2):
29            return "Spieler 2"
30
31muenzSpiel('KK', 'ZZ')

'Spieler 2'

 1### BEGIN HIDDEN TESTS
 2from collections import Counter
 3import numpy as np
 4
 5def test_correct_labels(spiel):
 6    assert 'Spieler 1' in spiel, 'Label Spieler 1 nicht in den Ergebnissen'
 7    assert 'Spieler 2' in spiel, 'Label Spieler 2 nicht in den Ergebnissen'
 8    
 9def test_distribution(observed, expected, mean_error_limit):
10    mean_error = np.mean([abs(x[0] - x[1])/x[1] for x in zip(observed, expected)])
11    assert mean_error <= mean_error_limit, 'Observed: {}, Expected {} -> Mean Error = {}, exceeds limit of {}'\
12                                            .format(observed, expected, mean_error, mean_error_limit)
13
14# Simuliere alle Spiele 1000 mal
15spiel_KK_ZZ = Counter([muenzSpiel('KK', 'ZZ') for i in range(1000)])
16spiel_KK_ZK = Counter([muenzSpiel('KK', 'ZK') for i in range(1000)])
17spiel_KK_KZ = Counter([muenzSpiel('KK', 'KZ') for i in range(1000)])
18spiel_ZK_ZZ = Counter([muenzSpiel('ZK', 'ZZ') for i in range(1000)])
19spiel_ZK_KZ = Counter([muenzSpiel('ZK', 'KZ') for i in range(1000)])
20spiel_KZ_ZZ = Counter([muenzSpiel('KZ', 'ZZ') for i in range(1000)])
21
22spiele = [spiel_KK_ZZ, spiel_KK_ZK, spiel_KK_KZ,
23          spiel_ZK_ZZ, spiel_ZK_KZ, spiel_KZ_ZZ]
24
25# Teste auf korrekte return Label
26for spiel in spiele:
27    test_correct_labels(spiel)
28
29# Wandle in Liste um mit erstem Eintrag für Spieler 1 und zweiten für Spieler 2
30KK_ZZ = [spiel_KK_ZZ['Spieler 1'], spiel_KK_ZZ['Spieler 2']]
31KK_ZK = [spiel_KK_ZK['Spieler 1'], spiel_KK_ZK['Spieler 2']]
32KK_KZ = [spiel_KK_KZ['Spieler 1'], spiel_KK_KZ['Spieler 2']]
33ZK_ZZ = [spiel_ZK_ZZ['Spieler 1'], spiel_ZK_ZZ['Spieler 2']]
34ZK_KZ = [spiel_ZK_KZ['Spieler 1'], spiel_ZK_KZ['Spieler 2']]
35KZ_ZZ = [spiel_KZ_ZZ['Spieler 1'], spiel_KZ_ZZ['Spieler 2']]
36
37# Expected
38KK_ZZ_expected = [500, 500]
39KK_ZK_expected = [250, 750]
40KK_KZ_expected = [500, 500]
41ZK_ZZ_expected = [500, 500]
42ZK_KZ_expected = [500, 500]
43KZ_ZZ_expected = [750, 250]
44
45
46# Prüfe auf richtige Verteilung
47
48mean_error_limit = 0.1
49
50test_distribution(KK_ZZ, KK_ZZ_expected, mean_error_limit)
51test_distribution(KK_ZK, KK_ZK_expected, mean_error_limit)
52test_distribution(KK_KZ, KK_KZ_expected, mean_error_limit)
53test_distribution(ZK_ZZ, ZK_ZZ_expected, mean_error_limit)
54test_distribution(ZK_KZ, ZK_KZ_expected, mean_error_limit)
55test_distribution(KZ_ZZ, KZ_ZZ_expected, mean_error_limit)
56### END HIDDEN TESTS

Task 4.2¶

[5 Point(s)]

Münzwurf b)¶

Benutzen Sie Ihre Funktion aus Teil a) um 1000 Spiele zu simulieren. Füllen Sie dafür eine Liste mit den Ergebnissen der Funktion muenzSpiel('KK', 'ZZ').

Erzeugen Sie ein Histogramm für die Ergebnisse der 1000 Spiele.

 1import matplotlib.pyplot as plt
 2
 3data = [muenzSpiel('KK', 'ZZ') for _ in range(1000)]
 4fig, ax = plt.subplots()
 5players = ['Spieler 1', 'Spieler 2']
 6heights = [data.count(p) for p in players]
 7bar_colors = ['tab:blue', 'tab:red']
 8
 9ax.bar(players, heights, label=players, color=bar_colors)
10plt.grid()  # Gitterlinien
11plt.xlabel('Anzahl der gewonnen Spiele')  # Achsenbeschriftung
12plt.ylabel('Spieler')  # Achsenbeschriftung
13plt.title('Gewinner bei Münzwurfspiel')  # Titel
14
15plt.show()

Task 4.3¶

[10 Point(s)]

Münzwurf c)¶

Nehmen Sie an, Sie wissen, dass der andere Spieler immer die Folge $KK$ wählt.

Welche Folge sollten Sie wählen um Ihre Gewinnchance zu maximieren? Experimentieren Sie! Wie hoch ist die Wahrscheinlichkeit zu gewinnen?

Speichern Sie die sinnvollste Folge als String in der Variablen Folge. Speichern Sie die zugehörige Wahrscheinlichkeit in der Variablen Gewinnwahrscheinlichkeit.

1from collections import Counter
2
3Folge = 'ZK'
4Gewinnwahrscheinlichkeit = 0.75
5
6c = Counter([muenzSpiel('KK', Folge) for _ in range(10000)])
7print(c.most_common())

[('Spieler 2', 7484), ('Spieler 1', 2516)]

 1# Dies ist eine Testzelle, bitte ignorieren Sie diese!
 2### BEGIN HIDDEN TESTS
 3from e2xgradingtools import VariableTest, FunctionTest, grade_report, comparators
 4from numbers import Number
 5
 6Folge_is_ZK = Folge == 'ZK'
 7grade_report(VariableTest(namespace=globals(), a_tol=.1).test([
 8    {'name': 'Gewinnwahrscheinlichkeit', 'expected': .75, 'expected_type': Number},
 9    {'name': 'Folge_is_ZK', 'expected': True, 'expected_type': bool},
10
11]), points=10)
12
13
14### END HIDDEN TESTS

============================================================
Variable Test

============================================================
2 / 2 tests passed!
============================================================
### BEGIN GRADE
10.0
### END GRADE

Viel Erfolg¶

Erinnerungen: Ausführbar? Errors Raised? Abgegeben?

Stellen Sie sicher, dass sich Ihr Code ausführen lässt. Code der nicht läuft kann nicht automatisch bewertet werden.
Bevor Sie abgeben: Klicken Sie im Menü auf Kernel > Restart & Run All (oder den Button in der Toolbar). Damit führen Sie das Notebook linear von oben nach unten aus. Alle Fehler die dann auftreten, treten auch beim Bewerten auf.
Entfernen Sie die raise NotImplementedError(), wenn Sie eine Aufgabe bearbeiten. Ansonsten wird beim Bewerten eine Exception ausgelöst, die uns sagt, dass Sie die Aufgabe nicht bearbeitet haben!
Vergessen Sie nicht Ihr bearbeitetes Notebook zu abzugeben (Assignment Tab / Submit Button)! Einfaches Speichern reicht nicht und wird nicht bewertet.

Timestamp:

2023-10-19 10:11:40.027880 CEST

WuS_Hausaufgabe_1 (Score: 99.0 / 100.0)

Wahrscheinlichkeitstheorie und Statistik

WS 2023 / 2024

WuS Hausaufgabe 1

Abgabetermin

Viel Erfolg!

Hinweise zur Bearbeitung der Übung

Allgemeine Informationen:

Angabe von Ergebnissen

Programmcode

Task 1¶

Deskriptive Statistik: Body Mass Index¶

Task 1.1¶

Merkmalsskalen ¶

Task 1.2¶

Anzahl der Datenpunkte¶

Task 1.3¶

min und max¶

Task 1.4¶

Berechnung des Merkmals BMI¶

Task 1.5¶

Modus¶

Task 1.6¶

Median¶

Task 1.7¶

Quantile¶

Task 1.8¶

Mittelwert¶

Task 1.9¶

Varianz¶

Task 1.10¶

Kovarianz¶

Task 1.11¶

Visualisierung der Daten (ohne Ausreißer)¶

Gewicht:¶

Task 1.12¶

Größe:¶

Task 2¶

Fairer Würfel¶

Task 2.1¶

Fairer Würfel a)¶

Task 2.2¶

Fairer Würfel b) - Visualisierung¶

Task 3¶

Summe mehrerer Würfel¶

Task 3.1¶

Summe mehrerer Würfel a) - Implementierung¶

Task 3.2¶

Summe mehrerer Würfel b) - Histogramm¶

Task 3.3¶

Summe mehrerer Würfel c) - Histogramm¶

Task 3.4¶

Summe mehrerer Würfel d) - Minimale Augensumme ¶

Task 3.5¶

Summe mehrerer Würfel e) - Maximale Augensumme ¶

Task 4¶

Münzwurf¶

Task 4.1¶

Münzwurf a)¶

Task 4.2¶

Münzwurf b)¶

Task 4.3¶

Münzwurf c)¶

Viel Erfolg¶

Erinnerungen: Ausführbar? Errors Raised? Abgegeben?

2023-10-19 10:11:40.027880 CEST