|
|
import torch |
|
|
import numpy as np |
|
|
from cognitive_mapping_probe.llm_iface import get_or_load_model |
|
|
from cognitive_mapping_probe.resonance_seismograph import run_silent_cogitation_seismic |
|
|
from cognitive_mapping_probe.concepts import get_concept_vector, _get_last_token_hidden_state |
|
|
from cognitive_mapping_probe.signal_analysis import analyze_cognitive_signal |
|
|
|
|
|
def test_get_or_load_model_loads_correctly(model_id): |
|
|
"""Testet, ob das Laden eines echten Modells funktioniert.""" |
|
|
llm = get_or_load_model(model_id, seed=42) |
|
|
assert llm is not None |
|
|
assert llm.model_id == model_id |
|
|
assert llm.stable_config.hidden_dim > 0 |
|
|
assert llm.stable_config.num_layers > 0 |
|
|
|
|
|
def test_run_silent_cogitation_seismic_output_shape_and_type(model_id): |
|
|
"""Führt einen kurzen Lauf mit einem echten Modell durch und prüft die Datentypen.""" |
|
|
num_steps = 10 |
|
|
llm = get_or_load_model(model_id, seed=42) |
|
|
state_deltas = run_silent_cogitation_seismic( |
|
|
llm=llm, prompt_type="control_long_prose", |
|
|
num_steps=num_steps, temperature=0.1 |
|
|
) |
|
|
assert isinstance(state_deltas, list) |
|
|
assert len(state_deltas) == num_steps |
|
|
assert all(isinstance(d, float) for d in state_deltas) |
|
|
|
|
|
def test_get_last_token_hidden_state_robustness(model_id): |
|
|
"""Testet die Helper-Funktion mit einem echten Modell.""" |
|
|
llm = get_or_load_model(model_id, seed=42) |
|
|
hs = _get_last_token_hidden_state(llm, "test prompt") |
|
|
assert isinstance(hs, torch.Tensor) |
|
|
assert hs.shape == (llm.stable_config.hidden_dim,) |
|
|
|
|
|
def test_get_concept_vector_logic(model_id): |
|
|
"""Testet die Vektor-Extraktion mit einem echten Modell.""" |
|
|
llm = get_or_load_model(model_id, seed=42) |
|
|
vector = get_concept_vector(llm, "love", baseline_words=["thing", "place"]) |
|
|
assert isinstance(vector, torch.Tensor) |
|
|
assert vector.shape == (llm.stable_config.hidden_dim,) |
|
|
|
|
|
def test_analyze_cognitive_signal_no_peaks(): |
|
|
""" |
|
|
Testet den Edge Case, dass ein Signal keine signifikanten Frequenz-Peaks hat. |
|
|
""" |
|
|
flat_signal = np.linspace(0, 1, 100) |
|
|
results = analyze_cognitive_signal(flat_signal) |
|
|
assert results is not None |
|
|
assert results["dominant_periods_steps"] is None |
|
|
assert "spectral_entropy" in results |
|
|
|
|
|
def test_analyze_cognitive_signal_with_peaks(): |
|
|
""" |
|
|
Testet den Normalfall, dass ein Signal Peaks hat, mit realistischerem Rauschen. |
|
|
""" |
|
|
np.random.seed(42) |
|
|
steps = np.arange(200) |
|
|
|
|
|
signal_with_peak = (1.0 * np.sin(2 * np.pi * (1/10.0) * steps) + |
|
|
0.5 * np.sin(2 * np.pi * (1/25.0) * steps) + |
|
|
np.random.randn(200) * 0.5) |
|
|
results = analyze_cognitive_signal(signal_with_peak) |
|
|
|
|
|
assert results["dominant_periods_steps"] is not None |
|
|
assert 10.0 in results["dominant_periods_steps"] |
|
|
assert 25.0 in results["dominant_periods_steps"] |
|
|
|
|
|
def test_analyze_cognitive_signal_with_multiple_peaks(): |
|
|
""" |
|
|
Erweiterter Test, der die korrekte Identifizierung und Sortierung |
|
|
von drei Peaks verifiziert, mit realistischerem Rauschen. |
|
|
""" |
|
|
np.random.seed(42) |
|
|
steps = np.arange(300) |
|
|
|
|
|
signal = (2.0 * np.sin(2 * np.pi * (1/10.0) * steps) + |
|
|
1.5 * np.sin(2 * np.pi * (1/4.0) * steps) + |
|
|
1.0 * np.sin(2 * np.pi * (1/30.0) * steps) + |
|
|
np.random.randn(300) * 0.5) |
|
|
|
|
|
results = analyze_cognitive_signal(signal, num_peaks=3) |
|
|
|
|
|
assert results["dominant_periods_steps"] is not None |
|
|
expected_periods = [10.0, 4.0, 30.0] |
|
|
assert results["dominant_periods_steps"] == expected_periods |
|
|
|
