featrixsphere 0.2.6127__tar.gz → 0.2.6379__tar.gz

{featrixsphere-0.2.6127 → featrixsphere-0.2.6379}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: featrixsphere
-Version: 0.2.6127
+Version: 0.2.6379
 Summary: Transform any CSV into a production-ready ML model in minutes, not months.
 Home-page: https://github.com/Featrix/sphere
 Author: Featrix

featrixsphere-0.2.6379/VERSION

@@ -0,0 +1 @@
+0.2.6379

{featrixsphere-0.2.6127 → featrixsphere-0.2.6379}/featrixsphere/__init__.py

@@ -57,7 +57,7 @@ TWO API OPTIONS:
     >>> print(result['prediction'])
 """
 
-__version__ = "0.2.6127"
+__version__ = "0.2.6379"
 __author__ = "Featrix"
 __email__ = "support@featrix.com"
 __license__ = "MIT"

{featrixsphere-0.2.6127 → featrixsphere-0.2.6379}/featrixsphere/client.py

@@ -137,22 +137,24 @@ class SessionInfo:
 class PredictionBatch:
     """
     Cached prediction batch that allows instant lookups after initial batch processing.
-    
+
     Usage:
         # First run - populate cache
         batch = client.predict_batch(session_id, records)
-        
+
         # Second run - instant cache lookups
         for i in values1:
             for j in values2:
                 record = {"param1": i, "param2": j}
                 result = batch.predict(record)  # Instant!
     """
-    
-    def __init__(self, session_id: str, client: 'FeatrixSphereClient', target_column: str = None):
+
+    def __init__(self, session_id: str, client: 'FeatrixSphereClient', target_column: str = None,
+                 best_metric_preference: str = None):
         self.session_id = session_id
         self.client = client
         self.target_column = target_column
+        self.best_metric_preference = best_metric_preference
         self._cache = {}  # record_hash -> prediction_result
         self._stats = {'hits': 0, 'misses': 0, 'populated': 0}
         
@@ -203,14 +205,15 @@ class PredictionBatch:
         """Populate the cache with batch predictions."""
         if not records:
             return {'summary': {'total_records': 0, 'successful': 0, 'failed': 0}}
-        
+
         print(f"🚀 Creating prediction batch for {len(records)} records...")
-        
+
         # Use existing batch prediction system
         batch_results = self.client.predict_records(
             session_id=self.session_id,
             records=records,
             target_column=self.target_column,
+            best_metric_preference=self.best_metric_preference,
             show_progress_bar=True
         )
         
@@ -7744,23 +7747,25 @@ class FeatrixSphereClient:
         else:
             return data
     
-    def predict_csv_file(self, session_id: str, file_path: Path) -> Dict[str, Any]:
+    def predict_csv_file(self, session_id: str, file_path: Path,
+                          best_metric_preference: str = None) -> Dict[str, Any]:
         """
         Make batch predictions on a CSV file.
-        
+
         Args:
             session_id: ID of session with trained predictor
             file_path: Path to CSV file
-            
+            best_metric_preference: Which metric checkpoint to use: "roc_auc", "pr_auc", or None (default)
+
         Returns:
             Batch prediction results
         """
         import pandas as pd
         from jsontables import JSONTablesEncoder
-        
+
         if not file_path.exists():
             raise FileNotFoundError(f"File not found: {file_path}")
-        
+
         # Support CSV, Parquet, JSON, and JSONL files
         file_path_str = str(file_path).lower()
         if file_path_str.endswith('.parquet'):
@@ -7779,29 +7784,31 @@ class FeatrixSphereClient:
             df = pd.read_json(file_path)
         else:
             df = pd.read_csv(file_path)
-        
+
         # Convert to JSON Tables format and clean NaNs
         table_data = JSONTablesEncoder.from_dataframe(df)
         cleaned_table_data = self.replace_nans_with_nulls(table_data)
-        
-        return self.predict_table(session_id, cleaned_table_data)
 
-    def run_predictions(self, session_id: str, records: List[Dict[str, Any]]) -> Dict[str, Any]:
+        return self.predict_table(session_id, cleaned_table_data, best_metric_preference=best_metric_preference)
+
+    def run_predictions(self, session_id: str, records: List[Dict[str, Any]],
+                         best_metric_preference: str = None) -> Dict[str, Any]:
         """
         Run predictions on provided records. Clean and fast for production use.
