featrixsphere 0.2.6708__tar.gz → 0.2.6710__tar.gz

{featrixsphere-0.2.6708 → featrixsphere-0.2.6710}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: featrixsphere
-Version: 0.2.6708
+Version: 0.2.6710
 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.6710/VERSION

@@ -0,0 +1 @@
+0.2.6710

{featrixsphere-0.2.6708 → featrixsphere-0.2.6710}/featrixsphere/__init__.py

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

{featrixsphere-0.2.6708 → featrixsphere-0.2.6710}/featrixsphere/api/client.py

@@ -342,6 +342,34 @@ class FeatrixSphere(HTTPClientMixin):
             ground_truth=ground_truth
         )
 
+    def list_sessions(
+        self,
+        name_prefix: str = "",
+    ) -> List[str]:
+        """
+        List sessions matching a name prefix/search term.
+
+        Searches session directory names on the compute cluster for
+        partial matches (not just prefix).
+
+        Args:
+            name_prefix: Term to match in session names
+
+        Returns:
+            List of matching session ID strings
+
+        Example:
+            sessions = featrix.list_sessions(name_prefix="customer")
+            for sid in sessions:
+                fm = featrix.foundational_model(sid)
+                print(f"{sid}: {fm.status}")
+        """
+        params = {}
+        if name_prefix:
+            params['name_prefix'] = name_prefix
+        response = self._get_json("/compute/sessions-for-org", params=params)
+        return response.get('sessions', [])
+
     def health_check(self) -> Dict[str, Any]:
         """
         Check if the API server is healthy.

{featrixsphere-0.2.6708 → featrixsphere-0.2.6710}/featrixsphere/api/foundational_model.py

@@ -22,6 +22,21 @@ from .reference_record import ReferenceRecord
 logger = logging.getLogger(__name__)
 
 
+def _parse_datetime(value) -> Optional[datetime]:
+    """Parse a datetime from ISO string or return as-is if already datetime."""
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        return value
+    if isinstance(value, str):
+        try:
+            # Handle ISO format with or without timezone
+            return datetime.fromisoformat(value.replace('Z', '+00:00'))
+        except (ValueError, AttributeError):
+            return None
+    return None
+
+
 @dataclass
 class FoundationalModel:
     """
@@ -68,6 +83,11 @@ class FoundationalModel:
     epochs: Optional[int] = None
     final_loss: Optional[float] = None
     created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    session_type: Optional[str] = None
+    compute_cluster: Optional[str] = None
+    error_message: Optional[str] = None
+    training_progress: Optional[Dict[str, Any]] = None
 
     # Internal
     _ctx: Optional['ClientContext'] = field(default=None, repr=False)
@@ -88,7 +108,9 @@ class FoundationalModel:
             dimensions=response.get('d_model') or response.get('dimensions'),
             epochs=response.get('epochs') or response.get('final_epoch'),
             final_loss=response.get('final_loss'),
-            created_at=datetime.now(),
+            created_at=_parse_datetime(response.get('created_at')),
+            session_type=response.get('session_type'),
+            compute_cluster=response.get('compute_cluster'),
             _ctx=ctx,
         )
 
@@ -99,19 +121,22 @@ class FoundationalModel:
         ctx: 'ClientContext'
     ) -> 'FoundationalModel':
         """Load FoundationalModel from session ID."""
-        # Get session info
-        session_data = ctx.get_json(f"/compute/session/{session_id}")
+        # Get session info - response has {"session": {...}, "jobs": {...}}
+        response_data = ctx.get_json(f"/compute/session/{session_id}")
+        session = response_data.get('session', response_data)
 
         fm = cls(
             id=session_id,
-            name=session_data.get('name'),
-            status=session_data.get('status'),
-            created_at=datetime.now(),
+            name=session.get('name'),
+            status=session.get('status'),
+            created_at=_parse_datetime(session.get('created_at')),
+            session_type=session.get('session_type'),
+            compute_cluster=session.get('compute_cluster'),
             _ctx=ctx,
         )
 
-        # Try to get model info
-        fm._update_from_session(session_data)
+        # Extract model info, training stats, jobs, error_message
+        fm._update_from_session(response_data)
 
         return fm
 
@@ -439,10 +464,11 @@ class FoundationalModel:
         last_status = None
 
         while time.time() - start_time < max_wait_time:
