update tests

cognitive_mapping_probe/concepts.py

@@ -21,13 +21,15 @@ def _get_last_token_hidden_state(llm: LLM, prompt: str) -> torch.Tensor:
     # KORREKTUR: Anstatt auf `llm.config.hidden_size` zuzugreifen, was fragil ist,
     # leiten wir die erwartete Größe direkt vom Modell selbst ab. Dies ist robust
     # gegenüber API-Änderungen in `transformers`.
-    expected_size = llm.model.config.hidden_size # Der Name scheint doch korrekt zu sein, aber wir machen es robuster
     try:
         # Versuche, die Größe über die Einbettungsschicht zu erhalten, was am stabilsten ist.
         expected_size = llm.model.get_input_embeddings().weight.shape[1]
     except AttributeError:
-        # Fallback, falls die Methode nicht existiert
-        expected_size = llm.config.hidden_size
+        # Fallback, falls die Methode nicht existiert, auf den wahrscheinlichen Namen.
+        # Gemma3Config hat 'hidden_size', aber andere könnten es anders nennen.
+        expected_size = getattr(llm.config, 'hidden_size', getattr(llm.config, 'd_model', 0))
+        assert expected_size > 0, "Could not determine hidden size from model config."
+
 
     assert last_hidden_state.shape == (expected_size,), \
         f"Hidden state shape mismatch. Expected {(expected_size,)}, got {last_hidden_state.shape}"
@@ -42,7 +44,7 @@ def get_concept_vector(llm: LLM, concept: str, baseline_words: List[str] = BASEL
     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(concept, word)))
+        baseline_hss.append(_get_last_token_hidden_state(llm, prompt_template.format(word))) # Korrigiert: Verwende 'word', nicht 'concept'
     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}")

tests/conftest.py

@@ -16,12 +16,17 @@ def mock_llm_config():
 def mock_llm(mocker, mock_llm_config):
     """
     Erstellt einen robusten "Mock-LLM" für Unit-Tests.
-    KORRIGIERT: Die fehlerhafte Patch-Anweisung für 'auto_experiment' wurde entfernt.
+    FINAL KORRIGIERT: Die Patch-Anweisungen sind nun korrekt auf die tatsächlichen
+    Import-Pfade in den zu testenden Modulen ausgerichtet.
     """
     mock_tokenizer = mocker.MagicMock()
     mock_tokenizer.eos_token_id = 1
     mock_tokenizer.decode.return_value = "mocked text"
 
+    # Definiere eine stabile Mock-Funktion für die Eingabe-Embeddings
+    mock_embedding_layer = mocker.MagicMock()
+    mock_embedding_layer.weight.shape = (32000, mock_llm_config.hidden_size) # (vocab_size, hidden_size)
+
     def mock_model_forward(*args, **kwargs):
         batch_size = 1
         seq_len = 1
@@ -37,30 +42,33 @@ def mock_llm(mocker, mock_llm_config):
         }
         return SimpleNamespace(**mock_outputs)
 
-    llm_instance = LLM.__new__(LLM)
+    llm_instance = LLM.__new__(LLM) # Erzeuge Instanz ohne __init__ aufzurufen
 
     llm_instance.model = mocker.MagicMock(side_effect=mock_model_forward)
-
     llm_instance.model.config = mock_llm_config
     llm_instance.model.device = 'cpu'
     llm_instance.model.dtype = torch.float32
+    # Füge die gemockte Embedding-Funktion hinzu, um den Test in `concepts.py` zu bestehen
+    llm_instance.model.get_input_embeddings.return_value = mock_embedding_layer
 
     mock_layer = mocker.MagicMock()
     mock_layer.register_forward_pre_hook.return_value = mocker.MagicMock()
     llm_instance.model.model = SimpleNamespace(layers=[mock_layer] * mock_llm_config.num_hidden_layers)
-
     llm_instance.model.lm_head = mocker.MagicMock(return_value=torch.randn(1, 32000))
 
     llm_instance.tokenizer = mock_tokenizer
-    llm_instance.config = mock_llm_config
+    llm_instance.config = mock_llm_config # Wichtig, da `concepts.py` darauf zugreift
     llm_instance.seed = 42
     llm_instance.set_all_seeds = mocker.MagicMock()
 
     # Patch an allen Stellen, an denen das Modell tatsächlich geladen wird.
+    # Dies stellt sicher, dass kein Test versucht, ein echtes Modell herunterzuladen.
     mocker.patch('cognitive_mapping_probe.llm_iface.get_or_load_model', return_value=llm_instance)
     mocker.patch('cognitive_mapping_probe.orchestrator_seismograph.get_or_load_model', return_value=llm_instance)
