Merge pull request #9 from zoccoler/improve_tests

Add comprehensive test suite for signal classifier

Author: zoccoler

.github/workflows/test_and_deploy.yml

@@ -46,6 +46,12 @@ jobs:
           git clone --depth 1 https://github.com/pyvista/gl-ci-helpers.git
           powershell gl-ci-helpers/appveyor/install_opengl.ps1
 
+      # Install OpenMP for macOS to enable dtaidistance C extensions
+      - name: Install OpenMP on macOS
+        if: runner.os == 'macOS'
+        run: |
+          brew install libomp
+
       # note: if you need dependencies from conda, considering using
       # setup-miniconda: https://github.com/conda-incubator/setup-miniconda
       # and

pyproject.toml

@@ -36,7 +36,8 @@ dependencies = [
     "tsfresh",
     "dtaidistance",
     "napari-signal-selector>=0.0.6",
-    "cmap"
+    "cmap",
+    "packaging"
 ]
 
 [project.optional-dependencies]

src/napari_signal_classifier/_tests/test_classification.py

@@ -0,0 +1,167 @@
+import numpy as np
+import pandas as pd
+import pytest
+import tempfile
+from pathlib import Path
+
+from napari_signal_classifier._classification import (
+    split_table_train_test, train_signal_classifier, predict_signal_labels,
+    generate_sub_signals_table, train_sub_signal_classifier,
+    generate_sub_signal_templates_from_annotations, predict_sub_signal_labels,
+    _get_classifier_file_path
+)
+
+
+@pytest.fixture
+def sample_signal_table():
+    """Create a sample signal table for testing."""
+    np.random.seed(42)
+    n_labels = 10
+    n_frames = 20
+    
+    data = []
+    for label in range(n_labels):
+        for frame in range(n_frames):
+            # Create different patterns for different annotations
+            if label < 5:  # Class 1
+                intensity = 10 + 5 * np.sin(frame / 3) + np.random.normal(0, 0.5)
+                annotation = 1
+            else:  # Class 2
+                intensity = 15 + 3 * np.cos(frame / 2) + np.random.normal(0, 0.5)
+                annotation = 2
+            
+            data.append({
+                'label': label,
+                'frame': frame,
+                'mean_intensity': intensity,
+                'Annotations': annotation
+            })
+    
+    return pd.DataFrame(data)
+
+
+@pytest.fixture
+def sample_sub_signal_table():
+    """Create a sample table with sub-signal annotations."""
+    np.random.seed(42)
+    data = []
+    
+    for label in range(5):
+        for frame in range(30):
+            # Create sub-signals at different positions
+            if 5 <= frame < 10:
+                annotation = 1  # Sub-signal type 1
+                intensity = 20 + 3 * np.sin(frame)
+            elif 15 <= frame < 20:
+                annotation = 2  # Sub-signal type 2
+                intensity = 15 + 2 * np.cos(frame)
+            else:
+                annotation = 0  # Background
+                intensity = 10 + np.random.normal(0, 0.5)
+            
+            data.append({
+                'label': label,
+                'frame': frame,
+                'mean_intensity': intensity,
+                'Annotations': annotation
+            })
+    
+    return pd.DataFrame(data)
+
+
+def test_get_classifier_file_path():
+    """Test classifier file path generation."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Test with directory path
+        path = _get_classifier_file_path(tmpdir)
+        assert path.name == 'signal_classifier.pkl'
+        assert path.parent == Path(tmpdir)
+        
+        # Test with None
+        path = _get_classifier_file_path(None)
+        assert path.name == 'signal_classifier.pkl'
+        
+        # Test with specific file path
+        file_path = Path(tmpdir) / 'custom.pkl'
+        path = _get_classifier_file_path(str(file_path))
+        assert path == file_path
+
+
+def test_split_table_train_test(sample_signal_table):
+    """Test train/test split of signal table."""
+    train, test = split_table_train_test(
+        sample_signal_table, train_size=0.8, random_state=42
+    )
+    
+    assert len(train) > 0
+    assert len(test) > 0
+    assert len(train) + len(test) == len(sample_signal_table)
+    
+    # Check that labels are properly split
+    train_labels = train['label'].unique()
+    test_labels = test['label'].unique()
+    assert len(set(train_labels).intersection(set(test_labels))) == 0
+
+
+def test_train_signal_classifier(sample_signal_table):
+    """Test signal classifier training."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        classifier_path = train_signal_classifier(
+            sample_signal_table,
+            classifier_path=tmpdir,
+            train_size=0.6,
+            random_state=42,
+            n_estimators=10
+        )
+        
+        assert classifier_path is not None
+        assert Path(classifier_path).exists()
+
+
+def test_predict_signal_labels(sample_signal_table):
+    """Test signal label prediction."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Train classifier
+        classifier_path = train_signal_classifier(
+            sample_signal_table,
+            classifier_path=tmpdir,
+            train_size=0.6,
+            random_state=42,
+            n_estimators=10
+        )
+        
+        # Predict
+        result_table = predict_signal_labels(
+            sample_signal_table,
+            classifier_path
+        )
+        
+        assert 'Predictions' in result_table.columns
+        assert result_table['Predictions'].dtype == int
+        assert len(result_table) == len(sample_signal_table)
+
+
+def test_train_sub_signal_classifier(sample_sub_signal_table):
+    """Test sub-signal classifier training."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        classifier_path = train_sub_signal_classifier(
+            sample_sub_signal_table,
+            classifier_path=tmpdir,
+            train_size=0.6,
+            random_state=42,
+            n_estimators=10
+        )
+        
+        assert classifier_path is not None
+        assert Path(classifier_path).exists()
+
+
+def test_generate_sub_signal_templates_from_annotations(sample_sub_signal_table):
+    """Test sub-signal template generation."""
+    templates = generate_sub_signal_templates_from_annotations(
+        sample_sub_signal_table
+    )
+    
+    assert isinstance(templates, dict)
+    assert len(templates) > 0
+    assert all(isinstance(v, np.ndarray) for v in templates.values())