-            # Get session status
-            session_data = self._ctx.get_json(f"/compute/session/{self.id}")
+            # Get session status - response has {"session": {...}, "jobs": {...}}
+            response_data = self._ctx.get_json(f"/compute/session/{self.id}")
+            session_data = response_data.get('session', response_data)
             status = session_data.get('status', 'unknown')
-            jobs = session_data.get('jobs', {})
+            jobs = response_data.get('jobs', {})
 
             # Look for ES training job
             es_job = None
@@ -475,7 +501,7 @@ class FoundationalModel:
             # Check completion
             if job_status == 'done' or status == 'done':
                 self.status = 'done'
-                self._update_from_session(session_data)
+                self._update_from_session(response_data)
                 if show_progress:
                     print(f"Training complete!")
                     if self.dimensions:
@@ -627,27 +653,73 @@ class FoundationalModel:
 
         return predictors
 
-    def _update_from_session(self, session_data: Dict[str, Any]) -> None:
-        """Update fields from session data."""
-        # Try to get model info from various places
-        model_info = session_data.get('model_info', {})
-        training_stats = session_data.get('training_stats', {})
+    def _update_from_session(self, response_data: Dict[str, Any]) -> None:
+        """Update fields from session API response.
+
+        The response from GET /session/{id} has structure:
+            {"session": {...}, "jobs": {...}, ...}
+        """
+        # Handle both nested and flat response formats
+        session = response_data.get('session', response_data)
+        jobs = response_data.get('jobs', {})
+
+        # Core session fields
+        if session.get('name') and not self.name:
+            self.name = session['name']
+        if session.get('status'):
+            self.status = session['status']
+        if session.get('session_type'):
+            self.session_type = session['session_type']
+        if session.get('compute_cluster'):
+            self.compute_cluster = session['compute_cluster']
+        if session.get('created_at') and not self.created_at:
+            self.created_at = _parse_datetime(session['created_at'])
+        if session.get('finished_at'):
+            self.updated_at = _parse_datetime(session['finished_at'])
+        elif session.get('started_at'):
+            self.updated_at = _parse_datetime(session['started_at'])
+
+        # Model info from session
+        model_info = session.get('model_info', {})
+        training_stats = session.get('training_stats', {})
 
         self.dimensions = (
             model_info.get('d_model') or
             model_info.get('embedding_dim') or
-            session_data.get('d_model')
+            session.get('d_model')
         )
         self.epochs = (
             training_stats.get('final_epoch') or
             training_stats.get('epochs_trained') or
-            session_data.get('epochs')
+            session.get('epochs')
         )
         self.final_loss = (
             training_stats.get('final_loss') or
-            session_data.get('final_loss')
+            session.get('final_loss')
         )
 
+        # Extract error_message and training_progress from jobs
+        for job_id, job in jobs.items():
+            job_type = job.get('job_type', '')
+            job_status = job.get('status', '')
+
+            # Training progress from ES training job
+            if job_type in ('train_embedding_space', 'train_es', 'training'):
+                current_epoch = job.get('current_epoch') or job.get('epoch')
+                total_epochs = job.get('total_epochs') or job.get('epochs')
+                if current_epoch or total_epochs:
+                    self.training_progress = {
+                        'current_epoch': current_epoch,
+                        'total_epochs': total_epochs,
+                        'job_status': job_status,
+                    }
+
+            # Error message from any failed job
+            if job_status in ('failed', 'error'):
+                err = job.get('error') or job.get('error_message')
+                if err:
+                    self.error_message = err
+
     def _clean_record(self, record: Dict[str, Any]) -> Dict[str, Any]:
         """Clean a record for API submission."""
         import math
@@ -684,6 +756,17 @@ class FoundationalModel:
         """Column names in this foundational model's embedding space."""
         return self.get_columns()
 
