lecrapaud 0.15.0__tar.gz → 0.16.0__tar.gz

{lecrapaud-0.15.0 → lecrapaud-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lecrapaud
-Version: 0.15.0
+Version: 0.16.0
 Summary: Framework for machine and deep learning, with regression, classification and time series analysis
 License: Apache License
 Author: Pierre H. Gallet

{lecrapaud-0.15.0 → lecrapaud-0.16.0}/lecrapaud/api.py

@@ -92,13 +92,22 @@ class LeCrapaud:
         """Retrieve the last experiment by name."""
         return ExperimentEngine(id=Experiment.get_last_by_name(name).id, **kwargs)
 
-    def get_best_experiment_by_name(self, name: str,metric: str = "both", **kwargs) -> "ExperimentEngine":
+    def get_best_experiment_by_name(
+        self, name: str, metric: str = "both", **kwargs
+    ) -> "ExperimentEngine":
         """Retrieve the best experiment by score."""
-        return ExperimentEngine(id=Experiment.get_best_by_score(name=name, metric=metric).id, **kwargs)
+        return ExperimentEngine(
+            id=Experiment.get_best_by_score(name=name, metric=metric).id, **kwargs
+        )
 
-    def list_experiments(self, limit=1000) -> list["ExperimentEngine"]:
+    def list_experiments(
+        self, name: str = None, limit: int = 1000
+    ) -> list["ExperimentEngine"]:
         """List all experiments in the database."""
-        return [ExperimentEngine(id=exp.id) for exp in Experiment.get_all(limit=limit)]
+        return [
+            ExperimentEngine(id=exp.id)
+            for exp in Experiment.get_all_by_name(name=name, limit=limit)
+        ]
 
 
 class ExperimentEngine:

{lecrapaud-0.15.0 → lecrapaud-0.16.0}/lecrapaud/db/models/experiment.py

@@ -32,7 +32,7 @@ lecrapaud_experiment_target_association = create_association_table(
     table1="experiments",
     column1="experiment",
     table2="targets",
-    column2="target"
+    column2="target",
 )
 
 
@@ -62,21 +62,22 @@ class Experiment(Base):
         cascade="all, delete-orphan",
         lazy="selectin",
     )
+
     @hybrid_property
     def best_rmse(self):
         """Best RMSE score across all model selections and trainings."""
         # Get the minimum RMSE for each model selection
         min_scores = [
             min(
-                score.rmse 
-                for mt in ms.model_trainings 
+                score.rmse
+                for mt in ms.model_trainings
                 for score in mt.score
                 if score.rmse is not None
             )
             for ms in self.model_selections
             if any(
-                score.rmse is not None 
-                for mt in ms.model_trainings 
+                score.rmse is not None
+                for mt in ms.model_trainings
                 for score in mt.score
             )
         ]
@@ -88,15 +89,15 @@ class Experiment(Base):
         # Get the minimum LogLoss for each model selection
         min_scores = [
             min(
-                score.logloss 
-                for mt in ms.model_trainings 
+                score.logloss
+                for mt in ms.model_trainings
                 for score in mt.score
                 if score.logloss is not None
             )
             for ms in self.model_selections
             if any(
-                score.logloss is not None 
-                for mt in ms.model_trainings 
+                score.logloss is not None
+                for mt in ms.model_trainings
                 for score in mt.score
             )
         ]
@@ -108,15 +109,15 @@ class Experiment(Base):
         # Get the minimum RMSE for each model selection
         min_scores = [
             min(
-                score.rmse 
-                for mt in ms.model_trainings 
+                score.rmse
+                for mt in ms.model_trainings
                 for score in mt.score
                 if score.rmse is not None
             )
             for ms in self.model_selections
             if any(
-                score.rmse is not None 
-                for mt in ms.model_trainings 
+                score.rmse is not None
+                for mt in ms.model_trainings
                 for score in mt.score
             )
         ]
@@ -128,20 +129,20 @@ class Experiment(Base):
         # Get the minimum LogLoss for each model selection
         min_scores = [
             min(
-                score.logloss 
-                for mt in ms.model_trainings 
+                score.logloss
+                for mt in ms.model_trainings
                 for score in mt.score
                 if score.logloss is not None
             )
             for ms in self.model_selections
             if any(
-                score.logloss is not None 
-                for mt in ms.model_trainings 
+                score.logloss is not None
+                for mt in ms.model_trainings
                 for score in mt.score
             )
         ]
         return mean(min_scores) if min_scores else None
-    
+
     test_size = Column(Integer)
     corr_threshold = Column(Float, nullable=False)
     max_features = Column(Integer, nullable=False)