src/napari_signal_classifier/_tests/test_detection.py

@@ -0,0 +1,125 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+from napari_signal_classifier._detection import (
+    normalize, align_signals, generate_template_mean, generate_templates_by_category,
+    detect_sub_signal_by_template, extract_sub_signals_by_templates
+)
+from napari_signal_classifier._sub_signals import SubSignalCollection
+
+
+@pytest.fixture
+def sample_sub_signal_table():
+    """Create a sample table with sub-signal annotations."""
+    np.random.seed(42)
+    data = []
+    
+    for label in range(5):
+        for frame in range(30):
+            # Create sub-signals at different positions
+            if 5 <= frame < 10:
+                annotation = 1  # Sub-signal type 1
+                intensity = 20 + 3 * np.sin(frame)
+            elif 15 <= frame < 20:
+                annotation = 2  # Sub-signal type 2
+                intensity = 15 + 2 * np.cos(frame)
+            else:
+                annotation = 0  # Background
+                intensity = 10 + np.random.normal(0, 0.5)
+            
+            data.append({
+                'label': label,
+                'frame': frame,
+                'mean_intensity': intensity,
+                'Annotations': annotation
+            })
+    
+    return pd.DataFrame(data)
+
+
+def test_normalize():
+    """Test signal normalization."""
+    signal = np.array([1, 2, 3, 4, 5])
+    
+    # Test z-score normalization
+    normalized_z = normalize(signal, method='zscores')
+    assert np.isclose(np.mean(normalized_z), 0, atol=1e-10)
+    assert np.isclose(np.std(normalized_z), 1, atol=1e-10)
+    
+    # Test min-max normalization
+    normalized_mm = normalize(signal, method='minmax')
+    assert np.isclose(np.min(normalized_mm), 0)
+    assert np.isclose(np.max(normalized_mm), 1)
+    
+    # Test invalid method
+    with pytest.raises(ValueError):
+        normalize(signal, method='invalid')
+
+
+def test_align_signals():
+    """Test signal alignment using DTW."""
+    reference = np.sin(np.linspace(0, 2*np.pi, 50))
+    signal = np.sin(np.linspace(0, 2*np.pi, 50) + 0.1)  # Slightly shifted
+    
+    aligned = align_signals(reference, signal, detrend=False)
+    
+    assert len(aligned) == len(reference)
+    assert isinstance(aligned, np.ndarray)
+
+
+def test_generate_template_mean():
+    """Test template generation from replicates."""
+    # Create similar signals with slight variations
+    replicates = [
+        np.sin(np.linspace(0, 2*np.pi, 50)) + np.random.normal(0, 0.1, 50)
+        for _ in range(5)
+    ]
+    
+    template = generate_template_mean(replicates, detrend=False)
+    
+    assert len(template) == len(replicates[0])
+    assert isinstance(template, np.ndarray)
+
+
+def test_detect_sub_signal_by_template():
+    """Test sub-signal detection using template matching."""
+    # Create a composite signal with a known pattern
+    template = np.sin(np.linspace(0, 2*np.pi, 20))
+    composite = np.concatenate([
+        np.random.normal(0, 0.5, 30),
+        template,
+        np.random.normal(0, 0.5, 30),
+        template,
+        np.random.normal(0, 0.5, 30)
+    ])
+    
+    peaks = detect_sub_signal_by_template(
+        composite, template, threshold=0.5
+    )
+    
+    assert len(peaks) >= 2  # Should detect at least 2 peaks
+    assert isinstance(peaks, np.ndarray)
+
+
+def test_extract_sub_signals_by_templates(sample_sub_signal_table):
+    """Test sub-signal extraction using templates."""
+    from napari_signal_classifier._classification import generate_sub_signal_templates_from_annotations
+    
+    # Generate templates first
+    templates = generate_sub_signal_templates_from_annotations(
+        sample_sub_signal_table
+    )
+    
+    # Extract sub-signals
+    collection = extract_sub_signals_by_templates(
+        sample_sub_signal_table,
+        'mean_intensity',
+        'label',
+        'frame',
+        templates,
+        threshold=0.5
+    )
+    
+    assert isinstance(collection, SubSignalCollection)
+    assert len(collection.sub_signals) > 0