+    @property
+    def schema_metadata(self) -> Dict[str, Any]:
+        """Get schema metadata including column names and types.
+
+        Returns:
+            Dict with 'column_names', 'column_types', and 'num_columns'
+        """
+        if not self._ctx:
+            raise ValueError("FoundationalModel not connected to client")
+        return self._ctx.get_json(f"/compute/session/{self.id}/columns")
+
     def clone(
         self,
         target_compute_cluster: Optional[str] = None,
@@ -749,7 +832,6 @@ class FoundationalModel:
 
         data = self._ctx.get_json(f"/compute/session/{self.id}")
         self._update_from_session(data)
-        self.status = data.get('status', self.status)
         return data
 
     def is_ready(self) -> bool:
@@ -767,9 +849,8 @@ class FoundationalModel:
             raise ValueError("FoundationalModel not connected to client")
 
         data = self._ctx.get_json(f"/compute/session/{self.id}")
-        status = data.get('status', 'unknown')
-        self.status = status
-        return status == 'done'
+        self._update_from_session(data)
+        return self.status == 'done'
 
     def publish(
         self,
@@ -938,6 +1019,11 @@ class FoundationalModel:
             'epochs': self.epochs,
             'final_loss': self.final_loss,
             'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None,
+            'session_type': self.session_type,
+            'compute_cluster': self.compute_cluster,
+            'error_message': self.error_message,
+            'training_progress': self.training_progress,
         }
 
     def __repr__(self) -> str:

{featrixsphere-0.2.6708 → featrixsphere-0.2.6710}/featrixsphere.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: featrixsphere
-Version: 0.2.6708
+Version: 0.2.6710
 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.6708 → featrixsphere-0.2.6710}/src/lib/featrix/neural/embedded_space.py

@@ -6615,6 +6615,25 @@ class EmbeddingSpace(object):
                         'pct_rank_top10': float((ranks_arr <= 10).sum() / len(ranks_arr) * 100),
                     }
 
+        # Aggregate ranking metrics (AUC, Recall@1, etc.) from batch collapse_diagnostics
+        if batch_loss_dicts:
+            ranking_accum = {}
+            ranking_count = 0
+            for loss_dict in batch_loss_dicts:
+                cd = loss_dict.get('collapse_diagnostics', {})
+                rm = cd.get('ranking_metrics') if isinstance(cd, dict) else None
+                if rm and isinstance(rm, dict):
+                    ranking_count += 1
+                    for key in ('auc', 'recall_at_1', 'recall_at_5', 'recall_at_10',
+                                'positive_rank_mean', 'diagonal_cosine_mean', 'margin_mean'):
+                        if rm.get(key) is not None:
+                            ranking_accum.setdefault(key, 0.0)
+                            ranking_accum[key] += float(rm[key])
+            if ranking_count > 0:
+                components['ranking_metrics'] = {
+                    k: v / ranking_count for k, v in ranking_accum.items()
+                }
+
         # Return both total loss and components
         return combined_loss / n_batches, components
 
@@ -7600,6 +7619,7 @@ class EmbeddingSpace(object):
                     "epoch": best_epoch_idx,
                     "train_loss": best_entry.get('train_loss'),
                     "val_loss": best_entry.get('val_loss'),
+                    "test_loss": best_entry.get('test_loss'),
                     "spread": best_entry.get('spread'),
                     "joint": best_entry.get('joint'),
                     "marginal": best_entry.get('marginal'),
@@ -7786,9 +7806,36 @@ class EmbeddingSpace(object):
                 "created_at": datetime.now().isoformat(),
                 "training_duration_minutes": self.training_info.get('duration_minutes', 0),
                 "version_info": self.version_info or {},
+            },
+
+            "test_set_monitoring": {
+                "description": "Held-out test loss recorded periodically during training (observation only, never used for training decisions)",
+                "entries": [
+                    {
+                        "epoch": entry["epoch"],
+                        "test_loss": entry.get("test_loss"),
+                        "test_auc": entry.get("test_auc"),
+                        "test_recall_at_1": entry.get("test_recall_at_1"),
+                    }
+                    for entry in loss_history
+                    if entry.get("test_loss") is not None
+                ],
+            },
+
+            "ranking_metrics_history": {
+                "description": "Validation AUC and Recall@1 per epoch",
+                "entries": [
+                    {
+                        "epoch": entry["epoch"],
+                        "val_auc": entry.get("val_auc"),
+                        "val_recall_at_1": entry.get("val_recall_at_1"),
+                    }
+                    for entry in loss_history
+                    if entry.get("val_auc") is not None
+                ],
             }
         }
-        
+
         return model_card
     
     def _get_feature_inventory(self):
@@ -18715,6 +18762,39 @@ class EmbeddingSpace(object):
                 self._current_val_dataloader = val_dataloader
                 logger.info(f"✅ Validation DataLoader created with num_workers={val_dl_kwargs.get('num_workers', 0)}, persistent_workers={val_dl_kwargs.get('persistent_workers', False)}")
 