-        
+
         Args:
             session_id: ID of session with trained predictor
             records: List of record dictionaries
-            
+            best_metric_preference: Which metric checkpoint to use: "roc_auc", "pr_auc", or None (default)
+
         Returns:
             Dictionary with prediction results
         """
         # Clean NaNs for JSON encoding
         cleaned_records = self.replace_nans_with_nulls(records)
-        
+
         # Make batch predictions
-        batch_results = self.predict_records(session_id, cleaned_records)
+        batch_results = self.predict_records(session_id, cleaned_records, best_metric_preference=best_metric_preference)
         predictions = batch_results['predictions']
         
         # Process predictions into clean format
@@ -8517,32 +8524,33 @@ class FeatrixSphereClient:
         
         return cleared_counts
 
-    def predict_batch(self, session_id: str, records: List[Dict[str, Any]], 
-                     target_column: str = None) -> PredictionBatch:
+    def predict_batch(self, session_id: str, records: List[Dict[str, Any]],
+                       target_column: str = None, best_metric_preference: str = None) -> PredictionBatch:
         """
         Create a prediction batch for instant cached lookups.
-        
+
         Perfect for parameter sweeps, grid searches, and exploring prediction surfaces.
         Run your loops twice with identical code - first populates cache, second gets instant results.
-        
+
         Args:
             session_id: ID of session with trained predictor
             records: List of all records you'll want to predict on
             target_column: Specific target column predictor to use
-            
+            best_metric_preference: Which metric checkpoint to use: "roc_auc", "pr_auc", or None (default)
+
         Returns:
             PredictionBatch object with instant predict() method
-            
+
         Example:
             # Generate all combinations you'll need
             records = []
             for i in range(10):
                 for j in range(10):
                     records.append({"param1": i, "param2": j})
-            
+
             # First run - populate cache with batch processing
             batch = client.predict_batch(session_id, records)
-            
+
             # Second run - same loops but instant cache lookups
             results = []
             for i in range(10):
@@ -8552,50 +8560,52 @@ class FeatrixSphereClient:
                     results.append(result)
         """
         # Create batch object
-        batch = PredictionBatch(session_id, self, target_column)
-        
+        batch = PredictionBatch(session_id, self, target_column, best_metric_preference)
+
         # Populate cache with batch predictions
         batch._populate_cache(records)
-        
+
         return batch
 
-    def predict_grid(self, session_id: str, degrees_of_freedom: int, 
-                    grid_shape: tuple = None, target_column: str = None) -> 'PredictionGrid':
+    def predict_grid(self, session_id: str, degrees_of_freedom: int,
+                      grid_shape: tuple = None, target_column: str = None,
+                      best_metric_preference: str = None) -> 'PredictionGrid':
         """
         Create a prediction grid for exploring parameter surfaces with automatic visualization.
-        
+
         Perfect for 1D curves, 2D heatmaps, and 3D surfaces with built-in plotting functions.
-        
+
         Args:
             session_id: ID of session with trained predictor
             degrees_of_freedom: Number of dimensions (1, 2, or 3)
             grid_shape: Custom grid shape tuple (default: auto-sized)
             target_column: Specific target column predictor to use
-            
+            best_metric_preference: Which metric checkpoint to use: "roc_auc", "pr_auc", or None (default)
+
         Returns:
             PredictionGrid object with predict() and plotting methods
-            
+
         Example:
             # 2D parameter sweep with automatic plotting
             grid = client.predict_grid(session_id, degrees_of_freedom=2)
             grid.set_axis_labels(["Spend", "Campaign Type"])
             grid.set_axis_values(0, [100, 250, 500])
             grid.set_axis_values(1, ["search", "display", "social"])
-            
+
             for i, spend in enumerate([100, 250, 500]):
                 for j, campaign in enumerate(["search", "display", "social"]):
                     record = {"spend": spend, "campaign_type": campaign}
                     grid.predict(record, grid_position=(i, j))
-            
+
             # Automatic visualization
             grid.plot_heatmap()  # 2D heatmap
             grid.plot_3d()       # 3D surface
