tests

app.py

@@ -104,7 +104,6 @@ with gr.Blocks(theme=theme, title="Cognitive Breaking Point Probe") as demo:
                 headers=["concept", "strength", "responded", "termination_reason", "generated_text"],
                 label="Detailed Run Data",
                 wrap=True,
-                height=400
             )
             with gr.Accordion("Raw JSON Output", open=False):
                 raw_json_output = gr.JSON()

tests/conftest.py

@@ -1,70 +0,0 @@
-import pytest
-import torch
-from types import SimpleNamespace
-from cognitive_mapping_probe.llm_iface import LLM
-
-@pytest.fixture(scope="session")
-def mock_llm_config():
-    """Stellt eine minimale, Schein-Konfiguration für das LLM bereit."""
-    return SimpleNamespace(
-        hidden_size=128,  # Kleinere Größe für schnelle Tests
-        num_hidden_layers=4,
-        num_attention_heads=4
-    )
-
-@pytest.fixture
-def mock_llm(mocker, mock_llm_config):
-    """
-    Dies ist die wichtigste Fixture. Sie erstellt einen "Mock-LLM".
-    Anstatt ein echtes Modell von Hugging Face zu laden (was langsam ist und eine GPU erfordert),
-    simulieren wir sein Verhalten. Wir verwenden `mocker.patch`, um die echte Ladefunktion
-    `get_or_load_model` abzufangen und stattdessen unsere schnelle Mock-Instanz zurückzugeben.
-    """
-    # Erstelle eine Schein-Tokenizer-Instanz
-    mock_tokenizer = mocker.MagicMock()
-    mock_tokenizer.eos_token_id = 1
-    mock_tokenizer.decode.return_value = "mocked text"
-
-    # Erstelle ein Schein-Modell-Objekt
-    mock_model = mocker.MagicMock()
-
-    # Konfiguriere das Schein-Modell so, dass es auf Aufrufe mit plausiblen Tensoren antwortet
-    def mock_model_forward(*args, **kwargs):
-        batch_size = 1
-        seq_len = kwargs.get("input_ids", torch.tensor([[0]])).shape[1]
-
-        # Simuliere die Ausgaben eines echten Transformer-Modells
-        mock_outputs = {
-            "hidden_states": tuple(
-                [torch.randn(batch_size, seq_len, mock_llm_config.hidden_size) for _ in range(mock_llm_config.num_hidden_layers + 1)]
-            ),
-            "past_key_values": tuple(
-                [
-                    (torch.randn(batch_size, mock_llm_config.num_attention_heads, seq_len, 16),
-                     torch.randn(batch_size, mock_llm_config.num_attention_heads, seq_len, 16))
-                    for _ in range(mock_llm_config.num_hidden_layers)
-                ]
-            ),
-            "logits": torch.randn(batch_size, seq_len, 32000) # Schein-Vokabulargröße
-        }
-        return SimpleNamespace(**mock_outputs)
-
-    mock_model.return_value = mock_model_forward
-    mock_model.config = mock_llm_config
-    mock_model.device = 'cpu'
-
-    # Erstelle eine Instanz unserer LLM-Klasse, aber mit den gemockten Komponenten
-    llm_instance = LLM.__new__(LLM)
-    llm_instance.model = mock_model
-    llm_instance.tokenizer = mock_tokenizer
-    llm_instance.config = mock_llm_config
-    llm_instance.seed = 42
-    llm_instance.set_all_seeds = mocker.MagicMock() # Mocke die Seeding-Funktion
-
-    # Der entscheidende Schritt: Patch die Ladefunktion, damit jeder Code, der sie aufruft,
-    # stattdessen unsere Mock-Instanz erhält.
-    mocker.patch('cognitive_mapping_probe.llm_iface.get_or_load_model', return_value=llm_instance)
-    mocker.patch('cognitive_mapping_probe.orchestrator.get_or_load_model', return_value=llm_instance)
-    mocker.patch('cognitive_mapping_probe.concepts.get_or_load_model', return_value=llm_instance)
-
-    return llm_instance

tests/test_core_logic.py

