tra-algorithm 1.0.0__py3-none-any.whl

tests/test_core.py

@@ -0,0 +1,145 @@
+"""
+Unit tests for TRA algorithm core functionality.
+"""
+import unittest
+import numpy as np
+from sklearn.datasets import make_classification, make_regression
+from sklearn.model_selection import train_test_split
+
+from tra_algorithm.core import OptimizedTRA
+
+
+class TestOptimizedTRA(unittest.TestCase):
+    """Test cases for OptimizedTRA class."""
+    
+    def setUp(self):
+        """Set up test fixtures."""
+        # Classification dataset
+        self.X_clf, self.y_clf = make_classification(
+            n_samples=200, n_features=10, n_classes=3, n_informative=3, random_state=42
+        )
+        self.X_train_clf, self.X_test_clf, self.y_train_clf, self.y_test_clf = \
+            train_test_split(self.X_clf, self.y_clf, test_size=0.3, random_state=42)
+        
+        # Regression dataset
+        self.X_reg, self.y_reg = make_regression(
+            n_samples=200, n_features=10, random_state=42
+        )
+        self.X_train_reg, self.X_test_reg, self.y_train_reg, self.y_test_reg = \
+            train_test_split(self.X_reg, self.y_reg, test_size=0.3, random_state=42)
+    
+    def test_classification_basic(self):
+        """Test basic classification functionality."""
+        tra = OptimizedTRA(task_type="classification", n_tracks=3, random_state=42)
+        tra.fit(self.X_train_clf, self.y_train_clf)
+        
+        # Test predictions
+        y_pred = tra.predict(self.X_test_clf)
+        self.assertEqual(len(y_pred), len(self.y_test_clf))
+        
+        # Test probability predictions
+        y_proba = tra.predict_proba(self.X_test_clf)
+        self.assertEqual(y_proba.shape[0], len(self.y_test_clf))
+        self.assertEqual(y_proba.shape[1], len(np.unique(self.y_clf)))
+        
+        # Test scoring
+        score = tra.score(self.X_test_clf, self.y_test_clf)
+        self.assertIsInstance(score, float)
+        self.assertGreaterEqual(score, 0.0)
+        self.assertLessEqual(score, 1.0)
+    
+    def test_regression_basic(self):
+        """Test basic regression functionality."""
+        tra = OptimizedTRA(task_type="regression", n_tracks=3, random_state=42)
+        tra.fit(self.X_train_reg, self.y_train_reg)
+        
+        # Test predictions
+        y_pred = tra.predict(self.X_test_reg)
+        self.assertEqual(len(y_pred), len(self.y_test_reg))
+        
+        # Test scoring (negative MSE)
+        score = tra.score(self.X_test_reg, self.y_test_reg)
+        self.assertIsInstance(score, float)
+        self.assertLessEqual(score, 0.0)  # Negative MSE
+    
+    def test_invalid_task_type(self):
+        """Test invalid task type handling."""
+        with self.assertRaises(ValueError):
+            tra = OptimizedTRA(task_type="invalid")
+            tra.fit(self.X_train_clf, self.y_train_clf)
+    
+    def test_predict_proba_regression_error(self):
+        """Test that predict_proba raises error for regression."""
+        tra = OptimizedTRA(task_type="regression", random_state=42)
+        tra.fit(self.X_train_reg, self.y_train_reg)
+        
+        with self.assertRaises(ValueError):
+            tra.predict_proba(self.X_test_reg)
+    
+    def test_feature_selection(self):
+        """Test feature selection functionality."""
+        tra = OptimizedTRA(
+            task_type="classification", 
+            feature_selection=True, 
+            random_state=42
+        )
+        tra.fit(self.X_train_clf, self.y_train_clf)
+        
+        # Check that feature selector was created
+        self.assertIsNotNone(tra.feature_selector_)
+        
+        # Test predictions work with feature selection
+        y_pred = tra.predict(self.X_test_clf)
+        self.assertEqual(len(y_pred), len(self.y_test_clf))
+    
+    def test_statistics_generation(self):
+        """Test statistics generation."""
+        tra = OptimizedTRA(task_type="classification", random_state=42)
+        tra.fit(self.X_train_clf, self.y_train_clf)
+        tra.predict(self.X_test_clf[:10])  # Make some predictions
+        
+        stats = tra.get_track_statistics()
+        
+        # Check required keys
+        required_keys = ['n_tracks', 'n_signals', 'total_predictions', 'track_details']
+        for key in required_keys:
+            self.assertIn(key, stats)
+        
+        # Check track details
+        self.assertGreater(stats['n_tracks'], 0)
+        self.assertGreaterEqual(stats['total_predictions'], 0)
+    
+    def test_performance_report(self):
+        """Test performance report generation."""
+        tra = OptimizedTRA(task_type="classification", random_state=42)
+        tra.fit(self.X_train_clf, self.y_train_clf)
+        
+        report = tra.get_performance_report()
+        self.assertIsInstance(report, str)
+        self.assertIn("PERFORMANCE REPORT", report)
+        self.assertIn("TRACK PERFORMANCE DETAILS", report)
+
+
+class TestUtils(unittest.TestCase):
+    """Test utility functions."""
+    
+    def test_example_dataset_creation(self):
+        """Test example dataset creation."""
+        # Classification dataset
+        X_clf, y_clf = OptimizedTRA.create_example_dataset(
+            task_type="classification", n_samples=100, n_features=5
+        )
+        self.assertEqual(X_clf.shape, (100, 5))
+        self.assertEqual(len(y_clf), 100)
+        self.assertGreater(len(np.unique(y_clf)), 1)
+        
+        # Regression dataset
+        X_reg, y_reg = OptimizedTRA.create_example_dataset(
+            task_type="regression", n_samples=150, n_features=8
+        )
+        self.assertEqual(X_reg.shape, (150, 8))
+        self.assertEqual(len(y_reg), 150)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_utils.py