+                # --- Test set monitoring (observability only, never used for training decisions) ---
+                test_dataloader = None
+                _test_monitor_epochs = set()
+                if get_config().get_enable_test_set_monitoring() and hasattr(self, '_timeline') and self._timeline is not None:
+                    test_input_data = self._timeline.get_test_set()
+                    if test_input_data is not None:
+                        test_dataset = SuperSimpleSelfSupervisedDataset(
+                            test_input_data.df,
+                            codecs=self.col_codecs,
+                            row_meta_data=test_input_data.project_row_meta_data_list,
+                            casted_df=test_input_data.casted_df,
+                        )
+                        test_dl_kwargs = create_dataloader_kwargs(
+                            batch_size=batch_size,
+                            shuffle=False,
+                            drop_last=True,
+                            num_workers=0,
+                            dataset_size=len(test_input_data.df),
+                            num_columns=len(test_input_data.df.columns),
+                        )
+                        test_dataloader = DataLoader(
+                            test_dataset,
+                            collate_fn=collate_tokens,
+                            **test_dl_kwargs
+                        )
+                        interval_pct = get_config().get_test_set_monitoring_interval_pct()
+                        for pct in range(interval_pct, 101, interval_pct):
+                            ep = max(0, int(round(n_epochs * pct / 100.0)) - 1)
+                            _test_monitor_epochs.add(ep)
+                        # Always include final epoch
+                        _test_monitor_epochs.add(n_epochs - 1)
+                        logger.info(f"🧪 Test set monitoring enabled: {len(test_input_data.df)} rows, eval at epochs {sorted(_test_monitor_epochs)}")
+
                 batches_per_epoch = len(data_loader)
             else:
                 logger.info("Using batch sampler data loader for multi-dataset training with multiprocess support")
@@ -21360,10 +21440,48 @@ class EmbeddingSpace(object):
                                 loss_entry_with_components["marginal"] = val_components.get('marginal')
                                 loss_entry_with_components["marginal_weighted"] = val_components.get('marginal_weighted')
 
+                        # Record validation ranking metrics (AUC, R@1)
+                        if val_components:
+                            val_rm = val_components.get('ranking_metrics', {})
+                            if val_rm:
+                                loss_entry_with_components["val_auc"] = val_rm.get('auc')
+                                loss_entry_with_components["val_recall_at_1"] = val_rm.get('recall_at_1')
+
+                        # --- Test set monitoring (observation only, never affects training) ---
+                        if test_dataloader is not None and epoch_idx in _test_monitor_epochs:
+                            logger.info(f"   🧪 Computing test loss for epoch {epoch_idx + 1}/{n_epochs} (observation only)...")
+                            test_loss, test_components = self.compute_val_loss(test_dataloader)
+                            loss_entry_with_components["test_loss"] = test_loss
+                            test_rm = test_components.get('ranking_metrics', {}) if test_components else {}
+                            test_auc = test_rm.get('auc')
+                            test_r1 = test_rm.get('recall_at_1')
+                            loss_entry_with_components["test_auc"] = test_auc
+                            loss_entry_with_components["test_recall_at_1"] = test_r1
+                            parts = [f"   🧪 Test set epoch {epoch_idx + 1}: loss={test_loss:.6f}"]
+                            if test_auc is not None:
+                                parts.append(f"AUC={test_auc:.4f}")
+                            if test_r1 is not None:
+                                parts.append(f"R@1={test_r1:.4f}")
+                            parts.append("(observation only)")
+                            logger.info(", ".join(parts))
+                            # Post to training timeline
+                            from featrix.neural.timeline_events import post_timeline_event
+                            post_timeline_event({
+                                'epoch': epoch_idx,
+                                'event_type': 'test_set_monitor',
+                                'test_loss': test_loss,
+                                'test_auc': test_auc,
+                                'test_recall_at_1': test_r1,
+                                'test_recall_at_5': test_rm.get('recall_at_5'),
+                                'test_recall_at_10': test_rm.get('recall_at_10'),
+                                'test_diagonal_cosine_mean': test_rm.get('diagonal_cosine_mean'),
+                                'test_positive_rank_mean': test_rm.get('positive_rank_mean'),
+                            })
+
                         # Update the loss_history entry (INSERT OR REPLACE) with components
                         if hasattr(self, 'history_db') and self.history_db:
                             self.history_db.push_loss_history(loss_entry_with_components)