-            
+
             # Find optimal parameters
             optimal_pos = grid.get_optimal_position()
             print(f"Optimal parameters at grid position: {optimal_pos}")
         """
-        return PredictionGrid(session_id, self, degrees_of_freedom, grid_shape, target_column)
+        return PredictionGrid(session_id, self, degrees_of_freedom, grid_shape, target_column, best_metric_preference)
 
     def get_embedding_space_columns(self, session_id: str) -> Dict[str, Any]:
         """
@@ -8672,12 +8682,13 @@ class PredictionGrid:
         grid.plot_3d()       # 3D surface plot
     """
     
-    def __init__(self, session_id: str, client: 'FeatrixSphereClient', degrees_of_freedom: int, 
-                 grid_shape: tuple = None, target_column: str = None):
+    def __init__(self, session_id: str, client: 'FeatrixSphereClient', degrees_of_freedom: int,
+                 grid_shape: tuple = None, target_column: str = None, best_metric_preference: str = None):
         self.session_id = session_id
         self.client = client
         self.degrees_of_freedom = degrees_of_freedom
         self.target_column = target_column
+        self.best_metric_preference = best_metric_preference
         
         # Initialize grid matrix based on degrees of freedom
         if grid_shape:
@@ -8769,6 +8780,7 @@ class PredictionGrid:
                 session_id=self.session_id,
                 records=records_list,
                 target_column=self.target_column,
+                best_metric_preference=self.best_metric_preference,
                 show_progress_bar=show_progress
             )
             

{featrixsphere-0.2.6127 → featrixsphere-0.2.6379}/featrixsphere.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: featrixsphere
-Version: 0.2.6127
+Version: 0.2.6379
 Summary: Transform any CSV into a production-ready ML model in minutes, not months.
 Home-page: https://github.com/Featrix/sphere
 Author: Featrix

{featrixsphere-0.2.6127 → featrixsphere-0.2.6379}/featrixsphere.egg-info/SOURCES.txt

@@ -112,6 +112,7 @@ src/lib/vector_db.py
 src/lib/webhook_helpers.py
 src/lib/weightwatcher_tracking.py
 src/lib/featrix/__init__.py
+src/lib/featrix/auto_calibrate.py
 src/lib/featrix/download-data/build_geo_weather_db.py
 src/lib/featrix/download-data/download_geographic_data.py
 src/lib/featrix/download-data/download_road_data.py
@@ -119,6 +120,7 @@ src/lib/featrix/download-data/download_weather_data.py
 src/lib/featrix/download-data/install-data.sh
 src/lib/featrix/neural/__init__.py
 src/lib/featrix/neural/adaptive_event_log.py
+src/lib/featrix/neural/auc_animation.py
 src/lib/featrix/neural/calibration_utils.py
 src/lib/featrix/neural/causal_relationship_scorer.py
 src/lib/featrix/neural/charting.py
@@ -129,12 +131,14 @@ src/lib/featrix/neural/curve_plots_example.py
 src/lib/featrix/neural/customer_quality_tracker.py
 src/lib/featrix/neural/data_frame_data_set.py
 src/lib/featrix/neural/dataloader_utils.py
+src/lib/featrix/neural/default_training_rules.py
 src/lib/featrix/neural/detect.py
 src/lib/featrix/neural/dimension_validator.py
 src/lib/featrix/neural/domain_codec.py
 src/lib/featrix/neural/dropout_scheduler.py
 src/lib/featrix/neural/duration_ops.py
 src/lib/featrix/neural/dynamic_relationship_extractor.py
+src/lib/featrix/neural/email_codec.py
 src/lib/featrix/neural/email_domain_ops.py
 src/lib/featrix/neural/embedded_space.py
 src/lib/featrix/neural/embedding_lr_scheduler.py
@@ -144,6 +148,7 @@ src/lib/featrix/neural/embedding_utils.py
 src/lib/featrix/neural/encoders.py
 src/lib/featrix/neural/enrich.py
 src/lib/featrix/neural/es_projection.py
+src/lib/featrix/neural/es_training_callbacks.py
 src/lib/featrix/neural/exceptions.py
 src/lib/featrix/neural/featrix_csv.py
 src/lib/featrix/neural/featrix_json.py
@@ -172,8 +177,10 @@ src/lib/featrix/neural/io_utils.py
 src/lib/featrix/neural/ip_address_ops.py
 src/lib/featrix/neural/json_cache.py
 src/lib/featrix/neural/json_codec.py
+src/lib/featrix/neural/junction_adapter.py
 src/lib/featrix/neural/local_string_cache.py
 src/lib/featrix/neural/logging_config.py
+src/lib/featrix/neural/loss_framework.py
 src/lib/featrix/neural/loss_short_embedding.py
 src/lib/featrix/neural/lr_timeline.py
 src/lib/featrix/neural/mask_bias_tracker.py
@@ -188,7 +195,6 @@ src/lib/featrix/neural/pair_scorer.py
 src/lib/featrix/neural/per_epoch_quality.py
 src/lib/featrix/neural/platform_utils.py
 src/lib/featrix/neural/prng_control.py
-src/lib/featrix/neural/random_utils.py
 src/lib/featrix/neural/relationship_complexity.py
 src/lib/featrix/neural/relationship_estimator.py
 src/lib/featrix/neural/relationship_extractor.py
@@ -232,6 +238,7 @@ src/lib/featrix/neural/training_exceptions.py
 src/lib/featrix/neural/training_history_db.py
 src/lib/featrix/neural/training_logger.py
 src/lib/featrix/neural/training_movie_writer.py
+src/lib/featrix/neural/training_rules.py
 src/lib/featrix/neural/training_timeline.py
 src/lib/featrix/neural/transformer_encoder.py
 src/lib/featrix/neural/type_aware_ops_config.py
@@ -247,6 +254,11 @@ src/lib/featrix/neural/world_data.py
 src/lib/featrix/neural/xgboost_classifier.py
 src/lib/featrix/neural/llm/__init__.py
 src/lib/featrix/neural/llm/schema_analyzer.py
+src/lib/featrix/neural/loss_functions/__init__.py
+src/lib/featrix/neural/loss_functions/list_versions.py
+src/lib/featrix/neural/loss_functions/loss_functions_01Jan2026.py
+src/lib/featrix/neural/loss_functions/loss_functions_01Jul2025.py
+src/lib/featrix/neural/loss_functions/loss_functions_21Jan2026.py
 src/lib/featrix/neural/qa/demo_advisor_decisions.py
 src/lib/featrix/neural/qa/example_complete_workflow.py
 src/lib/featrix/neural/qa/generate_focal_report.py
@@ -254,7 +266,9 @@ src/lib/featrix/neural/qa/model_advisor.py
 src/lib/featrix/neural/qa/show_results.py
 src/lib/featrix/neural/qa/test_adaptive_loss_benchmark.py
 src/lib/featrix/neural/qa/test_adaptive_training.py
+src/lib/featrix/neural/qa/test_all_codecs.py
 src/lib/featrix/neural/qa/test_checkpoint_dict_reconstruction.py
+src/lib/featrix/neural/qa/test_cls_vs_mean_pooling.py
 src/lib/featrix/neural/qa/test_confusion_matrix_metadata.py
 src/lib/featrix/neural/qa/test_data_timestamps.py
 src/lib/featrix/neural/qa/test_embedding_quality.py
@@ -284,4 +298,5 @@ src/lib/featrix/neural/qa/test_training_monitor.py
 src/lib/featrix/neural/qa/test_warning_tracking.py
 src/lib/featrix/neural/qa/visualize_training_timeline.py
 src/lib/featrix/neural/tools/__init__.py
-src/lib/featrix/neural/tools/compare_clusters.py
+src/lib/featrix/neural/tools/compare_clusters.py
+tests/test_foundation_mode_local.py

{featrixsphere-0.2.6127 → featrixsphere-0.2.6379}/src/api.py

@@ -3031,10 +3031,11 @@ def create_app() -> FastAPI:
                 predictor_dir = Path(predictor_path).parent
                 if predictor_dir.exists():
                     # Look for best checkpoint files
+                    # Filename format: {timestamp}_best_single_predictor_auc_roc_{value}_epoch_{N}.pickle
                     if best_metric_preference.lower() in ['roc_auc', 'roc-auc', 'auc']:
                         # Look for ROC-AUC best checkpoint
                         roc_auc_checkpoints = sorted(
-                            predictor_dir.glob("best_single_predictor_roc_auc*.pickle"),
+                            predictor_dir.glob("*best_single_predictor_auc_roc*.pickle"),
                             key=lambda p: p.stat().st_mtime,
                             reverse=True
                         )
@@ -3046,7 +3047,7 @@ def create_app() -> FastAPI:
                     elif best_metric_preference.lower() in ['pr_auc', 'pr-auc', 'precision_recall']:
                         # Look for PR-AUC best checkpoint
                         pr_auc_checkpoints = sorted(
-                            predictor_dir.glob("best_single_predictor_pr_auc*.pickle"),
+                            predictor_dir.glob("*best_single_predictor_auc_pr*.pickle"),
                             key=lambda p: p.stat().st_mtime,
                             reverse=True
                         )

{featrixsphere-0.2.6127 → featrixsphere-0.2.6379}/src/celery_app.py

@@ -2123,9 +2123,10 @@ def create_structured_data(self, job_spec: dict, job_id: str, data_file: str = N
                 logger.info(f"📊 Processing data file (reading, parsing, cleaning, expanding JSON columns, writing to SQLite)...")
                 logger.info(f"   This may take a while for large files - watch for progress updates below...")
 
-                # Check if we should use foundation mode (large datasets >= 100k rows)
+                # Check if we should use foundation mode (large datasets >= 50k rows)
                 # Foundation mode creates train/validation/test/warmup splits directly in SQLite
-                FOUNDATION_THRESHOLD = 100_000
+                # This enables chunked iteration, SQLite-backed splits, and better memory efficiency
+                FOUNDATION_THRESHOLD = 50_000
                 foundation_mode_setting = job_spec.get("foundation_mode")  # None = auto-detect, True = force, False = disable
                 use_foundation_mode = foundation_mode_setting is True  # Explicitly True means force it
 

{featrixsphere-0.2.6127 → featrixsphere-0.2.6379}/src/lib/celery_job_recovery.py

@@ -6,11 +6,12 @@ This replaces the old file-based worker recovery mechanism.
 """
 import json
 import logging
