lecrapaud 2.3.0__tar.gz → 2.3.2__tar.gz

{lecrapaud-2.3.0 → lecrapaud-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lecrapaud
-Version: 2.3.0
+Version: 2.3.2
 Summary: Framework for machine and deep learning, with regression, classification and time series analysis
 License: Apache License
 License-File: LICENSE

{lecrapaud-2.3.0 → lecrapaud-2.3.2}/lecrapaud/feature_selection.py

@@ -1634,11 +1634,30 @@ class FeatureSelector(LeCrapaudEstimatorMixin):
 # utils
 # TODO : can we use this to select the ideal number of features ?
 def feature_selection_analysis(feature_selection_id: int, n_components: int = 5):
-
-    feature_selection = FeatureSelection.get(feature_selection_id)
-    experiment_dir = feature_selection.experiment.path
-    features = [f.name for f in feature_selection.features]
-    target = feature_selection.target.name
+    # `FS.features` is `lazy="select"` (changed from selectin to drop
+    # the cascading explosion on API endpoints). Wrap the load + the
+    # M2M materialisation inside one session so the access at line
+    # below doesn't hit DetachedInstanceError. Same goes for
+    # `.experiment.path` and `.target.name` — selectin'd at parent
+    # level, so post-session access is fine for those.
+    from lecrapaud.db.session import get_db
+    from sqlalchemy.orm import selectinload as _selectin
+
+    with get_db() as _db:
+        feature_selection = (
+            _db.query(FeatureSelection)
+            .options(_selectin(FeatureSelection.features))
+            .filter(FeatureSelection.id == feature_selection_id)
+            .first()
+        )
+        if feature_selection is None:
+            raise ValueError(f"FeatureSelection {feature_selection_id} not found")
+        # Materialise everything we need from the session BEFORE
+        # the context manager exits (post-exit attribute access is
+        # OK for selectin-loaded relationships).
+        features = [f.name for f in feature_selection.features]
+        experiment_dir = feature_selection.experiment.path
+        target = feature_selection.target.name
     target_number = target.split("_")[1]
 
     train, val, train_scaled, val_scaled, _scaler_y = load_train_data(

{lecrapaud-2.3.0 → lecrapaud-2.3.2}/lecrapaud/model_selection.py

@@ -119,6 +119,44 @@ def test_hardware():
 warnings.filterwarnings("ignore", category=UserWarning, module="pydantic")
 
 
+def _safe_concatenate(data_list, axis=0):
+    """
+    Safely concatenate data regardless of whether it's numpy arrays or pandas objects.
+
+    This function detects the data type and uses the appropriate concatenation method:
+    - np.concatenate for numpy arrays
+    - pd.concat for pandas Series/DataFrames
+
+    Args:
+        data_list: List of data objects to concatenate
+        axis: Axis along which to concatenate
+
+    Returns:
+        Concatenated data using the appropriate method
+    """
+    if not data_list:
+        raise ValueError("Cannot concatenate empty list")
+
+    # Check the type of the first non-None element
+    first_data = next((d for d in data_list if d is not None), None)
+    if first_data is None:
+        raise ValueError("All data elements are None")
+
+    # Determine the data type and use appropriate concatenation method
+    if isinstance(first_data, np.ndarray):
+        # Use numpy concatenation for numpy arrays
+        return np.concatenate(data_list, axis=axis)
+    elif isinstance(first_data, (pd.DataFrame, pd.Series)):
+        # Use pandas concatenation for pandas objects
+        return pd.concat(data_list, axis=axis)
+    else:
+        # For other types, try pandas first, fallback to numpy
+        try:
+            return pd.concat(data_list, axis=axis)
+        except (TypeError, ValueError):
+            return np.concatenate(data_list, axis=axis)
+
+
 def trainable_cv(
     params,
     x_train,
@@ -152,13 +190,13 @@ def trainable_cv(
     in `LeCrapaudModel.fit_boosting._sort_for_ranking`.
     """
     # Combine train and validation data for cross-validation
-    if recurrent:
-        x_train_val = np.concatenate([x_train, x_val], axis=0)
-        y_train_val = np.concatenate([y_train, y_val], axis=0)
-    else:
-        x_train_val = pd.concat([x_train, x_val], axis=0)
-        y_train_val = pd.concat([y_train, y_val], axis=0)
-        # Store original index for later use if needed
+    # Use safe concatenation to handle mixed data types properly
+    x_train_val = _safe_concatenate([x_train, x_val], axis=0)
+    y_train_val = _safe_concatenate([y_train, y_val], axis=0)
+
+    # Store original index for later use if needed (only for pandas objects)
+    original_index = None
+    if hasattr(x_train_val, 'index'):
         original_index = x_train_val.index.copy()
         # Reset index for proper iloc indexing with CV splits
         x_train_val = x_train_val.reset_index(drop=True)
@@ -557,6 +595,19 @@ class ModelSelector(LeCrapaudEstimatorMixin):
 
             if self.target_number is not None:
                 self.features = self.experiment.get_features(self.target_number)
+                # Feature selection can legitimately end up keeping nothing
+                # (over-strict thresholds, too few samples, all-constant
+                # columns). Training on a (N, 0) matrix raises the opaque
+                # sklearn "Found array with 0 feature(s)" deep in the fit
+                # call — fail fast here with an actionable message instead.
+                if not self.features:
+                    raise ValueError(
+                        f"Feature selection produced 0 features for "
+                        f"TARGET_{self.target_number} (experiment "
+                        f"{self.experiment_id}). Cannot train on an empty "
+                        f"feature matrix — check the input data or relax the "
+                        f"feature-selection thresholds."
+                    )
 
             self.all_features = self.experiment.get_all_features(
                 date_column=self.date_column, group_column=self.group_column
@@ -865,14 +916,9 @@ class ModelSelector(LeCrapaudEstimatorMixin):
 
             # Always evaluate on test set (no cross-validation here)
             # The hyperopt already did CV if needed to find best params.
-            # Recurrent models carry 3D numpy arrays (no pandas index), so
-            # concatenate with numpy — pd.concat rejects ndarrays (pandas 3).
-            if model.recurrent:
-                x_train_full = np.concatenate([x_train, x_val], axis=0)
-                y_train_full = np.concatenate([y_train, y_val], axis=0)
-            else:
-                x_train_full = pd.concat([x_train, x_val], axis=0)
-                y_train_full = pd.concat([y_train, y_val], axis=0)
+            # Use safe concatenation to handle mixed data types properly
+            x_train_full = _safe_concatenate([x_train, x_val], axis=0)
+            y_train_full = _safe_concatenate([y_train, y_val], axis=0)
             # Combine the per-row ranking groups the same way for the final
             # fit (train+val together, test on its own). `None` when not ranking.
             train_full_groups = None

{lecrapaud-2.3.0 → lecrapaud-2.3.2}/lecrapaud/models/experiment.py

@@ -444,7 +444,7 @@ class Experiment(Base):
         own_contribs = self._headline_contributions()
         if not own_contribs:
             if self.state == self.STATE_COMPLETED:
-                logger.error(
+                logger.warning(
                     f"Completed experiment {self.id} has no usable scores "
                     f"(no headline / rmse / logloss on any Best Model)"
                 )

{lecrapaud-2.3.0 → lecrapaud-2.3.2}/lecrapaud/models/feature_selection.py

@@ -97,7 +97,21 @@ class FeatureSelection(Base):
         "Feature",
         secondary=lecrapaud_feature_selection_association,
         back_populates="feature_selections",
-        lazy="selectin",
+        # `lazy="select"` (default) instead of `selectin`. The M2M
+        # association explodes the query cost when an Experiment is
+        # loaded (via the cascading selectin from
+        # Experiment.feature_selections → each FS → features here).
+        # For a 12-target / ~200-feature run, this is ~2400 Feature
+        # rows + the join table — pure cost for any API endpoint
+        # that doesn't render features.
+        # Trade-off: accessing `fs.features` AFTER the session closes
+        # raises DetachedInstanceError. All internal lecrapaud
+        # accesses already happen inside `@with_db` (get_features,
+        # get_all_features); the one utility that didn't is now
+        # wrapped explicitly. External consumers that need the M2M
+        # outside a session should pass `selectinload(FS.features)`
+        # in their query.
+        lazy="select",
     )
 
     __table_args__ = (

{lecrapaud-2.3.0 → lecrapaud-2.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lecrapaud"
-version = "2.3.0"
+version = "2.3.2"
 description = "Framework for machine and deep learning, with regression, classification and time series analysis"
 authors = [
     {name = "Pierre H. Gallet"}
@@ -94,4 +94,5 @@ requires = ["poetry-core"]
 [tool.pytest.ini_options]
 markers = [
   "order: reorder test execution",
+  "slow: trains real models end-to-end; deselect for a fast loop with -m 'not slow'",
 ]