Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

--- talit:tutorial_oop3 [2025-05-11 14:25] – [Score berechnen] hof
+++ talit:tutorial_oop3 [2025-05-26 14:11] (aktuell) – [Aufgabe F] hof
@@ Zeile 132: / Zeile 132: @@
 <html><bottom-editor>print(f'len() is of class {type(len)}')</bottom-editor></html>
 ### Vererbung
@@ Zeile 200: / Zeile 201: @@
   * `0` bedeutet, dass das Wort unbekannt ist oder immer falsch war.
   * `1` bedeutet, dass das Wort unendlich mal richtig getestet wurde.
-  * Der neueste Test soll mehr Gewicht haben als lange zurückliegende Tests.
+  * Der neueste Versuch soll mehr Gewicht haben als lange zurückliegende Versuche.
 Es bietet sich an, mit einem Decay zu arbeiten: jedes Mal, wenn ein neuer Wert dazukommt, wird der alte Score mit einem Faktor <1 multipliziert. Mit einem Faktor von 0.5 setzt sich der Score zur Hälfte aus dem neuesten Test, zur anderen Hälfte aus dem bisherigen Score zusammen:
 $$\begin{aligned} score_{new} &= 0.5 \cdot (test_0 + score_{old}) \\
   &= 0.5 \cdot (test_0 + 0.5 \cdot (test_1 + 0.5 \cdot (test_2 + \ldots))) \\
-  &= \frac{test_0}{2} + \frac{test_1}{4} + \frac{test_2}{8} + \frac{test_3}{16} + \ldots \end{aligned}$
+  &= \frac{test_0}{2} + \frac{test_1}{4} + \frac{test_2}{8} + \frac{test_3}{16} + \ldots \end{aligned}$$
-$
 #### Ausgabe
 Nach einem Learning Run möchten wir alle `WordPairs` mit ihren Statistiken ausgeben. Füge eine Methode `print_stats()` zu `VocabularyUnit` hinzu und verwende darin die `__str__` Funktion von `WordPair`.
@@ Zeile 224: / Zeile 226: @@
 % (32/46) Blume -> flower
 </code>