+import os
 import time
 import traceback
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Tuple
 from zoneinfo import ZoneInfo
 
 import redis
@@ -30,6 +31,92 @@ logger = logging.getLogger(__name__)
 CANCELLED_JOBS_DIR = Path("/tmp/featrix_cancelled_jobs")
 
 
+def _check_running_job_state(job: dict) -> Tuple[str, bool, Optional[str]]:
+    """
+    Check the actual state of a RUNNING job by examining:
+    1. Control files (ABORT, PAUSE, CRASH, FAILURE)
+    2. PID from .job.lock file (is process still alive?)
+
+    Returns:
+        (state, should_recover, reason)
+
+    States and actions:
+    - "running_will_abort" - ABORT file exists, process running → don't recover, will finish soon
+    - "running_paused" - PAUSE file exists, process running → don't recover, paused
+    - "running_healthy" - process running, no control files → don't recover
+    - "dead_aborted" - ABORT file exists, process dead → mark FAILED, don't recover
+    - "dead_crashed" - CRASH/FAILURE file exists, process dead → mark FAILED, don't recover
+    - "dead_needs_recovery" - process dead, no markers → needs recovery
+    - "unknown" - can't determine (no job dir, etc.) → recover to be safe
+    """
+    job_id = job.get('job_id')
+    job_type = job.get('job_type')
+    session_id = job.get('session_id')
+
+    # Get job output directory
+    try:
+        job_output_dir = get_job_output_path(job_id, session_id=session_id, job_type=job_type)
+        if not job_output_dir or not job_output_dir.exists():
+            return ("unknown", True, "job output directory not found")
+    except Exception as e:
+        logger.debug(f"Could not get job output path for {job_id}: {e}")
+        return ("unknown", True, f"could not get job output path: {e}")
+
+    # Check for control files
+    abort_file = job_output_dir / "ABORT"
+    pause_file = job_output_dir / "PAUSE"
+    crash_file = job_output_dir / "CRASH.log"
+    failure_file = job_output_dir / "FAILURE"
+
+    has_abort = abort_file.exists()
+    has_pause = pause_file.exists()
+    has_crash = crash_file.exists()
+    has_failure = failure_file.exists()
+
+    # Check if process is still running via .job.lock file
+    lock_file = job_output_dir / ".job.lock"
+    pid = None
+    process_running = False
+
+    if lock_file.exists():
+        try:
+            lock_content = lock_file.read_text()
+            for line in lock_content.split('\n'):
+                if line.startswith('pid:'):
+                    pid = int(line.split(':', 1)[1].strip())
+                    break
+
+            if pid:
+                # Check if process is still running
+                try:
+                    os.kill(pid, 0)  # Signal 0 just checks if process exists
+                    process_running = True
+                except OSError:
+                    process_running = False
+        except Exception as e:
+            logger.debug(f"Could not read lock file for job {job_id}: {e}")
+
+    # Determine state based on control files and process status
+    if process_running:
+        if has_abort:
+            return ("running_will_abort", False, f"ABORT file exists, PID {pid} still running - will finish cleanly soon")
+        elif has_pause:
+            return ("running_paused", False, f"PAUSE file exists, PID {pid} still running - paused")
+        else:
+            return ("running_healthy", False, f"PID {pid} still running - healthy")
+    else:
+        # Process is dead
+        if has_abort:
+            return ("dead_aborted", False, f"ABORT file exists, process dead - mark as FAILED")
+        elif has_crash:
+            return ("dead_crashed", False, f"CRASH.log exists, process dead - mark as FAILED")
+        elif has_failure:
+            return ("dead_failed", False, f"FAILURE file exists, process dead - mark as FAILED")
+        else:
+            pid_info = f" (was PID {pid})" if pid else ""
+            return ("dead_needs_recovery", True, f"process dead{pid_info}, no failure markers - needs recovery")
+
+
 def _mark_job_cancelled(job_id: str, replaced_by: str, reason: str) -> bool:
     """
     Mark a job as CANCELLED so it won't be picked up by recovery again.
@@ -1598,10 +1685,32 @@ def recover_interrupted_jobs() -> Dict[str, Any]:
                     logger.debug(f"⏭️  Skipping movie frame job {job_id} - movie generation disabled")
                     continue
                 
-                # Include RUNNING jobs
+                # Include RUNNING jobs - but check actual state first
                 if status == JobStatus.RUNNING.value:
-                    jobs_to_recover.append(job)
-                    logger.info(f"🔄 Found RUNNING job {job_id} (type: {job.get('job_type')})")
+                    state, should_recover, reason = _check_running_job_state(job)
+                    job_type = job.get('job_type')
+
+                    if state == "running_healthy":
+                        logger.info(f"✅ RUNNING job {job_id} (type: {job_type}) - {reason}")
+                    elif state == "running_will_abort":
+                        logger.info(f"⏳ RUNNING job {job_id} (type: {job_type}) - {reason}")
+                    elif state == "running_paused":
+                        logger.info(f"⏸️  RUNNING job {job_id} (type: {job_type}) - {reason}")
+                    elif state in ("dead_aborted", "dead_crashed", "dead_failed"):
+                        # Process is dead with failure markers - mark as FAILED in Redis
+                        logger.warning(f"💀 RUNNING job {job_id} (type: {job_type}) - {reason}")
+                        try:
+                            update_job_status(job_id, JobStatus.FAILED, metadata={'error': reason})
+                            logger.info(f"   ✅ Updated job status to FAILED in Redis")
+                        except Exception as e:
+                            logger.warning(f"   ⚠️  Failed to update job status: {e}")
+                    elif state == "dead_needs_recovery":
+                        logger.info(f"🔄 RUNNING job {job_id} (type: {job_type}) - {reason}")
+                        jobs_to_recover.append(job)
+                    else:  # unknown state
+                        logger.info(f"🔄 RUNNING job {job_id} (type: {job_type}) - {reason}")
+                        if should_recover:
+                            jobs_to_recover.append(job)
                 
                 # Include recently FAILED jobs
                 elif status == JobStatus.FAILED.value: