fix

app.py

@@ -3,7 +3,7 @@ import pandas as pd
 import traceback
 import gc
 import torch
-import json # Importiere das json-Modul
+import json
 
 from cognitive_mapping_probe.orchestrator_seismograph import run_seismic_analysis
 from cognitive_mapping_probe.auto_experiment import run_auto_suite, get_curated_experiments
@@ -21,19 +21,18 @@ def cleanup_memory():
     dbg("Memory cleanup complete.")
 
 def run_single_analysis_display(*args, progress=gr.Progress(track_tqdm=True)):
-    """Wrapper für ein einzelnes manuelles Experiment."""
+    """Wrapper für ein einzelnes manuelles Experiment mit robuster Fehlerbehandlung."""
     try:
         results = run_seismic_analysis(*args, progress_callback=progress)
         stats, deltas = results.get("stats", {}), results.get("state_deltas", [])
         df = pd.DataFrame({"Internal Step": range(len(deltas)), "State Change (Delta)": deltas})
         stats_md = f"### Statistical Signature\n- **Mean Delta:** {stats.get('mean_delta', 0):.4f}\n- **Std Dev Delta:** {stats.get('std_delta', 0):.4f}\n- **Max Delta:** {stats.get('max_delta', 0):.4f}\n"
-
-        # Stelle sicher, dass das Ergebnis für die JSON-Komponente serialisierbar ist
         serializable_results = json.dumps(results, indent=2, default=str)
-
         return f"{results.get('verdict', 'Error')}\n\n{stats_md}", df, serializable_results
     except Exception:
-        return f"### ❌ Analysis Failed\n```\n{traceback.format_exc()}\n```", pd.DataFrame(), "{}"
+        # Im Fehlerfall, gib für jede Komponente einen leeren, aber typ-korrekten Wert zurück.
+        error_message = f"### ❌ Analysis Failed\n```\n{traceback.format_exc()}\n```"
+        return error_message, pd.DataFrame(), "{}"
     finally:
         cleanup_memory()
 
@@ -44,22 +43,20 @@ PLOT_PARAMS = {
 }
 
 def run_auto_suite_display(model_id, num_steps, seed, experiment_name, progress=gr.Progress(track_tqdm=True)):
-    """Wrapper für die automatisierte Experiment-Suite mit korrekter JSON-Serialisierung."""
+    """
+    Wrapper für die automatisierte Experiment-Suite mit robuster Fehlerbehandlung.
+    """
     try:
         summary_df, plot_df, all_results = run_auto_suite(model_id, int(num_steps), int(seed), experiment_name, progress)
-
-        dbg("Plot DataFrame Head for Auto-Suite:\n", plot_df.head())
-
         new_plot = gr.LinePlot(value=plot_df, **PLOT_PARAMS)
-
-        # KORREKTUR: Serialisiere das Ergebnis-Dictionary explizit zu einem JSON-String,
-        # bevor es an die `gr.JSON`-Komponente zurückgegeben wird.
         serializable_results = json.dumps(all_results, indent=2, default=str)
-
         return summary_df, new_plot, serializable_results
     except Exception:
+        # KORREKTUR: Gib für jede Komponente einen typ-korrekten, leeren Wert zurück.
+        # Insbesondere für die JSON-Komponente einen leeren JSON-String.
         empty_plot = gr.LinePlot(value=pd.DataFrame(), **PLOT_PARAMS)
-        return pd.DataFrame(), empty_plot, f"### ❌ Auto-Experiment Failed\n```\n{traceback.format_exc()}\n```"
+        error_string_for_json = json.dumps({"error": traceback.format_exc()}, indent=2)
+        return pd.DataFrame([{"Error": "Experiment failed. See Raw JSON."}]), empty_plot, error_string_for_json
     finally:
         cleanup_memory()
 

cognitive_mapping_probe/concepts.py

@@ -5,19 +5,17 @@ from tqdm import tqdm
 from .llm_iface import LLM
 from .utils import dbg
 
-# Eine Liste neutraler Wörter zur Berechnung der Baseline-Aktivierung.
 BASELINE_WORDS = [
     "thing", "place", "idea", "person", "object", "time", "way", "day", "man", "world",
     "life", "hand", "part", "child", "eye", "woman", "fact", "group", "case", "point"
 ]
 
-# REFAKTORISIERUNG: Diese Funktion wird auf Modulebene verschoben, um sie testbar zu machen.
-# Sie ist nun keine lokale Funktion innerhalb von `get_concept_vector` mehr.
 @torch.no_grad()
 def _get_last_token_hidden_state(llm: LLM, prompt: str) -> torch.Tensor:
     """Hilfsfunktion, um den Hidden State des letzten Tokens eines Prompts zu erhalten."""
     inputs = llm.tokenizer(prompt, return_tensors="pt").to(llm.model.device)
     with torch.no_grad():
+        # WAHRSCHEINLICHE FEHLERQUELLE: Sicherstellen, dass hier wirklich `llm` steht.
         outputs = llm.model(**inputs, output_hidden_states=True)
     last_hidden_state = outputs.hidden_states[-1][0, -1, :].cpu()
     assert last_hidden_state.shape == (llm.config.hidden_size,), \
@@ -26,28 +24,19 @@ def _get_last_token_hidden_state(llm: LLM, prompt: str) -> torch.Tensor:
 
 @torch.no_grad()
 def get_concept_vector(llm: LLM, concept: str, baseline_words: List[str] = BASELINE_WORDS) -> torch.Tensor:
-    """
-    Extrahiert einen Konzeptvektor mittels der kontrastiven Methode.
-    """
+    """Extrahiert einen Konzeptvektor mittels der kontrastiven Methode."""
     dbg(f"Extracting contrastive concept vector for '{concept}'...")
-
     prompt_template = "Here is a sentence about the concept of {}."
-
     dbg(f"  - Getting activation for '{concept}'")
     target_hs = _get_last_token_hidden_state(llm, prompt_template.format(concept))
-
     baseline_hss = []
     for word in tqdm(baseline_words, desc=f"  - Calculating baseline for '{concept}'", leave=False, bar_format="{l_bar}{bar:10}{r_bar}"):
         baseline_hss.append(_get_last_token_hidden_state(llm, prompt_template.format(word)))
-
-    assert all(hs.shape == target_hs.shape for hs in baseline_hss), "Shape mismatch in baseline hidden states."
-
+    assert all(hs.shape == target_hs.shape for hs in baseline_hss)
     mean_baseline_hs = torch.stack(baseline_hss).mean(dim=0)
     dbg(f"  - Mean baseline vector computed with norm {torch.norm(mean_baseline_hs).item():.2f}")
-
     concept_vector = target_hs - mean_baseline_hs
     norm = torch.norm(concept_vector).item()
     dbg(f"Concept vector for '{concept}' extracted with norm {norm:.2f}.")
-
-    assert torch.isfinite(concept_vector).all(), "Concept vector contains NaN or Inf values."
+    assert torch.isfinite(concept_vector).all()
     return concept_vector