src/napari_signal_classifier/_tests/test_features.py

@@ -0,0 +1,47 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+from napari_signal_classifier._features import get_signal_features
+
+
+@pytest.fixture
+def sample_signal_table():
+    """Create a sample signal table for testing."""
+    np.random.seed(42)
+    n_labels = 10
+    n_frames = 20
+    
+    data = []
+    for label in range(n_labels):
+        for frame in range(n_frames):
+            # Create different patterns for different annotations
+            if label < 5:  # Class 1
+                intensity = 10 + 5 * np.sin(frame / 3) + np.random.normal(0, 0.5)
+                annotation = 1
+            else:  # Class 2
+                intensity = 15 + 3 * np.cos(frame / 2) + np.random.normal(0, 0.5)
+                annotation = 2
+            
+            data.append({
+                'label': label,
+                'frame': frame,
+                'mean_intensity': intensity,
+                'Annotations': annotation
+            })
+    
+    return pd.DataFrame(data)
+
+
+def test_get_signal_features(sample_signal_table):
+    """Test signal feature extraction."""
+    features = get_signal_features(
+        sample_signal_table,
+        column_id='label',
+        column_sort='frame',
+        column_value='mean_intensity'
+    )
+    
+    assert isinstance(features, pd.DataFrame)
+    assert len(features) == len(sample_signal_table['label'].unique())
+    assert features.shape[1] > 0  # Should have multiple feature columns