Markov-Ketten: Nonsens-Texte würfeln

Eine Markov-Kette schaut sich an, welche Zeichen in einem Text aufeinander folgen, und würfelt daraus neuen Text. Der Trick: Sie merkt sich die letzten paar Zeichen als Kontext — das ist der Grad — und wählt das nächste Zeichen passend dazu aus. Übergänge, die im Originaltext häufig vorkommen, werden auch häufiger gewürfelt.

Je größer der Grad, desto mehr Kontext behält die Kette — und desto echter klingt das Ergebnis. Bei Grad 0 kommt reiner Buchstabensalat heraus, bei Grad 3 oder 4 schon fast lesbares Deutsch.

Starte das Programm und sieh selbst, wie aus Zufall Sprache wird:

Pyodide laedt… Strg/⌘+Enter zum Ausführen

Nach dem Run erscheinen hier die Top-Level-Variablen.

import random
from collections import defaultdict, Counter

# Trainingstext: Anfang vom "Froschkönig" (Brüder Grimm)
KORPUS = (
    "In den alten Zeiten, wo das Wünschen noch geholfen hat, lebte ein König, "
    "dessen Töchter waren alle schön, aber die jüngste war so schön, dass die "
    "Sonne selber, die doch so vieles gesehen hat, sich verwunderte, sooft sie "
    "ihr ins Angesicht schien. Nahe bei dem Schlosse des Königs lag ein großer "
    "dunkler Wald, und in dem Walde unter einer alten Linde war ein Brunnen. "
    "Wenn nun der Tag recht heiß war, so ging das Königskind hinaus in den Wald "
    "und setzte sich an den Rand des kühlen Brunnens; und wenn sie Langeweile "
    "hatte, so nahm sie eine goldene Kugel, warf sie in die Höhe und fing sie "
    "wieder; und das war ihr liebstes Spielwerk. Nun trug es sich einmal zu, "
    "dass die goldene Kugel der Königstochter nicht in ihr Händchen fiel, "
    "sondern vorbei auf die Erde schlug und geradezu ins Wasser hineinrollte. "
    "Die Königstochter folgte ihr mit den Augen nach, aber die Kugel verschwand, "
    "und der Brunnen war tief, so tief, dass man keinen Grund sah."
)


def lerne_uebergaenge(text, grad):
    # Zähle, welches Zeichen nach je `grad` vorangehenden Zeichen folgt.
    uebergaenge = defaultdict(Counter)
    for i in range(len(text) - grad):
        kontext = text[i:i + grad]      # die letzten `grad` Zeichen
        naechstes = text[i + grad]      # das darauf folgende Zeichen
        uebergaenge[kontext][naechstes] += 1
    return uebergaenge


def erzeuge_text(uebergaenge, grad, laenge):
    # Würfle Zeichen für Zeichen neuen Text.
    text = random.choice(list(uebergaenge))     # mit zufälligem Kontext starten
    while len(text) < laenge:
        kontext = text[-grad:] if grad > 0 else ""
        folger = uebergaenge.get(kontext)
        if not folger:                          # Kontext unbekannt -> neu ansetzen
            text += random.choice(list(uebergaenge))
            continue
        # gewichtet würfeln: häufige Folgezeichen sind wahrscheinlicher
        naechstes = random.choices(list(folger), weights=list(folger.values()))[0]
        text += naechstes
    return text


# Probiere verschiedene Grade aus:
for grad in (0, 1, 2, 3, 4):
    uebergaenge = lerne_uebergaenge(KORPUS, grad)
    print("--- Grad", grad, "-" * 30)
    print(erzeuge_text(uebergaenge, grad, 180))
    print()

Zum Experimentieren:

Ändere die Grade in der Schleife ganz unten — zum Beispiel nur (2,), oder geh hoch bis (0, 1, 2, 3, 4, 6).
Tausch den KORPUS gegen einen eigenen Text: einen Liedtext, einen Wikipedia-Absatz, ein Gedicht. Je länger der Text, desto besser lernt die Kette.
Bei sehr hohem Grad gibt die Kette irgendwann den Originaltext fast wörtlich wieder. Warum wohl?

Diese Demo gehört zu Kapitel 2 von „Künstliche Intelligenz verstehen" (Noack/Sanner, Rheinwerk). Das Buch setzt die Idee in JavaScript und p5.js um — hier läuft dieselbe Idee in Python, dank Counter und random.choices sogar etwas kürzer.

Demo: Markov-Ketten — Nonsens-Texte würfeln

Markov-Ketten: Nonsens-Texte würfeln

Stichworte