"Die Musterlösugen der einzelnen Aufgaben befindet sich direkt in den entsprechenden Jupyter-Notebooks. In diesem Notebook möchte ich nochmal auf einige beliebte Fehler so wie die Auswertungsaufgabe zum Thema Fitten eingehen. \n",
"\n",
"## Fehlermeldungen in Python:\n",
"Einigen von euch sind über ein paar Fehlermeldungen gestolpert und wussten nicht genau wie diese zu beheben sind. Im Grunde sind Fehlermeldungen in Python sehr einfach zu verstehen und es bedarf lediglich ein wenig Übung. Schauen wir uns zunächst einmal eine typische Fehlermeldung in Python an:\n",
"Diese sieht erst einmal schrecklich kompliziert aus, die wichtigsten Informationen sind jedoch farbig hervorgehoben. Gehen wir diese doch einmal Schritt für Schritt durch.\n",
"\n",
"1. Art der Fehlermeldung. Meistens ist dies ein erster guter Indikator wie der Fehler zustanden gekommen ist.\n",
"2. Beschreibung des Fehlers, hier steht meistens etwas ausführlicher was genau das Problem ist. Wir werde uns im Nachfolgenden noch ein paar Beispiele angucken.\n",
"3. Ort in eurem Hauptprogramm an dem der Fehler aufgetreten ist. \n",
"4. Exakte Position an welcher der Fehler aufgetreten ist. Dies kann gleich sein mit Punkt 3. sofern eure Funktion nicht innerhalb einer weiteren Funktion (hier `curve_fit`) verwendet wird. \n",
"\n",
"Der schwarz umrandete Teil kann bei sehr komplexen Funktionen sehr länglich ausfallen. In der Regel können wir dies jedoch ignorieren und uns nur auf den Anfang und das Ende der Fehlermeldung konzentrieren.\n",
"\n",
"### Beispiele:\n",
"\n",
"Im Folgenden möchte euch ein paar beliebte Fehler vorstellen. Führt einfach die entsprechenden Zellen aus um die Fehlermeldung euch anzugucken.\n",
"\n",
"Fangen wir einfach an:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"nicht_definiert"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Diese Fehlermeldung ist relative selbsterklärend. Der Fehlertyp ist ein `NameError` und der dazugehörige Fehlertext sagt uns, dass die Variable `nicht_definiert` noch nicht definiert wurde. \n",
"\n",
"Außerdem verrät uns Python, dass `nicht_definiert` in Zeile 1 unserer Zelle ausgeführt wird. Um die Zellennummerierung angezeigt zubekommen müsst ihr die Zelle anwählen und mit Esc in den Editiermodus wechseln. Nun könnt ihr mit dem Buchstaben \"L\" die Zeilennummerierung aktivieren. Dies kann bei längeren Code-Blöcken sehr hilfreich sein. \n",
"\n",
"Ein ähnlicher Fehler tritt auf sofern ihr versucht eine Funktion aus einem Package zu laden welche nicht existiert. Zum Beispiel, weil ihr euch verschrieben habt:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"plt.plott([1,2,3,4]) # vertippt"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Da es sich hierbei jedoch um eine Funktion innerhalb eins Packages handelt spricht man von einem `AttributeError` (Warum es sich um ein Attribut handelt lernt ihr noch ausführlicher in anderen Programmierveranstaltungen). \n",
"\n",
"Richtig wäre:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.plot([1,2,3,4]) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ein weiterer beliebter Fehler ist der folgende:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a = 1+1\n",
"b = 2\n",
"[[1,a,b,4] # Beispiel verschachtelte Liste"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Bei diesem Fehler handelt es sich um einen Syntaxfehler, der besagt, dass Python das Ende eures Codes erreicht hat (end of file EOF), jedoch nicht alle Code-Blöcke abgeschlossen sind. In diesem konkreten Beispiel liegt es daran, dass wir vergessen haben die Klammer der zweiten Liste zu schließen. Korrigiert sieht die Zelle wie folgt aus:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a = 1+1\n",
"b = 2\n",
"[[1,a,b,4]] # Beispiel verschachtelte Liste"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dieser Fehler kann auch vorkommen sofern ihr Code-Blöcke in for-Schleifen vergesst."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for i in range(4):"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Manche von euch haben versehentlich einen Zeilenumbruch innerhalb eines string verwendet. Hier bekommt ihr eine ähnliche Fehlermeldung."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"String mit \n",
" Zeilenumbruch\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So wäre es richtig:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"String mit \" \n",
" \"Zeilenumbruch\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ein anderer Fehler, welcher mal leicht durch das überdefinieren von Variablen passieren kann, ist der folgende:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def quadrat(x):\n",
" return x**2\n",
"\n",
"quadrat = [1**2, 2**2, 3**2]\n",
"\n",
"quadrat(3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"oder"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"quadrat = 2\n",
"quadrat(3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Bei dieser Art von Fehler handelt es sich um einen TypeError. Ein TypeError besagt, dass ein Objekt (hier `quadrat`) nicht mit dem vom Python erwartenden Typ übereinstimmt. In unserem obigen Beispiel erwarten wir ein Objekt vom Typ `callable` was im Allgemeinen eine Funktion represntiert z.B.: unsere Funktion:\n",
"\n",
"```python\n",
"def quadrat(x):\n",
" return x**2\n",
"```\n",
"\n",
"Leider haben wir diese jedoch versehentlich einmal mit einer Liste und einmal mit einem Intiger überdefiniert. Python weiß hierdurch leider nicht, was `[1**2, 2**2, 3**2](3)` bzw. `3(3)` bedeuten soll. Versucht daher eindeutige Variablennamen zu benutzen. \n",
"\n",
"Als letztes hier noch ein Fehler, welcher euch beim Plotten und Fitten unterlaufen kann:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"xWerte = [1, 2, 3, 4]\n",
"yWerte = [1, 2, 4]\n",
"\n",
"plt.plot(xWerte, yWerte)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dieser Fehler besagt euch, dass eure Liste für die x-Werte und eure Liste für die y-Werte nicht die gleiche länge haben. Dies kann leicht beim Abtippen von Messdaten passieren.\n",
"\n",
"Ich hoffe, dass diese Beispiele euch helfen werden in Zukunft besser mit Fehlermeldungen umzugehen. Hier noch drei allgemeine Tipps zum Programmieren und Fehlerbeheben in Jupyter-Notebooks:\n",
"\n",
"1. Wenn ihr euren Code schreibt führt nach jeder neuen Zeile/Funktion euren Code aus und überprüft ob das Resultat mit euren Erwartungen übereinstimmt. \n",
"2. Solltet ihr eine Fehlermeldung bekommen und ihr seht nicht genau wie dieser Fehler zu beheben ist, kopiert euch Zeile für Zeile (bzw. Funktion) den Code in eine neue Zelle und führte diesen aus. Meistens findet man hierdurch sehr schnell wo das Problem liegt. \n",
"3. Da ihr in einem Notebook Zellen in willkürlicher Reihenfolge ausführen könnt, kann es leicht passieren, dass ihr Variablen überdefiniert. Solltet ihr also mal komplett verloren sein kann es hilfreich sein den Kernal neu zu starten, um alle Variablen zu löschen.\n",
" * Geht hierzu in der Menüleiste auf Kernal.\n",
" * Klickt anschließend auf Restart.\n",
" * Anschließend müsst ihr erneut alle Zellen (in der richtigen Reihenfolge) ausführen.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Lösungen zum Thema Fitten:\n",
"\n",
"In diesem Abschnitt wollen wir uns den Lösungen zum Thema Fitten widmen. Neben den Musterlösungen zu den Aufgaben, befindet sich am Ende nochmal ein weiteres Beispiel zu illustration.\n",
"\n",
"## Bestimmen der Fallbeschleunigung des Planeten X:\n",
"Stellen Sie sich den folgenden Versuch vor: Jahr 2132, die Firma SpaceYpsilon hat Sie auf eine Außenmission auf den Planeten ?? geschickt. Hier sollen Sie zusammen mit ihrem Versuchspartner/in die Fallbeschleunigung g?? des Planeten bestimmen. Als Versuch lassen sie eine Kugel aus unterschiedlichen Fallhöhen innerhalb einer evakuierten Glasröhre fallen. Sie lassen die Kugel insgesamt aus 10 unterschiedlichen\n",
"Höhen Fallen.\n",
"\n",
"Basierend auf der Versuchsbeschreibung wissen wir, dass es sich bei dem Versuch um einen Freien Fall handelt, welcher als eine gleichförmig beschleunigte Bewegung beschrieben werden kann. D.h. es liegt der folgende Zusammenhang zwischen den gemessenen Höhen und Fallzeiten vor:\n",
"\n",
"$$h(t, g) = 1/2 \\cdot g \\cdot t^2$$ \n",
"\n",
"### Aufgabenstellung:\n",
"\n",
"Bestimmen Sie mit Hilfe ihrer Vorbereitungsaufgabe 1 und der entsprechenden Funktion die\n",
"Fallbeschleunigung g?? mittels eines Chi²-Fits. Diskutieren Sie anschließend mittels der Güte\n",
"Ihres Fits ob ihre Fitfunktion die gemessenen Daten gut widerspiegelt. Auf welchen Planeten\n",
"in unserem Sonnensystem befinden Sie sich?\n",
"Testen Sie anschließend ob nicht ein linearere Fit besser geeignet wäre. Begründen Sie Ihre\n",
"chi = sum([(fallhoehe(t, para[0]) - h)**2/dh**2 for t, h, dh in zip(time, height, dheight)])\n",
"\n",
"print(f'''\n",
"Das die Fitgüte Chi²/ndof lautet {chi:.2f}/{len(height)-1}\n",
"und der Wert für g ist {para[0]:.2f} +/- {pcov[0,0]:.2f} m/s\n",
"''')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie ihr seht ist unser $\\chi^2$/ndof (wobei ndof die Anzahl an Freiheitsgrade sind) nicht schlecht. Darüber hinaus scheint der Fehler des Wertes kleiner zu sein als die Anazahl an signifikanten Stellen die uns zur Verfügung stehen. \n",
"\n",
"Als zweites sollen wir das ganze nochmal wiederholen um zu testen ob ein lineare Fit nicht besser an die Daten passt."
"chi = sum([(fallhoehe2(t, para2[0], para2[1]) - h)**2/dh**2 for t, h, dh in zip(time, height, dheight)])\n",
"\n",
"print(f'''\n",
"Das die Fitgüte Chi²/ndof lautet {chi:.2f}/{len(height)-1}\n",
"und der Wert für g ist {para2[0]:.2f} +/- {pcov2[0,0]:.2f} m/s\n",
"''')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie ihr sehen könnt ist hier das $\\chi^2$ wesentlich schlechter und somit ist die Hypothese, dass es sich um ein lineares Model handeln könnte abgelehnt. Zu letzt können wir noch unsere beiden Ergebnisse gemeinsam mit den Daten plotten:"
"Wie wir bereits am Versuchstag selbst festgestellt haben, können bei einem einfachen $\\chi^2$ Fit lediglich die Fehler des Funktionswertes berücksichtigt werden. Da in unseren obigen Messdaten der Zeitfehler dominiert wollen wir nun noch einmal angucken, was denn passiert sofern wir die beiden Achsen tauschen. D.h. dieses mal wollen wir eine Funktion t(h, g) an unsere Messdaten anpassen:\n",
"\n",
"$$t(h, g) = \\sqrt{2 \\cdot h/g}$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Gucken wir uns zunächst wieder die Messdaten an:"
"chit = sum([(fallzeit(h, para[0]) - t)**2/dt**2 for t, h, dt in zip(time, height, dtime)])\n",
"\n",
"print(f'''\n",
"Das die Fitgüte Chi²/ndof lautet {chit:.2f}/{len(height)-1}\n",
"und der Wert für g ist {parat[0]:.2f} +/- {pcovt[0,0]:.2f} m/s\n",
"''')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie ihr sehen könnt sind die Werte für $g$ fast identisch mit den Werten des vorherigen Fits, jedoch sieht das $\\chi^2$ dieses mal aufgrund der größeren Fehler besser aus. Dies spricht dafür, dass die Fehler von der Fallhöhe unterschätzt worden sind."
"# Bestimmen der Erdbeschleunigung mittels curve_fit und einer schiefen Ebene:\n",
"\n",
"Der Zusammenhang der zurückgelegten Strecke $s$ einer Vollkugel auf einer schiefen Ebene ist gegeben durch:\n",
"\n",
"$$ s(t) = \\frac{5}{14} \\cdot g \\cdot \\sin(\\alpha) \\cdot t^2$$\n",
"\n",
"Während des Versuchs wurden jedoch die Startfallhöhe $h$ und die benötigte Zeit $t_\\text{i}$ gemessen (wobei $i$ der Index für eure drei Messversuche ist.). Dies bedeutet, dass wir unsere obige Formel in Abhängigkeit dieser beiden Parameter ausdrücken müssen um $g$ mittels eines Fits bestimmen zu können. Das können wir erreichen sofern wir den folgenden Zusammenhang verwenden\n",
"\n",
"$$ \\sin(\\alpha) = \\frac{h}{l} $$\n",
"\n",
"wobei $l$ die Länge unserer schiefen Ebene ist. Setzen wir dies in unsere obige Formel ein und lösen die Gleichung nach $h$ auf so erhalten wir\n",
"wobei wir hier noch verwendet haben das die maximal zurückgelegte Strecke der Kugel nach einer Zeit $t_\\text{i}$ der Gesammtlänge der schiefen Ebene entspricht. Diese Formel für $h$ können wir nun auf unterschiedliche Arten und Weisen in Abhängigkeit der Zeit setzen wobei die bereits gezeigte Variante die erste ist:\n",
"Nun müssen wir uns unsere Formel definieren um unsere Messdaten fitten zu können. Hierbei ist es wichtig das eine Fitfunktion $\\lambda$ von dieser Form ist $\\lambda(x, \\Theta)$ woebei $\\Theta$ unsere Parameter sind. In unserem Fall entspricht dies einer Funktion $h(t, g)$ bzw. in den anderen beiden Varianten $h(x, g)$ wobei $x=1/t$ und $x=1/t^2$ in den Varianten 2 und 3 ist. "
"Als nächstes sollten wir zu jeder Fallhöhe den Mittelwert unserer drei Zeitmessungen bilden und den entsprechenden Fehler berechnen. Hierdurch erhalten wir ein genaueres Ergebnis für unsere gesuchte Zahl von $g$.\n",
"\n",
"D.h. wir müssen uns zunächst eine Funktion definieren, welche den Mittelwert für unsere Messwerte berechnet\n",
"Man kann anhand des Plots bereits schön den nicht linearen Zusammenhang zwischen der Starthöhe $h$ und der Rollzeit $t$ erkennen. Als nächstes wollen wir nun aus diesen Daten unsere Erdbeschleunigung $g$ bestimmen. Hierzu verwenden wir wieder unsere Funktion `curve_fit`. Im folgenden möchte ich jedoch nochmal anhand dieses Datensatzes illustrieren, was curve_fit genau macht. Hierzu gucken wir uns die nachfolgenden Plots an (ignoriert zunächst einmal den Code)."
"Wie ihr sehen könnt, können wir durch einfaches ausprobieren feststellen welcher Wert von $g$ am besten zu unseren Messwerten passt. Und genau das macht curve_fit für euch. Curve_fit probiert solange (nach der Methode der kleinsten Quadrate), verschiedene Werte von $g$ aus bis es den am besten passenden Wert gefunden hat. Probieren wir dies nochmal aus:"
"Hierbei schreibt curve_fit das Ergebnis der besten Werte in die Variable `parameter` und den deren Fehler in eine so genannte Kovarianzmatrix. Sprich das Ergebnis sieht für eine Funktion mit drei Parametern `def f(x, p1, p2, p3):` allgemein so aus:\n",
"\n",
"```\n",
"paramter = [p1, p2, p3]\n",
"covariance = [[cov_1,1, cov_1,2, cov_1,3], \n",
" [cov_2,1, cov_2,2, cov_2,3],\n",
" [cov_3,1, cov_3,2, cov_3,3]]\n",
"```\n",
"wobei `cov_i,i` der Varianz sprich dem $\\sigma^2$ des Parameters i entspricht. Da wir in unserem Beispiel lediglich einen Parameter haben sieht das Ergebnis wie folgt aus:"
"print(f' Das chi-quadrat und die Anzhal der Freiheitsgrade sind: {chi:.0f}/{ndof}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie ihr seht ist das $\\chi^2/$ndof > 1, was bedeutet, dass unsere Fitfunktion die Daten nicht ganz wiederspiegelt. Um dies nachvollziehen zu können gucken wir uns erst einmal den finalen Plot an:"
"Wie ihr seht weicht unsere Funktion lediglich leicht von dem Großteil unserer Messdaten ab. Lediglich für kleine und große Fallhöhen ist die Abweichung stärker und unsere Funktion beschreibt die Messdaten nicht genau genug. Dies erklärt den leicht erhöhten Wert für unser $\\chi^2$/ndof. Woran könnte dies liegen? "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Bestimmen von mehren Parameter mittels curve_fit:\n",
"\n",
"Und weil es so schön ist hier noch ein letztes Beispiel zum Thema fitten. Einige von euch haben sich gefragt warum ich überhaupt fitten muss wenn ich bei einfachen Funktionen wie zum Beispiel\n",
"\n",
"$$ s(t) = 1/2 \\cdot g \\cdot t^2$$\n",
"\n",
"die Funktion einfach nach $g$ auflösen und den Mittelwert und die Standardabweichung von $g$ berechnen kann. Bei Funktionen welche lediglich nur von einem Parameter abhängen geht das relative einfach aber wie sieht es im folgenden Beispiel aus:\n",
"Die Funktion $T(t, T_0, \\tau, t_0)$ soll die jährlichen Temperaturschwankungen an einem bestimmten Ort auf der Erde wiederspiegeln. Hierbei ist $T_0$ die Durchschnittstemperatur, $\\tau$ der Temperatur unterschied und $t0$ eine Verschiebung des Cosinus entsprechend des Tages an dem die maximale Temperatur innerhalb eines Jahres gemessen wurde. Gucken wir uns zunächst die Messdaten an: "
"Im vergleich zu vorher haben wir diesesmal mehre Parameter sprich para ist jetzt eine Liste von Werten und die Kovarianzmatrix pcov eine verschachtelte Liste:"
"Denkt daran, dass die Fehler euer Parameter der Wurzel der Hauptdiagonalen der Kovarianzmatrix entsprechen. Gucken wir uns doch nochmal die durch den Fit berechneten Werte etwas genauer an:"
"print(f'Das Chi-Quadrat beträgt {chi:.2f} mit {len(gemessene_temperatur) - 3} Freiheitsgraden.')\n",
"\n",
"\n",
"# Zusatzinfo: \n",
"# Ihr könnt das ganze auch wieder etwas kompakter als list comprehension schreiben.\n",
"# Außerdem könnt ihr die Fitparameter anstatt als para[0], para[1], para[2] mit Hilfe von\n",
"# *para an die Funktion geben. Der Stern ordnet die Werte in euerer Liste der Reihe nach den \n",
"# Argumenten euer Funktion zu:\n",
"# chi = sum([(temp(t, *para) - T)**2/dT**2 for t, T, dT in zip(tage, gemessene_temperatur, fehler_temperatur)])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie ihr seht scheinen die Fitparameter den Funktionsverlauf ganz gut zu beschreiben, gucken wir uns also mal das Resultat zusammen mit den Messwerten an."
"Hier noch ein kleiner Zusatz: Ist euch etwas aufgefallen? Der Fitparameter $T_0$ hat einen Wert von ca. 20 Tagen obwohl das Maximum eher bei 200 Tagen liegt. Dennoch beschreibt der Fit den Verlauf der Messdaten sehr gut. Dies liegt daran, das der Cosinus eine periodische Funktion ist. Bei der Methode der kleinsten Quadrate werden die Fitparameter so lange, nach einem gewissen Schema variiert, bis das Chi-Qudarat minimal ist. Bei einer periodischen Funktion gibt es mehre dieser Minima. \n",
"\n",
"Dies kann auch bei anderen komplexeren Funktionen der Fall sein. Da die meisten Funktionen jedoch nicht periodisch sind handelt es sich in der Regel bei diesen zusätzlichen Minima nur um lokale Minima. Um die besten Fitparameter zu finden wollen wir jedoch das globale Minimum finden. Um dies zu erreichen können wir curve_fit ein wenig helfen und zum Beispiel noch zusätzlich Startwerte für unsere Fitparameter mitgeben: "
"Wie ihr sehen könnt konnten wir mit Hilfe der Startwerte den Fit so beeinflussen, dass curve_fit dieses mal das \"richtige\" Minimum finden konnte. Daher empfehle ich euch bei komplexeren Problem sich immer erst die Messdaten an zugucken und ein paar Startwerte für den Fit zu raten/schätzen. "
