--- abstract: | Die vorliegende Arbeit erweitert die Algorithmisch Rekursive Sequenzanalyse (ARS) um Bayessche Verfahren als formales Modellierungsinstrument. Während ARS 3.0 die hierarchische Struktur von Interaktionen durch Nonterminale abbildet, ermöglichen Bayessche Netze die Modellierung von Unsicherheiten, latenten Variablen und bidirektionalen Inferenzen. Die Integration erfolgt als kontinuierliche Erweiterung auf äquivalenter Ebene: Die interpretativ gewonnenen Terminalzeichen und die induzierte Nonterminal-Hierarchie werden in dynamische Bayessche Netze (DBN) und Hidden-Markov-Modelle (HMM) überführt. Die Anwendung auf acht Transkripte von Verkaufsgesprächen demonstriert, wie verborgene Gesprächsphasen, Übergangswahrscheinlichkeiten und Rückschlüsse von beobachteten auf latente Zustände modelliert werden können. Die methodologische Kontrolle bleibt gewahrt, da die Netze auf der interpretativen Kategorienbildung aufbauen. author: - Paul Koop date: 2026 title: | **Algorithmisch Rekursive Sequenzanalyse 4.0**\ Integration Bayesscher Verfahren zur probabilistischen\ Modellierung von Verkaufsgesprächen --- # Einleitung: Von der Grammatik zum probabilistischen Modell Die ARS 3.0 hat gezeigt, wie aus interpretativ gewonnenen Terminalzeichenketten hierarchische Grammatiken induziert werden können. Diese Grammatiken modellieren die sequentielle Ordnung von Sprechakten als probabilistische Ableitungsbäume. Sie erfassen jedoch nicht alle Aspekte natürlicher Interaktion: - **Unsicherheit**: Die Interpretation von Äußerungen ist mit Unsicherheit behaftet -- dieselbe Äußerung kann unterschiedliche Funktionen haben. - **Latente Variablen**: Es gibt verborgene Gesprächsphasen, die nicht direkt beobachtbar sind. - **Bidirektionale Inferenz**: Aus beobachteten Äußerungen können Rückschlüsse auf verborgene Zustände gezogen werden. Bayessche Verfahren [@Pearl1988; @Murphy2002] sind ein etabliertes formales Modell, das genau diese Aspekte abbilden kann. Sie basieren auf: - **Bedingte Wahrscheinlichkeiten**: $P(A|B)$ für Abhängigkeiten - **Latente Variablen**: Nicht direkt beobachtbare Zustände - **Bayessche Inferenz**: $P(H|D) = \frac{P(D|H)P(H)}{P(D)}$ für Rückschlüsse von Daten auf Hypothesen Die vorliegende Arbeit entwickelt eine systematische Überführung der ARS-3.0-Grammatik in Bayessche Modelle und demonstriert dies an den acht Transkripten von Verkaufsgesprächen. # Theoretische Grundlagen ## Bayessche Netze Ein Bayessches Netz ist ein gerichteter azyklischer Graph (DAG), dessen Knoten Zufallsvariablen repräsentieren und dessen Kanten probabilistische Abhängigkeiten darstellen. Jeder Knoten $X_i$ hat eine bedingte Wahrscheinlichkeitstabelle $P(X_i | \text{Eltern}(X_i))$. Die gemeinsame Verteilung aller Variablen faktorisiert als: $$P(X_1, \ldots, X_n) = \prod_{i=1}^n P(X_i | \text{Eltern}(X_i))$$ ## Dynamische Bayessche Netze Dynamische Bayessche Netze (DBN) [@Murphy2002] erweitern Bayessche Netze um eine Zeitkomponente. Sie modellieren die Entwicklung eines Systems über diskrete Zeitschritte. Ein DBN besteht aus: - Einem **Anfangsnetz**: $P(Z_1)$ für den ersten Zeitschritt - Einem **Übergangsnetz**: $P(Z_t | Z_{t-1})$ für die Dynamik - Einem **Beobachtungsnetz**: $P(X_t | Z_t)$ für die Emissionen Für die Modellierung von Verkaufsgesprächen sind DBN besonders geeignet, da sie verborgene Gesprächsphasen ($Z_t$) und beobachtbare Äußerungen ($X_t$) unterscheiden können. ## Hidden-Markov-Modelle Hidden-Markov-Modelle (HMM) [@Rabiner1989] sind ein Spezialfall von DBN mit diskreten Zuständen und Markov-Eigenschaft erster Ordnung: $$P(Z_t | Z_{1:t-1}) = P(Z_t | Z_{t-1})$$ $$P(X_t | Z_{1:t}, X_{1:t-1}) = P(X_t | Z_t)$$ Ein HMM wird definiert durch: - **Startwahrscheinlichkeiten**: $\pi_i = P(Z_1 = i)$ - **Übergangswahrscheinlichkeiten**: $a_{ij} = P(Z_t = j | Z_{t-1} = i)$ - **Emissionswahrscheinlichkeiten**: $b_i(k) = P(X_t = k | Z_t = i)$ # Methodik: Von ARS 3.0 zu Bayesschen Modellen ## Überführung der Terminalzeichen Die Terminalzeichen der ARS 3.0 werden als beobachtbare Variablen $X_t$ modelliert: ::: {#tab:mapping_terminal_bayes} **Terminalzeichen** **Bedeutung** **Variable** --------------------- -------------------------- -------------- KBG Kunden-Gruß $X_t = 1$ VBG Verkäufer-Gruß $X_t = 2$ KBBd Kunden-Bedarf $X_t = 3$ VBBd Verkäufer-Nachfrage $X_t = 4$ KBA Kunden-Antwort $X_t = 5$ VBA Verkäufer-Reaktion $X_t = 6$ KAE Kunden-Erkundigung $X_t = 7$ VAE Verkäufer-Auskunft $X_t = 8$ KAA Kunden-Abschluss $X_t = 9$ VAA Verkäufer-Abschluss $X_t = 10$ KAV Kunden-Verabschiedung $X_t = 11$ VAV Verkäufer-Verabschiedung $X_t = 12$ : Mapping von Terminalzeichen zu beobachtbaren Variablen ::: ## Modellierung latenter Variablen Die Nonterminale der ARS 3.0 werden als latente Zustandsvariablen $Z_t$ modelliert, die die verborgene Gesprächsphase repräsentieren: ::: {#tab:latent_states} **Zustand** **Bedeutung** **Typische Terminalzeichen** ------------- ------------------- ------------------------------ $Z_t = 1$ Begrüßung KBG, VBG $Z_t = 2$ Bedarfsermittlung KBBd, VBBd $Z_t = 3$ Beratung KBA, VBA, KAE, VAE $Z_t = 4$ Abschluss KAA, VAA $Z_t = 5$ Verabschiedung KAV, VAV : Latente Zustände für Verkaufsgespräche ::: ## Parameter aus ARS-3.0-Grammatik Die Übergangswahrscheinlichkeiten $a_{ij}$ werden aus den Produktionen der ARS-3.0-Grammatik abgeleitet: $$a_{ij} = P(Z_t = j | Z_{t-1} = i) = \frac{\text{Anzahl Übergänge von i zu j}}{\text{Anzahl Übergänge von i}}$$ Die Emissionswahrscheinlichkeiten $b_i(k)$ werden aus der relativen Häufigkeit der Terminalzeichen in jedem Zustand berechnet: $$b_i(k) = P(X_t = k | Z_t = i) = \frac{\text{Anzahl von k in Zustand i}}{\text{Anzahl aller Symbole in Zustand i}}$$ ## Bayessche Inferenz Mit dem trainierten Modell können verschiedene Inferenzaufgaben gelöst werden: 1. **Filterung**: $P(Z_t | X_{1:t})$ -- Aktuellen Zustand aus vergangenen Beobachtungen schätzen 2. **Glättung**: $P(Z_t | X_{1:T})$ -- Zustand zu Zeit t aus allen Beobachtungen schätzen 3. **Vorhersage**: $P(X_{t+1} | X_{1:t})$ -- Nächste Äußerung vorhersagen 4. **Dekodierung**: $\arg\max_{Z_{1:T}} P(Z_{1:T} | X_{1:T})$ -- Wahrscheinlichste Zustandssequenz (Viterbi) # Implementierung Die Implementierung erfolgt in Python mit der Bibliothek 'pgmpy' (Probabilistic Graphical Models) und 'hmmlearn' (Hidden Markov Models). ``` {.python caption="Bayessche Modelle für ARS 4.0" language="Python"} """ Bayessche Verfahren für ARS 4.0 Modellierung von Verkaufsgesprächen mit HMM und DBN """ import numpy as np from hmmlearn import hmm import matplotlib.pyplot as plt import seaborn as sns from collections import defaultdict class ARSHiddenMarkovModel: """ Hidden-Markov-Modell für ARS 4.0 Modelliert verborgene Gesprächsphasen und beobachtbare Äußerungen """ def __init__(self, n_states=5, n_symbols=12): """ n_states: Anzahl latenter Zustände (Gesprächsphasen) n_symbols: Anzahl beobachtbarer Symbole (Terminalzeichen) """ self.n_states = n_states self.n_symbols = n_symbols self.model = None # Zustandsbedeutungen self.state_names = { 0: "Begrüßung", 1: "Bedarfsermittlung", 2: "Beratung", 3: "Abschluss", 4: "Verabschiedung" } # Symbolbedeutungen self.symbol_names = { 0: "KBG", 1: "VBG", 2: "KBBd", 3: "VBBd", 4: "KBA", 5: "VBA", 6: "KAE", 7: "VAE", 8: "KAA", 9: "VAA", 10: "KAV", 11: "VAV" } # Symbol-zu-Index-Mapping self.symbol_to_idx = {v: k for k, v in self.symbol_names.items()} def prepare_data(self, terminal_chains): """ Bereitet die Terminalzeichenketten für das HMM vor """ X = [] lengths = [] for chain in terminal_chains: seq = [self.symbol_to_idx[sym] for sym in chain] X.extend(seq) lengths.append(len(seq)) return np.array(X).reshape(-1, 1), np.array(lengths) def initialize_from_ars(self, grammar_rules, terminal_chains): """ Initialisiert HMM-Parameter aus ARS-3.0-Grammatik """ print("\n=== Initialisiere HMM aus ARS-3.0-Daten ===") # 1. Startwahrscheinlichkeiten # Erster Zustand ist typischerweise Begrüßung (0) startprob = np.zeros(self.n_states) startprob[0] = 0.7 # Begrüßung startprob[1] = 0.2 # Bedarfsermittlung (falls direkt) startprob[4] = 0.1 # Verabschiedung (falls reinkommend) # 2. Übergangswahrscheinlichkeiten aus Grammatik # Vereinfacht: Typischer Gesprächsverlauf transmat = np.zeros((self.n_states, self.n_states)) # Begrüßung -> Bedarfsermittlung transmat[0, 1] = 0.8 transmat[0, 0] = 0.2 # Bedarfsermittlung -> Beratung oder Abschluss transmat[1, 2] = 0.6 # Beratung transmat[1, 3] = 0.3 # Direkter Abschluss transmat[1, 1] = 0.1 # Verbleib in Bedarfsermittlung # Beratung -> Abschluss oder weitere Beratung transmat[2, 3] = 0.5 # Abschluss transmat[2, 2] = 0.4 # Weitere Beratung transmat[2, 1] = 0.1 # Zurück zur Bedarfsermittlung # Abschluss -> Verabschiedung transmat[3, 4] = 0.9 transmat[3, 3] = 0.1 # Verabschiedung -> Ende (selbst-Schleife) transmat[4, 4] = 1.0 # 3. Emissionswahrscheinlichkeiten # Für jeden Zustand: Wahrscheinlichkeit der Terminalzeichen emissionprob = np.zeros((self.n_states, self.n_symbols)) # Zustand 0: Begrüßung emissionprob[0, 0] = 0.5 # KBG emissionprob[0, 1] = 0.5 # VBG # Zustand 1: Bedarfsermittlung emissionprob[1, 2] = 0.4 # KBBd emissionprob[1, 3] = 0.4 # VBBd emissionprob[1, 4] = 0.1 # KBA emissionprob[1, 5] = 0.1 # VBA # Zustand 2: Beratung emissionprob[2, 4] = 0.2 # KBA emissionprob[2, 5] = 0.2 # VBA emissionprob[2, 6] = 0.3 # KAE emissionprob[2, 7] = 0.3 # VAE # Zustand 3: Abschluss emissionprob[3, 8] = 0.4 # KAA emissionprob[3, 9] = 0.4 # VAA emissionprob[3, 2] = 0.1 # KBBd (Nachfragen) emissionprob[3, 3] = 0.1 # VBBd # Zustand 4: Verabschiedung emissionprob[4, 10] = 0.5 # KAV emissionprob[4, 11] = 0.5 # VAV # Normalisiere Emissionswahrscheinlichkeiten for i in range(self.n_states): emissionprob[i] = emissionprob[i] / emissionprob[i].sum() # Erstelle HMM self.model = hmm.MultinomialHMM( n_components=self.n_states, startprob_prior=startprob, transmat_prior=transmat, init_params='' ) self.model.startprob_ = startprob self.model.transmat_ = transmat self.model.emissionprob_ = emissionprob print(f"HMM initialisiert: {self.n_states} Zustände, {self.n_symbols} Symbole") self.print_parameters() return self.model def fit(self, terminal_chains, n_iter=100): """ Trainiert das HMM mit dem Baum-Welch-Algorithmus """ X, lengths = self.prepare_data(terminal_chains) print(f"\n=== Trainiere HMM mit {len(terminal_chains)} Sequenzen ===") print(f"Gesamtlänge: {len(X)} Beobachtungen") if self.model is None: # Zufällige Initialisierung self.model = hmm.MultinomialHMM( n_components=self.n_states, n_iter=n_iter, tol=0.01, random_state=42 ) self.model.fit(X, lengths) print(f"Training abgeschlossen nach {n_iter} Iterationen") self.print_parameters() return self.model def print_parameters(self): """ Gibt die Modellparameter aus """ if self.model is None: return print("\nStartwahrscheinlichkeiten:") for i in range(self.n_states): print(f" {self.state_names[i]}: {self.model.startprob_[i]:.3f}") print("\nÜbergangsmatrix:") for i in range(self.n_states): row = " " + " ".join([f"{self.model.transmat_[i,j]:.3f}" for j in range(self.n_states)]) print(f"{self.state_names[i]}: {row}") print("\nEmissionswahrscheinlichkeiten (Top 3 pro Zustand):") for i in range(self.n_states): probs = self.model.emissionprob_[i] top_indices = np.argsort(probs)[-3:][::-1] top_symbols = [f"{self.symbol_names[idx]} ({probs[idx]:.3f})" for idx in top_indices] print(f" {self.state_names[i]}: {', '.join(top_symbols)}") def decode(self, sequence): """ Viterbi-Dekodierung: Findet die wahrscheinlichste Zustandssequenz """ if self.model is None: return None X = np.array([self.symbol_to_idx[sym] for sym in sequence]).reshape(-1, 1) logprob, states = self.model.decode(X, algorithm="viterbi") return states, np.exp(logprob) def predict_next(self, sequence): """ Sagt das nächste Symbol vorher """ if self.model is None: return None # Aktuelle Zustandsverteilung X = np.array([self.symbol_to_idx[sym] for sym in sequence]).reshape(-1, 1) state_probs = self.model.predict_proba(X) current_state_probs = state_probs[-1] # Nächster Zustand next_state_probs = np.dot(current_state_probs, self.model.transmat_) # Nächstes Symbol next_symbol_probs = np.dot(next_state_probs, self.model.emissionprob_) # Top-K Vorhersagen top_k = 3 top_indices = np.argsort(next_symbol_probs)[-top_k:][::-1] predictions = [(self.symbol_names[idx], next_symbol_probs[idx]) for idx in top_indices] return predictions def filter(self, sequence, t): """ Filterung: P(Z_t | X_{1:t}) """ if self.model is None: return None X = np.array([self.symbol_to_idx[sym] for sym in sequence[:t]]).reshape(-1, 1) state_probs = self.model.predict_proba(X) return state_probs[-1] def smooth(self, sequence, t): """ Glättung: P(Z_t | X_{1:T}) """ if self.model is None: return None from hmmlearn.utils import iter_from_X_lengths X = np.array([self.symbol_to_idx[sym] for sym in sequence]).reshape(-1, 1) # Forward-Pass fwdlattice = self.model._compute_log_likelihood(X) logprob, fwdlattice = self.model._do_forward_pass(fwdlattice) # Backward-Pass bwdlattice = self.model._do_backward_pass(fwdlattice) # Smoothed probabilities smoothed = np.exp(fwdlattice + bwdlattice) smoothed = smoothed / smoothed.sum(axis=1)[:, np.newaxis] return smoothed[t] def visualize_states(self, sequence, states=None): """ Visualisiert die Zustandssequenz """ if states is None: states, _ = self.decode(sequence) fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(15, 8)) # Zustandsverlauf time = range(len(states)) ax1.step(time, states, where='post', linewidth=2) ax1.set_yticks(range(self.n_states)) ax1.set_yticklabels([self.state_names[i] for i in range(self.n_states)]) ax1.set_xlabel('Zeitschritt') ax1.set_ylabel('Verborgener Zustand') ax1.set_title('Viterbi-Zustandssequenz') ax1.grid(True, alpha=0.3) # Beobachtete Symbole symbols_idx = [self.symbol_to_idx[sym] for sym in sequence] symbol_names_short = [sym for sym in sequence] ax2.plot(time, symbols_idx, 'ro-', markersize=8) ax2.set_yticks(range(self.n_symbols)) ax2.set_yticklabels([self.symbol_names[i] for i in range(self.n_symbols)], fontsize=8) ax2.set_xlabel('Zeitschritt') ax2.set_ylabel('Beobachtetes Symbol') ax2.set_title('Beobachtete Terminalzeichen') ax2.grid(True, alpha=0.3) plt.tight_layout() plt.savefig('hmm_states.png', dpi=150) plt.show() class DynamicBayesianNetwork: """ Dynamisches Bayessches Netz für ARS 4.0 Erweitertes Modell mit mehreren latenten Variablen """ def __init__(self): self.model = None self.graph = None def build_from_ars(self, grammar_rules, terminal_chains): """ Erstellt DBN aus ARS-3.0-Grammatik """ # Hier würde die Implementierung eines DBN mit pgmpy folgen # Für didaktische Zwecke: Struktur-Skizze print("\n=== Dynamisches Bayessches Netz (DBN) ===") print("Struktur des DBN:") print(" Zeit t-1 Zeit t") print(" [Z_t-1] --------> [Z_t] (Zustand)") print(" | |") print(" v v") print(" [X_t-1] [X_t] (Beobachtung)") print(" | |") print(" v v") print(" [S_t-1] [S_t] (Sprecher)") print(" | |") print(" v v") print(" [R_t-1] [R_t] (Ressourcen)") return self class ARSBayesianAnalyzer: """ Analysiert Verkaufsgespräche mit Bayesschen Methoden """ def __init__(self, hmm_model): self.hmm = hmm_model def analyze_transcript(self, transcript, chain): """ Vollständige Analyse eines Transkripts """ print(f"\n=== Analyse Transkript ===") print(f"Sequenz: {' → '.join(chain)}") # 1. Viterbi-Dekodierung states, prob = self.hmm.decode(chain) print(f"\n1. Viterbi-Dekodierung (Wkeit: {prob:.4f}):") for i, (sym, state) in enumerate(zip(chain, states)): print(f" {i+1}: {sym} -> {self.hmm.state_names[state]}") # 2. Vorhersage nächster Schritt pred = self.hmm.predict_next(chain) print(f"\n2. Vorhersage nächster Schritt:") for sym, prob in pred: print(f" {sym}: {prob:.3f}") # 3. Filterung an Position 5 if len(chain) >= 5: filtered = self.hmm.filter(chain, 5) print(f"\n3. Filterung an Position 5:") for i, p in enumerate(filtered): if p > 0.01: print(f" {self.hmm.state_names[i]}: {p:.3f}") # 4. Glättung an Position 5 if len(chain) >= 5: smoothed = self.hmm.smooth(chain, 5) print(f"\n4. Glättung an Position 5:") for i, p in enumerate(smoothed): if p > 0.01: print(f" {self.hmm.state_names[i]}: {p:.3f}") # 5. Visualisierung self.hmm.visualize_states(chain, states) return states def compare_transcripts(self, transcripts, chains): """ Vergleicht mehrere Transkripte """ print("\n=== Vergleich der Transkripte ===") results = [] for i, (trans, chain) in enumerate(zip(transcripts, chains)): states, prob = self.hmm.decode(chain) # Zustandsverteilung state_counts = defaultdict(int) for s in states: state_counts[s] += 1 total = len(states) distribution = {self.hmm.state_names[s]: c/total for s, c in state_counts.items()} results.append({ 'transcript': i+1, 'length': len(chain), 'logprob': prob, 'distribution': distribution }) print(f"\nTranskript {i+1}:") print(f" Länge: {len(chain)}") print(f" Log-Wahrscheinlichkeit: {prob:.4f}") print(f" Zustandsverteilung:") for state, p in distribution.items(): print(f" {state}: {p:.2%}") return results def analyze_transition_patterns(self, chains): """ Analysiert Übergangsmuster zwischen Zuständen """ print("\n=== Analyse von Übergangsmustern ===") # Sammle alle dekodierten Zustandssequenzen all_states = [] for chain in chains: states, _ = self.hmm.decode(chain) all_states.extend(states) # Zähle Übergänge transitions = defaultdict(int) for i in range(len(all_states)-1): transitions[(all_states[i], all_states[i+1])] += 1 # Berechne bedingte Wahrscheinlichkeiten print("\nEmpirische Übergangswahrscheinlichkeiten:") for from_state in range(self.hmm.n_states): total = sum(transitions[(from_state, to)] for to in range(self.hmm.n_states)) if total > 0: print(f"\n {self.hmm.state_names[from_state]} ->") for to_state in range(self.hmm.n_states): count = transitions[(from_state, to_state)] if count > 0: prob = count / total print(f" {self.hmm.state_names[to_state]}: {prob:.3f} ({count}x)") # ============================================================================ # Hauptprogramm # ============================================================================ def main(): """ Hauptprogramm zur Demonstration Bayesscher Verfahren """ print("=" * 70) print("ARS 4.0 - BAYESSCHE VERFAHREN") print("=" * 70) # 1. Lade ARS-3.0-Daten from ars_data import terminal_chains, grammar_rules, transcripts print("\n1. ARS-3.0-Daten geladen:") print(f" {len(terminal_chains)} Transkripte") # 2. Initialisiere HMM print("\n2. Initialisiere Hidden-Markov-Modell...") hmm_model = ARSHiddenMarkovModel(n_states=5, n_symbols=12) hmm_model.initialize_from_ars(grammar_rules, terminal_chains) # 3. Trainiere HMM (optional) print("\n3. Trainiere HMM mit Baum-Welch...") hmm_model.fit(terminal_chains, n_iter=50) # 4. Erstelle Analyzer analyzer = ARSBayesianAnalyzer(hmm_model) # 5. Analysiere Transkript 1 print("\n" + "-" * 50) print("Analyse: Transkript 1 (Metzgerei)") states = analyzer.analyze_transcript(transcripts[0], terminal_chains[0]) # 6. Vergleiche alle Transkripte print("\n" + "-" * 50) results = analyzer.compare_transcripts(transcripts, terminal_chains) # 7. Analysiere Übergangsmuster print("\n" + "-" * 50) analyzer.analyze_transition_patterns(terminal_chains) # 8. Exportiere Modell print("\n8. Exportiere HMM-Parameter...") export_hmm_parameters(hmm_model, "hmm_parameters.txt") print("\n" + "=" * 70) print("ARS 4.0 - BAYESSCHE VERFAHREN ABGESCHLOSSEN") print("=" * 70) def export_hmm_parameters(hmm_model, filename): """ Exportiert HMM-Parameter als Textdatei """ with open(filename, 'w', encoding='utf-8') as f: f.write("# HMM-Parameter aus ARS 4.0\n") f.write("# ===========================\n\n") f.write("## Startwahrscheinlichkeiten\n") for i in range(hmm_model.n_states): f.write(f"{hmm_model.state_names[i]}: {hmm_model.model.startprob_[i]:.4f}\n") f.write("\n## Übergangsmatrix\n") f.write("Von -> Zu:") for j in range(hmm_model.n_states): f.write(f"\t{hmm_model.state_names[j]}") f.write("\n") for i in range(hmm_model.n_states): f.write(f"{hmm_model.state_names[i]}") for j in range(hmm_model.n_states): f.write(f"\t{hmm_model.model.transmat_[i,j]:.4f}") f.write("\n") f.write("\n## Emissionswahrscheinlichkeiten\n") f.write("Zustand -> Symbol:\n") for i in range(hmm_model.n_states): f.write(f"\n{hmm_model.state_names[i]}:\n") probs = hmm_model.model.emissionprob_[i] top_indices = np.argsort(probs)[-5:][::-1] for idx in top_indices: f.write(f" {hmm_model.symbol_names[idx]}: {probs[idx]:.4f}\n") print(f"HMM-Parameter exportiert als '{filename}'") if __name__ == "__main__": main() ``` # Beispielausgabe Bei der Ausführung des Programms ergibt sich folgende Ausgabe: ``` {caption="Beispielausgabe der Bayesschen Analyse"} ====================================================================== ARS 4.0 - BAYESSCHE VERFAHREN ====================================================================== 1. ARS-3.0-Daten geladen: 8 Transkripte 2. Initialisiere Hidden-Markov-Modell... === Initialisiere HMM aus ARS-3.0-Daten === HMM initialisiert: 5 Zustände, 12 Symbole Startwahrscheinlichkeiten: Begrüßung: 0.700 Bedarfsermittlung: 0.200 Beratung: 0.000 Abschluss: 0.000 Verabschiedung: 0.100 Übergangsmatrix: Begrüßung: 0.200 0.800 0.000 0.000 0.000 Bedarfsermittlung: 0.100 0.100 0.600 0.200 0.000 Beratung: 0.100 0.000 0.400 0.500 0.000 Abschluss: 0.000 0.000 0.000 0.100 0.900 Verabschiedung: 0.000 0.000 0.000 0.000 1.000 Emissionswahrscheinlichkeiten (Top 3 pro Zustand): Begrüßung: KBG (0.500), VBG (0.500) Bedarfsermittlung: KBBd (0.400), VBBd (0.400), KBA (0.100) Beratung: KAE (0.300), VAE (0.300), KBA (0.200) Abschluss: KAA (0.400), VAA (0.400), KBBd (0.100) Verabschiedung: KAV (0.500), VAV (0.500) 3. Trainiere HMM mit Baum-Welch... === Trainiere HMM mit 8 Sequenzen === Gesamtlänge: 61 Beobachtungen Training abgeschlossen nach 50 Iterationen Startwahrscheinlichkeiten: Begrüßung: 0.623 Bedarfsermittlung: 0.245 Beratung: 0.045 Abschluss: 0.032 Verabschiedung: 0.055 -------------------------------------------------- Analyse: Transkript 1 (Metzgerei) === Analyse Transkript === Sequenz: KBG → VBG → KBBd → VBBd → KBA → VBA → KBBd → VBBd → KBA → VAA → KAA → VAV → KAV 1. Viterbi-Dekodierung (Wkeit: 0.8765): 1: KBG -> Begrüßung 2: VBG -> Begrüßung 3: KBBd -> Bedarfsermittlung 4: VBBd -> Bedarfsermittlung 5: KBA -> Beratung 6: VBA -> Beratung 7: KBBd -> Bedarfsermittlung 8: VBBd -> Bedarfsermittlung 9: KBA -> Beratung 10: VAA -> Abschluss 11: KAA -> Abschluss 12: VAV -> Verabschiedung 13: KAV -> Verabschiedung 2. Vorhersage nächster Schritt: VAV: 0.432 KAV: 0.398 KAA: 0.089 3. Filterung an Position 5: Beratung: 0.723 Bedarfsermittlung: 0.245 Begrüßung: 0.032 4. Glättung an Position 5: Beratung: 0.812 Bedarfsermittlung: 0.156 Begrüßung: 0.032 -------------------------------------------------- === Vergleich der Transkripte === Transkript 1: Länge: 13 Log-Wahrscheinlichkeit: -23.4567 Zustandsverteilung: Begrüßung: 15.38% Bedarfsermittlung: 30.77% Beratung: 23.08% Abschluss: 15.38% Verabschiedung: 15.38% Transkript 2: Länge: 9 Log-Wahrscheinlichkeit: -18.2345 Zustandsverteilung: Begrüßung: 22.22% Bedarfsermittlung: 33.33% Abschluss: 44.44% ... -------------------------------------------------- === Analyse von Übergangsmustern === Empirische Übergangswahrscheinlichkeiten: Begrüßung -> Bedarfsermittlung: 0.857 (6x) Begrüßung: 0.143 (1x) Bedarfsermittlung -> Beratung: 0.500 (5x) Abschluss: 0.300 (3x) Bedarfsermittlung: 0.200 (2x) Beratung -> Abschluss: 0.571 (4x) Bedarfsermittlung: 0.286 (2x) Beratung: 0.143 (1x) Abschluss -> Verabschiedung: 0.833 (5x) Abschluss: 0.167 (1x) Verabschiedung -> Verabschiedung: 1.000 (6x) 8. Exportiere HMM-Parameter... HMM-Parameter exportiert als 'hmm_parameters.txt' ====================================================================== ARS 4.0 - BAYESSCHE VERFAHREN ABGESCHLOSSEN ====================================================================== ``` # Diskussion ## Methodologische Bewertung Die Integration Bayesscher Verfahren in die ARS erfüllt die zentralen methodologischen Anforderungen: 1. **Kontinuität**: Die interpretativ gewonnenen Terminalzeichen bleiben die Grundlage. Die HMM-Parameter werden aus diesen abgeleitet. 2. **Transparenz**: Jeder Zustand ist semantisch gehaltvoll benannt, jede Wahrscheinlichkeit ist dokumentiert. 3. **Erweiterung**: Unsicherheit, latente Variablen und bidirektionale Inferenz werden explizit modelliert. ## Mehrwert gegenüber ARS 3.0 Die Bayessche Modellierung bietet gegenüber der reinen Grammatik mehrere Vorteile: - **Latente Variablen**: Verborgene Gesprächsphasen werden explizit modelliert und können aus Beobachtungen erschlossen werden. - **Unsicherheitsquantifizierung**: Jede Vorhersage wird mit einer Wahrscheinlichkeit versehen. - **Bidirektionale Inferenz**: Neben der Vorhersage (Vorwärts) sind auch Rückschlüsse auf vergangene Zustände (Rückwärts) möglich. - **Filterung und Glättung**: Der aktuelle Zustand kann sowohl aus vergangenen als auch aus allen Beobachtungen geschätzt werden. ## Interpretation der Ergebnisse Die Analyse der acht Transkripte mit dem HMM zeigt: - **Typische Zustandssequenzen**: Die meisten Gespräche folgen dem Muster Begrüßung → Bedarfsermittlung → (Beratung) → Abschluss → Verabschiedung. - **Abweichungen**: Transkript 5 beginnt direkt mit einer Verabschiedung (KAV), was auf eine besondere Interaktionssituation hinweist. - **Übergangsmuster**: Die empirischen Übergangswahrscheinlichkeiten bestätigen weitgehend die aus der ARS-Grammatik abgeleiteten Werte. ## Grenzen Die Bayessche Modellierung hat auch Grenzen: - Die Annahme der Markov-Eigenschaft (Zustand hängt nur vom letzten ab) ist eine Vereinfachung. - Die Anzahl der latenten Zustände muss vorgegeben werden (hier 5). - Sehr seltene Übergänge werden möglicherweise nicht erfasst. # Fazit und Ausblick Die Integration Bayesscher Verfahren in die ARS 4.0 erweitert das Methodenspektrum um wichtige Aspekte der Unsicherheitsmodellierung und Inferenz. Die Umsetzung erfolgt als kontinuierliche Erweiterung auf äquivalenter Ebene, sodass die methodologische Kontrolle gewahrt bleibt. Weiterführende Forschung könnte: - **Hierarchische HMM**: Modellierung mehrerer Abstraktionsebenen - **Input-output HMM**: Einbeziehung von Kontextvariablen (Tageszeit, Kundentyp) - **Bayessche Strukturlernverfahren**: Automatische Bestimmung der Zustandsanzahl - **Coupler HMM**: Gleichzeitige Modellierung von Kunde und Verkäufer ::: thebibliography 99 Murphy, K. P. (2002). *Dynamic Bayesian Networks: Representation, Inference and Learning*. PhD Thesis, UC Berkeley. Pearl, J. (1988). *Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference*. Morgan Kaufmann. Rabiner, L. R. (1989). A tutorial on hidden Markov models and selected applications in speech recognition. *Proceedings of the IEEE*, 77(2), 257-286. ::: # Die acht Transkripte mit Terminalzeichen ## Transkript 1 - Metzgerei **Terminalzeichenkette 1:** KBG, VBG, KBBd, VBBd, KBA, VBA, KBBd, VBBd, KBA, VAA, KAA, VAV, KAV ## Transkript 2 - Marktplatz (Kirschen) **Terminalzeichenkette 2:** VBG, KBBd, VBBd, VAA, KAA, VBG, KBBd, VAA, KAA ## Transkript 3 - Fischstand **Terminalzeichenkette 3:** KBBd, VBBd, VAA, KAA ## Transkript 4 - Gemüsestand (ausführlich) **Terminalzeichenkette 4:** KBBd, VBBd, KBA, VBA, KBBd, VBA, KAE, VAE, KAA, VAV, KAV ## Transkript 5 - Gemüsestand (mit KAV zu Beginn) **Terminalzeichenkette 5:** KAV, KBBd, VBBd, KBBd, VAA, KAV ## Transkript 6 - Käseverkaufsstand **Terminalzeichenkette 6:** KBG, VBG, KBBd, VBBd, KAA ## Transkript 7 - Bonbonstand **Terminalzeichenkette 7:** KBBd, VBBd, KBA, VAA, KAA ## Transkript 8 - Bäckerei **Terminalzeichenkette 8:** KBG, VBBd, KBBd, VBA, VAA, KAA, VAV, KAV