@@ -0,0 +1,80 @@
+"""
+Unit tests for utility functions.
+"""
+import unittest
+import numpy as np
+import tempfile
+import os
+
+from tra_algorithm.core import OptimizedTRA
+from tra_algorithm.utils import validate_input, format_performance_metrics
+
+
+class TestUtilityFunctions(unittest.TestCase):
+    """Test utility functions."""
+    
+    def test_validate_input(self):
+        """Test input validation function."""
+        # Valid inputs
+        X_valid = np.array([[1, 2], [3, 4], [5, 6]])
+        y_valid = np.array([0, 1, 0])
+        
+        X_validated, y_validated = validate_input(X_valid, y_valid)
+        np.testing.assert_array_equal(X_validated, X_valid)
+        np.testing.assert_array_equal(y_validated, y_valid)
+        
+        # Invalid inputs
+        with self.assertRaises(ValueError):
+            validate_input(None, y_valid)
+        
+        with self.assertRaises(ValueError):
+            validate_input(X_valid, None)
+        
+        # Mismatched shapes
+        X_mismatch = np.array([[1, 2]])
+        with self.assertRaises(ValueError):
+            validate_input(X_mismatch, y_valid)
+    
+    def test_format_performance_metrics(self):
+        """Test performance metrics formatting."""
+        metrics = {
+            'accuracy': 0.8567,
+            'f1_score': 0.7234,
+            'precision': 0.9012
+        }
+        
+        formatted = format_performance_metrics(metrics)
+        self.assertIsInstance(formatted, str)
+        self.assertIn('accuracy', formatted.lower())
+        self.assertIn('0.857', formatted)  # Rounded to 3 decimal places
+    
+    def test_model_save_load_integration(self):
+        """Test model save/load functionality."""
+        # Create and train a simple model
+        X, y = OptimizedTRA.create_example_dataset(
+            task_type="classification", n_samples=50
+        )
+        
+        tra = OptimizedTRA(task_type="classification", n_tracks=2, random_state=42)
+        tra.fit(X, y)
+        
+        # Test saving and loading (Windows-safe)
+        tmp = tempfile.NamedTemporaryFile(suffix='.joblib', delete=False)
+        tmp_path = tmp.name
+        tmp.close()  # Close so joblib can use it
+        try:
+            tra.save_model(tmp_path)
+            loaded_tra = OptimizedTRA.load_model(tmp_path)
+            
+            # Test that loaded model works
+            y_pred_original = tra.predict(X[:10])
+            y_pred_loaded = loaded_tra.predict(X[:10])
+            
+            np.testing.assert_array_equal(y_pred_original, y_pred_loaded)
+            
+        finally:
+            os.unlink(tmp_path)
+
+
+if __name__ == '__main__':
+    unittest.main()

tra_algorithm/__init__.py

@@ -0,0 +1,98 @@
+"""
+TRA Algorithm Package
+====================
+
+Track/Rail Algorithm (TRA) - A novel machine learning algorithm for dynamic model selection.
+
+The TRA algorithm uses multiple "tracks" (models) and "signals" (switching conditions) to
+dynamically route data through the most appropriate model, providing improved performance
+for both classification and regression tasks.
+
+Example Usage:
+-------------
+    from tra_algorithm import OptimizedTRA
+    from sklearn.datasets import make_classification
+    from sklearn.model_selection import train_test_split
+    
+    # Create dataset
+    X, y = make_classification(n_samples=1000, n_features=20, n_classes=3)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
+    
+    # Initialize and train TRA
+    tra = OptimizedTRA(task_type="classification", n_tracks=3)
+    tra.fit(X_train, y_train)
+    
+    # Make predictions
+    y_pred = tra.predict(X_test)
+    
+    # Get performance report
+    print(tra.get_performance_report())
+
+Classes:
+--------
+    OptimizedTRA: Main TRA algorithm implementation
+    Track: Individual model track
+    Signal: Track switching signal
+    Record: Data record for tracking
+    EnhancedSignalCondition: Advanced signal logic
+    
+Utilities:
+----------
+    create_example_dataset: Generate sample datasets for testing
+    evaluate_model_performance: Model evaluation utilities
+    plot_learning_curves: Learning curve visualization
+    compare_with_baselines: Baseline model comparison
+    
+Examples:
+---------
+    basic_classification_example, basic_regression_example, model_comparison_example
+"""
+
+from .version import __version__
+from .core import (
+    OptimizedTRA,
+    Track,
+    Signal,
+    Record,
+    EnhancedSignalCondition
+)
+from .utils import (
+    create_example_dataset,
+    evaluate_model_performance,
+    plot_learning_curves,
+    compare_with_baselines
+)
+from .examples import (
+    basic_classification_example,
+    basic_regression_example,
+    model_comparison_example
+)
+
+__all__ = [
+    # Main classes
+    'OptimizedTRA',
+    'Track',
+    'Signal', 
+    'Record',
+    'EnhancedSignalCondition',
+    
+    # Utilities
+    'create_example_dataset',
+    'evaluate_model_performance',
+    'plot_learning_curves',
+    'compare_with_baselines',
+    
+    # Examples
+    'basic_classification_example',
+    'basic_regression_example', 
+    'model_comparison_example',
+    
+    # Version
+    '__version__',
+]
+
+# Package metadata
+__author__ = "TRA Algorithm Team"
+__email__ = "contact@tra-algorithm.com"
+__license__ = "MIT"
+__description__ = "Track/Rail Algorithm (TRA) - A novel machine learning algorithm for dynamic model selection"