@@ -179,88 +180,114 @@ class Experiment(Base):
         ),
     )
 
+    @classmethod
+    @with_db
+    def get_all_by_name(cls, name: str | None = None, db=None):
+        """
+        Find the most recently created experiment that contains the given name string.
+
+        Args:
+            session: SQLAlchemy session
+            name (str): String to search for in experiment names
+
+        Returns:
+            Experiment or None: The most recent matching experiment or None if not found
+        """
+        if name is not None:
+            return (
+                db.query(cls)
+                .filter(cls.name.ilike(f"%{name}%"))
+                .order_by(cls.created_at.desc())
+                .all()
+            )
+        return db.query(cls).order_by(cls.created_at.desc()).all()
+
     @classmethod
     @with_db
     def get_last_by_name(cls, name: str, db=None):
         """
         Find the most recently created experiment that contains the given name string.
-        
+
         Args:
             session: SQLAlchemy session
             name (str): String to search for in experiment names
-            
+
         Returns:
             Experiment or None: The most recent matching experiment or None if not found
         """
         return (
             db.query(cls)
-            .filter(cls.name.ilike(f'%{name}%'))
+            .filter(cls.name.ilike(f"%{name}%"))
             .order_by(cls.created_at.desc())
             .first()
         )
 
     @classmethod
     @with_db
-    def get_best_by_score(cls, name: str, metric='both', db=None):
+    def get_best_by_score(cls, name: str, metric="both", db=None):
         """
         Find the experiment with the best score based on average RMSE, LogLoss, or both.
-        
+
         Args:
             metric (str): 'rmse', 'logloss', or 'both' to determine which score to optimize
             db: SQLAlchemy session
-            
+
         Returns:
             Experiment or None: The experiment with the best score or None if not found
         """
-        if metric == 'both':
+        if metric == "both":
             # Calculate a combined score: average of normalized RMSE and LogLoss
             # This ensures we're comparing apples to apples by normalizing the scores
-            experiments = db.query(cls).filter(cls.name.ilike(f'%{name}%')).all()
+            experiments = db.query(cls).filter(cls.name.ilike(f"%{name}%")).all()
             if not experiments:
                 return None
-                
+
             # Get all scores
             rmse_scores = [e.avg_rmse for e in experiments if e.avg_rmse is not None]
-            logloss_scores = [e.avg_logloss for e in experiments if e.avg_logloss is not None]
-            
+            logloss_scores = [
+                e.avg_logloss for e in experiments if e.avg_logloss is not None
+            ]
+
             if not rmse_scores or not logloss_scores:
                 return None
-                
+
             # Normalize scores (subtract min and divide by range)
             min_rmse = min(rmse_scores)
             range_rmse = max(rmse_scores) - min_rmse
             min_logloss = min(logloss_scores)
             range_logloss = max(logloss_scores) - min_logloss
-            
+
             # Calculate combined score for each experiment
             experiment_scores = []
             for experiment in experiments:
                 if experiment.avg_rmse is None or experiment.avg_logloss is None:
                     continue
-                    
+
                 # Normalize both scores
                 norm_rmse = (experiment.avg_rmse - min_rmse) / range_rmse
                 norm_logloss = (experiment.avg_logloss - min_logloss) / range_logloss
-                
+
                 # Calculate combined score (average of normalized scores)
                 combined_score = (norm_rmse + norm_logloss) / 2
                 experiment_scores.append((experiment, combined_score))
-            
+
             # Sort by combined score (ascending since lower is better)
             experiment_scores.sort(key=lambda x: x[1])
-            
+
             return experiment_scores[0][0] if experiment_scores else None
-        
+
         # For single metric case (rmse or logloss)
-        score_property = cls.avg_rmse if metric == 'rmse' else cls.avg_logloss
-        
+        score_property = cls.avg_rmse if metric == "rmse" else cls.avg_logloss
+
         return (
             db.query(cls)
-            .filter(cls.name.ilike(f'%{name}%'), score_property.isnot(None))  # Only consider experiments with scores
+            .filter(
+                cls.name.ilike(f"%{name}%"), score_property.isnot(None)
+            )  # Only consider experiments with scores
             .order_by(score_property)
             .first()
         )
-        
+
     def get_features(self, target_number: int):
         targets = [t for t in self.targets if t.name == f"TARGET_{target_number}"]
         if targets:

{lecrapaud-0.15.0 → lecrapaud-0.16.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lecrapaud"
-version = "0.15.0"
+version = "0.16.0"
 description = "Framework for machine and deep learning, with regression, classification and time series analysis"
 authors = [
     {name = "Pierre H. Gallet"}