@@ -1,125 +0,0 @@
-import torch
-import pytest
-from types import SimpleNamespace
-
-from cognitive_mapping_probe.concepts import get_concept_vector
-from cognitive_mapping_probe.resonance import run_silent_cogitation
-from cognitive_mapping_probe.verification import generate_spontaneous_text
-from cognitive_mapping_probe.orchestrator import run_cognitive_titration_experiment
-
-def test_get_concept_vector(mock_llm):
-    """
-    Testet die `get_concept_vector` Funktion.
-    ASSERT: Gibt einen Tensor der korrekten Form zurück, der nicht null ist.
-    """
-    concept_vector = get_concept_vector(mock_llm, "test_concept")
-
-    assert isinstance(concept_vector, torch.Tensor)
-    assert concept_vector.shape == (mock_llm.config.hidden_size,)
-    assert torch.norm(concept_vector).item() > 0
-
-def test_run_silent_cogitation_max_steps(mock_llm):
-    """
-    Testet `run_silent_cogitation` im Standardfall (erreicht `max_steps`).
-    ASSERT: Läuft fehlerfrei durch und gibt 'max_steps_reached' zurück.
-    """
-    _, _, _, termination_reason = run_silent_cogitation(
-        llm=mock_llm,
-        prompt_type="resonance_prompt",
-        num_steps=10,
-        temperature=0.7
-    )
-    assert termination_reason == "max_steps_reached"
-
-def test_run_silent_cogitation_convergence(mock_llm, mocker):
-    """
-    Testet den Konvergenzfall in `run_silent_cogitation`.
-    Wir patchen hier die `lm_head`-Ausgabe des Modells so, dass sie nach wenigen Schritten
-    einen stabilen Zustand erzwingt.
-    ASSERT: Die Funktion erkennt die Konvergenz korrekt und gibt 'converged' zurück.
-    """
-    stable_hidden_state = torch.ones(1, 1, mock_llm.config.hidden_size)
-
-    # Mocke die Modell-Ausgaben, um Konvergenz zu simulieren
-    def convergence_side_effect(*args, **kwargs):
-        # Nach dem 5. Schritt geben wir immer denselben Zustand zurück
-        if 'past_key_values' in kwargs and kwargs['past_key_values'][0][0].shape[-2] > 5:
-            return SimpleNamespace(
-                hidden_states=(None,) * (mock_llm.config.num_hidden_layers + 1) + (stable_hidden_state,),
-                past_key_values=kwargs['past_key_values'],
-                logits=torch.randn(1, 1, 32000)
-            )
-        # Ansonsten normales Verhalten
-        return mock_llm.model.return_value(*args, **kwargs)
-
-    mock_llm.model.side_effect = convergence_side_effect
-
-    _, _, _, termination_reason = run_silent_cogitation(
-        llm=mock_llm,
-        prompt_type="resonance_prompt",
-        num_steps=20, # Mehr Schritte als nötig, um Konvergenz zu testen
-        temperature=0.7
-    )
-    assert termination_reason == "converged"
-
-def test_generate_spontaneous_text(mock_llm):
-    """
-    Testet die manuelle Textgenerierung.
-    ASSERT: Generiert einen nicht-leeren String.
-    """
-    # Erstelle plausible Schein-Eingaben
-    dummy_state = torch.randn(1, 1, mock_llm.config.hidden_size)
-    dummy_kv_cache = tuple(
-        [
-            (torch.randn(1, mock_llm.config.num_attention_heads, 10, 16),
-             torch.randn(1, mock_llm.config.num_attention_heads, 10, 16))
-            for _ in range(mock_llm.config.num_hidden_layers)
-        ]
-    )
-
-    text = generate_spontaneous_text(mock_llm, dummy_state, dummy_kv_cache, max_new_tokens=5)
-
-    assert isinstance(text, str)
-    assert text == "mocked text" # Unser Mock-Tokenizer gibt immer diesen Text zurück
-
-def test_orchestrator_logic(mocker, mock_llm):
-    """
-    Dies ist ein Integrationstest für den Orchestrator. Wir testen seine *Logik*,
-    indem wir seine teuren Abhängigkeiten (`run_silent_cogitation`) mocken.
-    Wir simulieren ein Szenario, in dem das Modell bei Stärke >= 1.5 "bricht".
-    ASSERT: Der Orchestrator zeichnet die Ergebnisse korrekt auf.
-    """
-    # Mocke die `run_silent_cogitation`, um ihr Verhalten zu kontrollieren
-    def cognition_side_effect(*args, injection_strength=0.0, **kwargs):
-        reason = "converged" if injection_strength < 1.5 else "max_steps_reached"
-        # Gebe Schein-Tensoren zurück, die die richtige Struktur haben
-        return (
-            torch.randn(1, 1, mock_llm.config.hidden_size), # final_hidden_state
-            mocker.MagicMock(), # final_kv_cache
-            torch.tensor([[0]]), # final_token_id
-            reason
-        )
-
-    mocker.patch('cognitive_mapping_probe.orchestrator.run_silent_cogitation', side_effect=cognition_side_effect)
-    mocker.patch('cognitive_mapping_probe.orchestrator.generate_spontaneous_text', return_value="generated")
-
-    # Führe das Experiment mit den gemockten Funktionen aus
-    results = run_cognitive_titration_experiment(
-        model_id="mock_model",
-        prompt_type="resonance_prompt",
-        seed=42,
-        concepts_str="test",
-        strength_levels_str="0.0, 1.0, 1.5, 2.0",
-        num_steps=10,
-        temperature=0.7,
-        progress_callback=mocker.MagicMock() # Mocke auch den Progress-Callback
-    )
-
-    runs = results["runs"]
-    assert len(runs) == 4
-
-    # Überprüfe die Ergebnisse basierend auf unserer Mock-Logik
-    assert runs[0]['strength'] == 0.0 and runs[0]['termination_reason'] == 'converged' and runs[0]['responded'] is True
-    assert runs[1]['strength'] == 1.0 and runs[1]['termination_reason'] == 'converged' and runs[1]['responded'] is True
-    assert runs[2]['strength'] == 1.5 and runs[2]['termination_reason'] == 'max_steps_reached' and runs[2]['responded'] is False
-    assert runs[3]['strength'] == 2.0 and runs[3]['termination_reason'] == 'max_steps_reached' and runs[3]['responded'] is False