+## Refactoring
+Dein Code in `ConsoleLearner.learn()` könnte irgendwie so aussehen:
+<code python>
+   def learn(self, unit):
+        for pair in unit.pairs:
+            guess = input(f'Translate {pair.word1}')
+            correct = guess == pair.word2
+            pair.stats.record(correct)
+            if correct:
+                print('Yeah')
+            else:
+                print(f'Incorrect, {pair.word1} translates to {pair.word2}')
+</code>
+Wir möchten einige Teile dieses Verhaltens anpassen:
+### Auswahl eines Wortes
+Statt immer alle Paare durchzugehen, möchten wir andere Auswahl-Strategien ermöglichen:
+  * zufällige Wahl eines Wortpaars
+  * gewichtete Auswahl der Wortpaare: je schlechter der Score eines Paars, desto wahrscheinlicher dessen Wahl.
+Statt unseren Code oben mit all diesen Varianten vollzukleistern, lagern wir die Auswahl in ein eigenes Objekt aus:
+<code python>
+class LearningStrategy:
+    def select(self, unit):
+        pass  # has to be implemented by subclasses.
+</code>
+Hier ein Beispiel für das lineare Durchgehen der Paare, wie im ursprünglichen Code:
+<code python>
+class LinearStrategy(LearningStrategy):
+    """A learning strategy that selects all word pairs in a unit, in order."""
+    def __init__(self):
+        self.index = 0
+    def select(self, unit):
+        pair = unit.pairs[self.index % len(unit.pairs)]
+        self.index += 1
+        return pair
+</code>
+Wir passen `ConsoleLearner.learn()` so an, dass eine Strategie mitgeliefert werden kann, aber ein sinnvoller Default-Wert ausgewählt wird:
+<code python>
+   def learn(self, unit, learning_strategy=LinearStrategy()):
+        for _ in range(len(unit.pairs)):
+            pair = learning_strategy.select(unit)
+            guess = input(f'Translate {pair.word1}')
+            correct = guess == pair.word2
+            pair.stats.record(correct)
+            if correct:
+                print('Yeah')
+            else:
+                print(f'Incorrect, {pair.word1} translates to {pair.word2}')
+</code>
+### Aufgabe C: Bessere Auswahlstrategien
+Schreibe zwei Auswahl-Strategien mit folgenden Eigenschaften, und teste sie aus.
+  * `RandomStrategy`: zufällige Wahl eines Wortpaars
+  * `ScoreStrategy`: gewichtete Auswahl der Wortpaare: je schlechter der Score eines Paars, desto wahrscheinlicher dessen Wahl.
+    * s. [[https://docs.python.org/3/library/random.html#random.choices|random.choices()]]
+Du hast damit das [[wp>Strategy_pattern|Strategie-Entwurfsmuster]] kennengelernt.
+### Aufgabe D: Wie lange lernen?
+Ähnlich wie die Entscheidung über das nächste Wortpaar möchten wir auch die Entscheidung, wie lange gelernt werden soll, abstrahieren.
+Schreibe eine Klasse `StopCriterion`  mit einer Methode `should_stop(self, unit)`. Implementiere verschiedenen Kriterien als Unterklassen von `StopCriterion`, zum Beispiel:
+  * `ScoreCriterion`: stoppt, wenn der Score des schlechtesten WortPaars über 90% (oder einem konfigurierbaren Wert) liegt.
+  * `TimeCriterion`: stoppt, wenn eine definierte Zeit verstrichen ist.
+  * `CountingCriterion`: stoppt nach einer definierten Anzahl Wortpaare.
+  * `OrCriterion`: kombiniert mehrere Kriterien, stoppt, wenn mindestens eines der Kriterien stoppt.
+{{:talit:tutorial_oop3:pasted:20250513-173205.png?nolink&400}}
+Wie sieht die `ConsoleLearner.learn` Methode jetzt aus?
+## Speichern & Lesen
+Wir möchten `VocabularyUnits` in eine Datei speichern und von dort wieder lesen können. Es bietet sich an, eine Unit als JSON-Objekt zu speichern. JSON (JavaScript Object Notation) sind Dictionaries, die als Keys nur Strings, als Werte ausschliesslich Strings, Zahlen, Boolean-Werte, Listen und wiederum JSON-Objekte enthalten. Ein `WordPair` könnte zum Beispiel so aussehen:
+<code python>
+{"word1": "Baum", "word2": "tree", "correct": 26, "incorrect": 4, "score": 0.9999961480498314}
+</code>
+Eine ganze Unit wäre dann eine Liste solcher Objekte:
+<code python>
+[
+  {
+    "word1": "Baum",
+    "word2": "tree",
+    "correct": 24,
+    "incorrect": 4,
+    "score": 0.9249845921993256
+  },
+  {
+    "word1": "Blume",
+    "word2": "flower",
+    "correct": 30,
+    "incorrect": 14,
+    "score": 0.9999847523718017
+  }
+]
+</code>
+### Aufgabe E: JSON-Serialisierung
+  * Füge eine Methode `to_dict(self)` zu `WordPair` hinzu, die ein Wort-Paar und seine Stats in ein Dictionary verwandelt und zurückgibt.
+  * Füge eine Methode `save_to(self, filename)` zu `VocabularyUnit` hinzu, die die ganze Unit in die angegebene Datei speichert, in dem alle Wort-Paar-Dictionaries in eine Liste eingefügt werden. Diese kann dann mit [[https://docs.python.org/3/library/json.html#basic-usage|json.dump]] in eine Datei geschrieben werden:
+<code python>
+    def save_to(self, filename):
+        json_list = [pair.to_dict() for pair in self.pairs]
+        import json
+        with open(filename, 'w') as out:
+            json.dump(json_list, out, indent=2)  # indent=2 aligns the output nicely
+</code>
+### Statische Methoden
+Fürs Einlesen kommt die umgekehrte `json.load` Funktion zum Einsatz. Allerdings haben wir noch ein kleines Problem: Eine VocabularyUnit existiert ja noch gar nicht, wenn wir sie einlesen wollen aus der Datei. Wir benötigen also eine Funktion, die nicht an eine bestimmte Unit gebunden ist. Diese werden mit `@staticmethod` annotiert und haben keinen `self` Parameter. Statische Funktionen werden direkt über den Klassennamen aufgerufen.
+<code python>
+class WordPair:
+    ...
+    @staticmethod
+    def from_dict(data):
+        """Creates a fresh word pair from json data."""
+        pair = WordPair(data['word1'], data['word2'])
+        # TODO also read stats if available
+class VocabularyUnit:
+    ...
+    @staticmethod
+    def read_from(filename):
+        """Reads a vocabulary unit from a file."""
+        import json
+        pairs = []
+        with open(filename, 'r') as infile:
+            json_pairs = json.load(infile)
+            pairs = [WordPair.from_dict(p) for p in json_pairs]
+            return VocabularyUnit(pairs)
+</code>
+### Aufgabe F
+Füge statische Methoden zu `VocabularyUnit` und `WordPair` hinzu, um die gespeicherten Daten wieder einlesen zu können.
+Ein Beispielprogramm für unseren Code könnte nun so aussehen:
+<code python>
+from voci import *
+filename = 'data/test.voci'
+unit = VocabularyUnit.read_from(filename)
+learner = ConsoleLearner()
+try:
+    learner.learn(unit)
+    unit.print_stats()
+finally:   # Code im finally-Block wird jedenfalls ausgeführt, auch wenn eine Exception passiert ist.
+    unit.save_to(filename)
+</code>
+### Aufgabe G - Webapp
+S. auch [[talit:flask_webserver]] und [[ef_informatik:webapps:start]].