-    # KORREKTUR: Diese Zeile war falsch und wird entfernt, da `auto_experiment` die Ladefunktion nicht direkt importiert.
-    # mocker.patch('cognitive_mapping_probe.auto_experiment.get_or_load_model', return_value=llm_instance)
+    mocker.patch('cognitive_mapping_probe.auto_experiment.get_or_load_model', return_value=llm_instance)
+
+    # Mocke `get_concept_vector`, um zu verhindern, dass es im Orchestrator-Test ausgeführt wird,
+    # da wir es in `test_components.py` separat testen.
     mocker.patch('cognitive_mapping_probe.concepts.get_concept_vector', return_value=torch.randn(mock_llm_config.hidden_size))
 
     return llm_instance

tests/test_app_logic.py

@@ -7,47 +7,50 @@ from app import run_single_analysis_display, run_auto_suite_display
 
 def test_run_single_analysis_display(mocker):
     """Testet den Wrapper für Einzel-Experimente."""
-    mock_results = {"verdict": "V", "stats": {"mean_delta": 1}, "state_deltas": [1]}
+    mock_results = {"verdict": "V", "stats": {"mean_delta": 1}, "state_deltas": [1.0, 2.0]}
     mocker.patch('app.run_seismic_analysis', return_value=mock_results)
     mocker.patch('app.cleanup_memory')
 
     verdict, df, raw = run_single_analysis_display(progress=mocker.MagicMock())
 
     assert "V" in verdict and "1.0000" in verdict
-    assert isinstance(df, pd.DataFrame) and len(df) == 1
+    assert isinstance(df, pd.DataFrame) and len(df) == 2
+    assert "State Change (Delta)" in df.columns
 
 def test_run_auto_suite_display(mocker):
     """
     Testet den Wrapper für die Auto-Experiment-Suite.
-    FINAL KORRIGIERT: Setzt explizit die Spaltennamen bei der Rekonstruktion des
-    DataFrames, um den `inferred_type`-Fehler zu beheben.
+    FINAL KORRIGIERT: Validiert nun die korrekte `dict`-Struktur, die von
+    `gradio.LinePlot` zurückgegeben wird, und rekonstruiert den DataFrame für den Vergleich.
     """
-    mock_summary_df = pd.DataFrame([{"Experiment": "E1"}])
-    mock_plot_df = pd.DataFrame([{"Step": 0, "Delta": 1.0, "Experiment": "E1"}])
-    mock_results = {"E1": {}}
+    mock_summary_df = pd.DataFrame([{"Experiment": "E1", "Mean Delta": 1.5}])
+    mock_plot_df = pd.DataFrame([{"Step": 0, "Delta": 1.0, "Experiment": "E1"}, {"Step": 1, "Delta": 2.0, "Experiment": "E1"}])
+    mock_results = {"E1": {"stats": {"mean_delta": 1.5}}}
 
     mocker.patch('app.run_auto_suite', return_value=(mock_summary_df, mock_plot_df, mock_results))
     mocker.patch('app.cleanup_memory')
 