-                        
+
                         # Check for OOM events after validation
                         self._check_oom_after_validation()
                         

{featrixsphere-0.2.6708 → featrixsphere-0.2.6710}/src/lib/featrix/neural/sphere_config.py

@@ -149,6 +149,9 @@ DEFAULT_CONFIG = {
     "runtime_cleanup_age_days": 30,  # Delete cached versions not used in this many days
     # === XGBOOST RAW FEATURES ===
     "xgb_include_raw_features": False,  # When True, XGBoost classifier concatenates raw DataFrame columns with embeddings
+    # === TEST SET MONITORING (observability only — never used for training decisions) ===
+    "enable_test_set_monitoring": True,  # Record test loss periodically during foundation training for post-hoc analysis
+    "test_set_monitoring_interval_pct": 10,  # Evaluate test set every N% of total epochs (10 = every 10%)
 }
 
 
@@ -1604,6 +1607,31 @@ class SphereConfig:
             return False
         return self._config.get("xgb_include_raw_features", DEFAULT_CONFIG.get("xgb_include_raw_features", False))
 
+    # === TEST SET MONITORING GETTERS ===
+
+    def get_enable_test_set_monitoring(self) -> bool:
+        """
+        Get whether to periodically evaluate the held-out test set during foundation training.
+
+        Test loss is recorded for post-hoc analysis only. It is NEVER used for early stopping,
+        learning rate scheduling, or any other training decision.
+
+        Only effective during foundation training (simple mode has no separate test set).
+
+        Default: True
+        """
+        return self._config.get("enable_test_set_monitoring", DEFAULT_CONFIG.get("enable_test_set_monitoring", True))
+
+    def get_test_set_monitoring_interval_pct(self) -> int:
+        """
+        Get the interval (as percentage of total epochs) at which test set loss is evaluated.
+
+        For example, 10 means evaluate at 10%, 20%, ..., 100% of training.
+
+        Default: 10
+        """
+        return self._config.get("test_set_monitoring_interval_pct", DEFAULT_CONFIG.get("test_set_monitoring_interval_pct", 10))
+
     def log_config(self, prefix: str = ""):
         """
         Log all configuration parameters.

{featrixsphere-0.2.6708 → featrixsphere-0.2.6710}/src/lib/featrix/neural/training_history_db.py

@@ -51,6 +51,7 @@ class TrainingHistoryDB:
                 current_learning_rate REAL,
                 loss REAL,
                 validation_loss REAL,
+                test_loss REAL,
                 time_now REAL,
                 duration REAL,
                 spread REAL,
@@ -60,13 +61,18 @@ class TrainingHistoryDB:
                 diversity REAL,
                 reconstruction REAL,
                 separation REAL,
-                metric REAL
+                metric REAL,
+                val_auc REAL,
+                val_recall_at_1 REAL,
+                test_auc REAL,
+                test_recall_at_1 REAL
             )
         """)
         cursor.execute("CREATE INDEX IF NOT EXISTS idx_loss_history_epoch ON loss_history(epoch)")
 
         # Add new columns for existing databases (backward compatibility)
-        for col_name in ['diversity', 'reconstruction', 'separation', 'metric']:
+        for col_name in ['diversity', 'reconstruction', 'separation', 'metric', 'test_loss',
+                         'val_auc', 'val_recall_at_1', 'test_auc', 'test_recall_at_1']:
             try:
                 cursor.execute(f"ALTER TABLE loss_history ADD COLUMN {col_name} REAL")
             except sqlite3.OperationalError:
