Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

--- faecher:informatik:oberstufe:machine_learning:mljs:markow:start [19.02.2025 18:19] – [Die wichtigsten Bestandteile:] Frank Schiebel
+++ faecher:informatik:oberstufe:machine_learning:mljs:markow:start [19.02.2025 20:52] (aktuell) – [Die wichtigsten Bestandteile:] Frank Schiebel
@@ Zeile 1: / Zeile 1: @@
 {{:faecher:informatik:oberstufe:machine_learning:mljs:markow:256px-aamarkov.jpg?140 |}}((https://commons.wikimedia.org/wiki/File:AAMarkov.jpg))
 ====== Texterzeugung mit Herrn Markow ======
@@ Zeile 107: / Zeile 105: @@
 Teste weitere Grade beim Lernen des Textes.
-Die Methoden ''lerneText(textQuelle, grad)'' und ''lerneUebergang(letzteZeichen, naechstesZeichen)'':
+----
+{{:faecher:informatik:oberstufe:machine_learning:mljs:markow:puzzle.png |}}Die Methoden ''lerneText(String textQuelle, int grad)'' und ''lerneUebergang(String letzteZeichen, char naechstesZeichen)'':
+<code java>
+/**
+ *   Lerne Text
+ */
+public void lerneText(String text, int grad) {
+    this.grad = grad;
+    uebergaenge.clear();
+    for (int i = 0; i < text.length() - grad; i++) {
+        // Hier wird das "Zustandsfenster" der Länge grad
+        // über den Text "geschoben"
+        String zustand = text.substring(i, i + grad);
+        // Das ist das Zeichen, das auf den aktuellen Zustand folgt
+        char naechstesZeichen = text.charAt(i + grad);
+        // Lerne den gefundenen Übergang
+        lerneUebergang(zustand, naechstesZeichen);
+    }
+}
+/**
+ * Hier wird ein gefundener Übergang überprüft und
+ * passend in der HashMap eingetragen
+ */
+public void lerneUebergang(String zustand, char naechstesZeichen) {
+    // Versuche die Übergangs-Map für den aktuellen Zustand zu lesen
+    Map<Character, Integer> folgeZeichenMap = uebergaenge.get(zustand);
+    // Wenn es für den Zustand noch keine Einträge gibt...
+    if(folgeZeichenMap == null) {
+       // Zuerst eine neue Map für die Folgezeichen anlegen. Die ist erst mal leer...
+       uebergaenge.put(zustand, new HashMap<>());
+    }
+    // Jetzt gibt es für den Zustand auf alle Fälle ein Map mit den Folgezeichen
+    // Nun muss man entscheiden, ob das aktuelle Folgezeichen neu da rein muss
+    // oder ob nur seine Anzahl erhöht werden muss.
+    folgeZeichenMap = uebergaenge.get(zustand);
+    Integer anzahl = folgeZeichenMap.get(naechstesZeichen);
+    if(anzahl == null || anzahl == 0) {
+        folgeZeichenMap.put(naechstesZeichen, 1);
+    } else {
+        folgeZeichenMap.put(naechstesZeichen, anzahl + 1);
+    }
+    uebergaenge.put(zustand, folgeZeichenMap);
+}
+</code>
+----
+{{:aufgabe.png?nolink  |}}
+=== (A3) ===
+Vollziehe am Wort ''kakaopulver'' mit dem Grad 2 nach, was die beiden Methoden machen. Welche Übergänge sind am Ende des Lernprozesses in der HashMap ''uebergaenge'' abgelegt?
+Du kannst das mit dem Markow-Texter überprüfen, indem du den Text ''kakaopulver'' in die Datei ''experiment.txt'' einträgst und das Programm lernen lässt.
+++++ Hilfestellung: Schritt 1 |
+{{ :faecher:informatik:oberstufe:machine_learning:mljs:markow:lernen01.png |}}
+++++
+++++ Hilfestellung: Schritt 2 |
+{{ :faecher:informatik:oberstufe:machine_learning:mljs:markow:lernen02.png |}}
+++++
+++++ Hilfestellung: Schritt 3 |
+{{ :faecher:informatik:oberstufe:machine_learning:mljs:markow:lernen03.png |}}
+++++
+++++ Hilfestellung: Ergebnis |
+{{ :faecher:informatik:oberstufe:machine_learning:mljs:markow:lernen_fertig.png |}}
+++++
+----
+{{:faecher:informatik:oberstufe:machine_learning:mljs:markow:puzzle.png |}}Die Methoden ''erzeugeText(String anfang, int laenge)'' und ''zufaelligerUebergang(String aktuellerZustand)'':
+<code java>
+/**
+*   Erzeuge Text
+*/
+public String erzeugeText(String anfang, int laenge) {
+  String aktuellerZustand = anfang;
+  StringBuilder resultat = new StringBuilder(anfang);
+  for (int i = 0; i < laenge; i++) {
+      char naechstesZeichen = zufaelligerUebergang(aktuellerZustand);
+      aktuellerZustand = aktuellerZustand.substring(1) + naechstesZeichen;
+      resultat.append(naechstesZeichen);
+  }
+  return resultat.toString().replaceAll("N","\n");
+}
+/**
+* Wählt ein zufälliges Folgezeichen. Die Häufigkeit der Zeichen wird
+* nicht berücksichtigt.
+*/
+char zufaelligerUebergang(String aktuellerZustand) {
+  Map<Character, Integer> folgeZeichen = uebergaenge.get(aktuellerZustand);
+  if(folgeZeichen != null) {
+      // Zufalsgenerator initialisieren
+      Random generator = new Random();
+      // Die Keys der HashMap in ein Array umwandeln. Diese Methode
+      // funktioniert nur, wenn alleZeichen eine Array vom Typ
+      // Object ist.
+      Object[] alleZeichen = folgeZeichen.keySet().toArray();
+      // mit generator.nextInt(alleZeichen.length) wird eine Zufallszahl erzeugt
+      // die über den Index ein zufälliges Element auswählt.
+      // Bevor das Element zurückgegen werden kann, muss es nach char
+      // gecastet werden.
+      return (char) alleZeichen[generator.nextInt(alleZeichen.length)];
+  } else {
+      return ' ';
+  }
+}
+</code>
+----
+{{:aufgabe.png?nolink  |}}
+=== (A4) ===
+Vollziehe nach wie das Erzeugen von Texten abläuft.
+  * Erstelle eine Methode ''public char gewichteterUebergang(String aktuellerZustand)'', der bei der Auswahl des nächsten Zeichens die Häufigkeiten der Zeichen berücksichtigt
+  * Für Fortgeschrittene: Dupliziere den Markow-Texter in ein neues BlueJ-Projekt und passe dieses so an, dass er Wörter lernt anstatt Zeichen, so dass das jeweils nächste Wort anhand der vorhergehenden Worte bestimmt wird.