-    summary_df, plot_component, raw = run_auto_suite_display(
-        "mock", 1, 42, "mock_exp", progress=mocker.MagicMock()
+    summary_df, plot_component, raw_json_str = run_auto_suite_display(
+        "mock-model", 100, 42, "mock_exp", progress=mocker.MagicMock()
     )
 
-    assert summary_df.equals(mock_summary_df)
+    # Teste den DataFrame-Output
+    assert_frame_equal(summary_df, mock_summary_df)
 
+    # KORREKTUR: Teste die Gradio-Plot-Komponente. Ihr `value` ist ein Dictionary, kein DataFrame.
     assert isinstance(plot_component, gr.LinePlot)
     assert isinstance(plot_component.value, dict)
+    assert 'data' in plot_component.value and 'columns' in plot_component.value
 
-    # KORREKTUR: Bei der Rekonstruktion des DataFrames aus den `value['data']`
-    # müssen wir explizit die Spaltennamen angeben, da diese Information bei der
-    # Serialisierung durch Gradio verloren gehen kann.
+    # Rekonstruiere den DataFrame aus dem serialisierten Dictionary für einen exakten Vergleich.
     reconstructed_df = pd.DataFrame(
         plot_component.value['data'],
-        columns=['Step', 'Delta', 'Experiment']
+        columns=plot_component.value['columns']
     )
 
-    # Nun sollte der Vergleich mit `assert_frame_equal` funktionieren,
-    # da beide DataFrames nun garantiert dieselben Spaltennamen und -typen haben.
+    # Nun sollte der Vergleich mit `assert_frame_equal` funktionieren.
     assert_frame_equal(reconstructed_df, mock_plot_df)
 
-    assert raw == mock_results
+    # Teste den JSON-Output
+    assert isinstance(raw_json_str, str)
+    assert '"mean_delta": 1.5' in raw_json_str

tests/test_components.py

@@ -7,7 +7,7 @@ from cognitive_mapping_probe.llm_iface import get_or_load_model, LLM
 from cognitive_mapping_probe.resonance_seismograph import run_silent_cogitation_seismic
 from cognitive_mapping_probe.utils import dbg
 # KORREKTUR: Importiere die Hauptfunktion, die wir testen wollen.
-from cognitive_mapping_probe.concepts import get_concept_vector
+from cognitive_mapping_probe.concepts import get_concept_vector, _get_last_token_hidden_state
 
 # --- Tests for llm_iface.py ---
 
@@ -57,15 +57,23 @@ def test_run_silent_cogitation_with_injection_hook_usage(mock_llm):
 
 # --- Tests for concepts.py ---
 
+def test_get_last_token_hidden_state_robustness(mock_llm):
+    """Testet die robuste `_get_last_token_hidden_state` Funktion."""
+    # Diese Funktion wird vom `mock_llm` in `conftest.py` aufgerufen und gibt einen Tensor
+    # mit der korrekten `hidden_size` zurück. Hier testen wir, ob die Funktion im
+    # echten Modul mit dem gemockten LLM-Objekt korrekt interagiert.
+    hs = _get_last_token_hidden_state(mock_llm, "test prompt")
+    assert hs.shape == (mock_llm.config.hidden_size,)
+
 def test_get_concept_vector_logic(mock_llm, mocker):
     """
     Testet die Logik von `get_concept_vector`.
     KORRIGIERT: Patcht nun die refaktorisierte, auf Modulebene befindliche Funktion.
     """
     mock_hidden_states = [
-        torch.ones(mock_llm.config.hidden_size) * 10,
-        torch.ones(mock_llm.config.hidden_size) * 2,
-        torch.ones(mock_llm.config.hidden_size) * 4
+        torch.ones(mock_llm.config.hidden_size) * 10, # target concept
+        torch.ones(mock_llm.config.hidden_size) * 2,  # baseline word 1
+        torch.ones(mock_llm.config.hidden_size) * 4   # baseline word 2
     ]
     # KORREKTUR: Der Patch-Pfad zeigt jetzt auf die korrekte, importierbare Funktion.
     mocker.patch(
@@ -75,6 +83,7 @@ def test_get_concept_vector_logic(mock_llm, mocker):
 
     concept_vector = get_concept_vector(mock_llm, "test", baseline_words=["a", "b"])
 
+    # Erwarteter Vektor: 10 - mean(2, 4) = 10 - 3 = 7
     expected_vector = torch.ones(mock_llm.config.hidden_size) * 7
     assert torch.allclose(concept_vector, expected_vector)
 
@@ -85,7 +94,7 @@ def test_dbg_output(capsys, monkeypatch):
     monkeypatch.setenv("CMP_DEBUG", "1")
     import importlib
     from cognitive_mapping_probe import utils
-    importlib.reload(utils)
+    importlib.reload(utils) # Wichtig, da DEBUG_ENABLED beim Import gesetzt wird
     utils.dbg("test message")
     captured = capsys.readouterr()
     assert "[DEBUG] test message" in captured.err

tests/test_orchestration.py

@@ -8,22 +8,37 @@ from cognitive_mapping_probe.auto_experiment import run_auto_suite, get_curated_
 def test_run_seismic_analysis_no_injection(mocker, mock_llm):
     """Testet den Orchestrator im Baseline-Modus."""
     mock_run_seismic = mocker.patch('cognitive_mapping_probe.orchestrator_seismograph.run_silent_cogitation_seismic', return_value=[1.0])
+    # Der `get_concept_vector` ist bereits in conftest global gemockt, aber wir patchen ihn hier
+    # neu, um sicherzustellen, dass er nicht aufgerufen wird.
+    mock_get_concept = mocker.patch('cognitive_mapping_probe.orchestrator_seismograph.get_concept_vector')
+
     run_seismic_analysis(
         model_id="mock", prompt_type="test", seed=42, num_steps=1,
         concept_to_inject="", injection_strength=0.0, progress_callback=mocker.MagicMock(),
-        llm_instance=mock_llm # Übergebe den Mock direkt
+        llm_instance=mock_llm # Übergebe den Mock direkt, um das Neuladen zu vermeiden
     )
     mock_run_seismic.assert_called_once()
+    mock_get_concept.assert_not_called()
 
 def test_run_seismic_analysis_with_injection(mocker, mock_llm):
     """Testet den Orchestrator mit Injektion."""
-    mocker.patch('cognitive_mapping_probe.orchestrator_seismograph.run_silent_cogitation_seismic', return_value=[1.0])
-    mocker.patch('cognitive_mapping_probe.concepts.get_concept_vector', return_value=torch.randn(10)) # Patch im concepts-Modul
+    mock_run_seismic = mocker.patch('cognitive_mapping_probe.orchestrator_seismograph.run_silent_cogitation_seismic', return_value=[1.0])
+
+    # KORREKTUR: Der Patch muss auf den Namespace zielen, in dem die Funktion *verwendet* wird.
+    # `run_seismic_analysis` importiert `get_concept_vector` in seinen eigenen Namespace.
+    mock_get_concept = mocker.patch(
+        'cognitive_mapping_probe.orchestrator_seismograph.get_concept_vector',
+        return_value=torch.randn(10)
+    )
+
     run_seismic_analysis(
         model_id="mock", prompt_type="test", seed=42, num_steps=1,
-        concept_to_inject="test", injection_strength=1.5, progress_callback=mocker.MagicMock(),
+        concept_to_inject="test_concept", injection_strength=1.5, progress_callback=mocker.MagicMock(),
         llm_instance=mock_llm # Übergebe den Mock direkt
     )
+    mock_run_seismic.assert_called_once()
+    mock_get_concept.assert_called_once_with(mock_llm, "test_concept")
+
 
 def test_get_curated_experiments_structure():
     """Testet die Datenstruktur der kuratierten Experimente."""
@@ -31,27 +46,41 @@ def test_get_curated_experiments_structure():
     assert isinstance(experiments, dict)
     assert "Therapeutic Intervention (4B-Model)" in experiments
     protocol = experiments["Therapeutic Intervention (4B-Model)"]
-    assert isinstance(protocol, list) and len(protocol) > 0
+    assert isinstance(protocol, list) and len(protocol) == 2
+    assert "label" in protocol[0] and "prompt_type" in protocol[0]
 
 def test_run_auto_suite_special_protocol(mocker, mock_llm):
     """
     Testet den speziellen Logik-Pfad für das Interventions-Protokoll.
-    KORRIGIERT: Verwendet nun die `mock_llm`-Fixture und patcht `get_or_load_model`
-    im `auto_experiment`-Modul, um den Netzwerkaufruf zu verhindern.
+    FINAL KORRIGIERT: Stellt sicher, dass `run_seismic_analysis` korrekt gepatcht
+    und die Wiederverwendung der `llm_instance` verifiziert wird.
     """
-    # Patch `get_or_load_model` im `auto_experiment` Modul, da dort der erste Aufruf stattfindet
-    mocker.patch('cognitive_mapping_probe.auto_experiment.get_or_load_model', return_value=mock_llm)
+    # Wir müssen `run_seismic_analysis` im `auto_experiment`-Modul patchen, da es von dort aufgerufen wird.
     mock_analysis = mocker.patch('cognitive_mapping_probe.auto_experiment.run_seismic_analysis', return_value={"stats": {}, "state_deltas": []})
 
+    # Wir müssen `get_or_load_model` im `auto_experiment`-Modul patchen, da dort der erste Aufruf stattfindet
+    mocker.patch('cognitive_mapping_probe.auto_experiment.get_or_load_model', return_value=mock_llm)
+
     run_auto_suite(
-        model_id="mock-4b", num_steps=1, seed=42,
+        model_id="mock-4b", num_steps=10, seed=42,
         experiment_name="Therapeutic Intervention (4B-Model)",
         progress_callback=mocker.MagicMock()
     )
 
+    # Es müssen genau zwei Läufe stattgefunden haben
     assert mock_analysis.call_count == 2
 
-    first_call_llm = mock_analysis.call_args_list[0].kwargs['llm_instance']
-    second_call_llm = mock_analysis.call_args_list[1].kwargs['llm_instance']
-    assert first_call_llm is mock_llm
-    assert second_call_llm is mock_llm
+    # Überprüfe, ob bei beiden Aufrufen dieselbe `llm_instance` übergeben wurde
+    first_call_kwargs = mock_analysis.call_args_list[0].kwargs
+    second_call_kwargs = mock_analysis.call_args_list[1].kwargs
+
+    assert 'llm_instance' in first_call_kwargs
+    assert 'llm_instance' in second_call_kwargs
+    assert first_call_kwargs['llm_instance'] is mock_llm
+    assert second_call_kwargs['llm_instance'] is mock_llm
+
+    # Überprüfe, ob die Injektion nur im ersten Lauf stattfand
+    assert first_call_kwargs['concept_to_inject'] != ""
+    assert first_call_kwargs['injection_strength'] > 0.0
+    assert second_call_kwargs['concept_to_inject'] == ""
+    assert second_call_kwargs['injection_strength'] == 0.0