@@ -138,15 +144,16 @@ class TrainingHistoryDB:
         cursor = self.conn.cursor()
         cursor.execute("""
             INSERT OR REPLACE INTO loss_history
-            (epoch, current_learning_rate, loss, validation_loss, time_now, duration,
+            (epoch, current_learning_rate, loss, validation_loss, test_loss, time_now, duration,
              spread, joint, marginal, marginal_weighted, diversity, reconstruction,
-             separation, metric)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+             separation, metric, val_auc, val_recall_at_1, test_auc, test_recall_at_1)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         """, (
             loss_entry.get("epoch"),
             loss_entry.get("current_learning_rate"),
             loss_entry.get("loss"),
             loss_entry.get("validation_loss"),
+            loss_entry.get("test_loss"),
             loss_entry.get("time_now"),
             loss_entry.get("duration"),
             loss_entry.get("spread"),
@@ -156,7 +163,11 @@ class TrainingHistoryDB:
             loss_entry.get("diversity"),
             loss_entry.get("reconstruction"),
             loss_entry.get("separation"),
-            loss_entry.get("metric")
+            loss_entry.get("metric"),
+            loss_entry.get("val_auc"),
+            loss_entry.get("val_recall_at_1"),
+            loss_entry.get("test_auc"),
+            loss_entry.get("test_recall_at_1"),
         ))
         self.conn.commit()
         
@@ -226,8 +237,9 @@ class TrainingHistoryDB:
             num_epochs = self.memory_cache_size
         cursor = self.conn.cursor()
         cursor.execute("""
-            SELECT epoch, current_learning_rate, loss, validation_loss, time_now, duration,
-                   spread, joint, marginal, marginal_weighted, diversity, reconstruction
+            SELECT epoch, current_learning_rate, loss, validation_loss, test_loss, time_now, duration,
+                   spread, joint, marginal, marginal_weighted, diversity, reconstruction,
+                   val_auc, val_recall_at_1, test_auc, test_recall_at_1
             FROM loss_history
             ORDER BY epoch DESC
             LIMIT ?
@@ -241,14 +253,19 @@ class TrainingHistoryDB:
                 "current_learning_rate": row[1],
                 "loss": row[2],
                 "validation_loss": row[3],
-                "time_now": row[4],
-                "duration": row[5],
-                "spread": row[6],
-                "joint": row[7],
-                "marginal": row[8],
-                "marginal_weighted": row[9],
-                "diversity": row[10] if len(row) > 10 else None,
-                "reconstruction": row[11] if len(row) > 11 else None
+                "test_loss": row[4],
+                "time_now": row[5],
+                "duration": row[6],
+                "spread": row[7],
+                "joint": row[8],
+                "marginal": row[9],
+                "marginal_weighted": row[10],
+                "diversity": row[11] if len(row) > 11 else None,
+                "reconstruction": row[12] if len(row) > 12 else None,
+                "val_auc": row[13] if len(row) > 13 else None,
+                "val_recall_at_1": row[14] if len(row) > 14 else None,
+                "test_auc": row[15] if len(row) > 15 else None,
+                "test_recall_at_1": row[16] if len(row) > 16 else None,
             })
         return result
 
@@ -261,8 +278,9 @@ class TrainingHistoryDB:
 
         cursor = self.conn.cursor()
         cursor.execute("""
-            SELECT epoch, current_learning_rate, loss, validation_loss, time_now, duration,
-                   spread, joint, marginal, marginal_weighted, diversity, reconstruction
+            SELECT epoch, current_learning_rate, loss, validation_loss, test_loss, time_now, duration,
+                   spread, joint, marginal, marginal_weighted, diversity, reconstruction,
+                   val_auc, val_recall_at_1, test_auc, test_recall_at_1
             FROM loss_history
             ORDER BY epoch ASC
         """)
@@ -274,14 +292,19 @@ class TrainingHistoryDB:
                 "current_learning_rate": row[1],
                 "loss": row[2],
                 "validation_loss": row[3],
-                "time_now": row[4],
-                "duration": row[5],
-                "spread": row[6],
-                "joint": row[7],
-                "marginal": row[8],
-                "marginal_weighted": row[9],
-                "diversity": row[10] if len(row) > 10 else None,
-                "reconstruction": row[11] if len(row) > 11 else None
+                "test_loss": row[4],
+                "time_now": row[5],
+                "duration": row[6],
+                "spread": row[7],
+                "joint": row[8],
+                "marginal": row[9],
+                "marginal_weighted": row[10],
+                "diversity": row[11] if len(row) > 11 else None,
+                "reconstruction": row[12] if len(row) > 12 else None,
+                "val_auc": row[13] if len(row) > 13 else None,
+                "val_recall_at_1": row[14] if len(row) > 14 else None,
+                "test_auc": row[15] if len(row) > 15 else None,
+                "test_recall_at_1": row[16] if len(row) > 16 else None,
             })
         return result
         

featrixsphere-0.2.6708/VERSION

@@ -1 +0,0 @@
-0.2.6708