lecrapaud 0.14.8__py3-none-any.whl → 0.15.0__py3-none-any.whl

lecrapaud/api.py

@@ -88,6 +88,14 @@ class LeCrapaud:
         """
         return ExperimentEngine(id=id, **kwargs)
 
+    def get_last_experiement_by_name(self, name: str, **kwargs) -> "ExperimentEngine":
+        """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":
+        """Retrieve the best experiment by score."""
+        return ExperimentEngine(id=Experiment.get_best_by_score(name=name, metric=metric).id, **kwargs)
+
     def list_experiments(self, limit=1000) -> list["ExperimentEngine"]:
         """List all experiments in the database."""
         return [ExperimentEngine(id=exp.id) for exp in Experiment.get_all(limit=limit)]

lecrapaud/db/models/experiment.py

@@ -15,9 +15,15 @@ from sqlalchemy import (
     UniqueConstraint,
     func,
 )
-from sqlalchemy.orm import relationship
+from sqlalchemy.orm import relationship, aliased
+from sqlalchemy.ext.hybrid import hybrid_property
+from sqlalchemy import func
+from statistics import fmean as mean
+from lecrapaud.db.models.model_selection import ModelSelection
+from lecrapaud.db.models.model_training import ModelTraining
+from lecrapaud.db.models.score import Score
 
-from lecrapaud.db.models.base import Base
+from lecrapaud.db.models.base import Base, with_db
 from lecrapaud.db.models.utils import create_association_table
 
 # jointures
@@ -48,6 +54,94 @@ class Experiment(Base):
     size = Column(Integer, nullable=False)
     train_size = Column(Integer)
     val_size = Column(Integer)
+
+    # Relationships
+    model_selections = relationship(
+        "ModelSelection",
+        back_populates="experiment",
+        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 
+                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 
+                for score in mt.score
+            )
+        ]
+        return min(min_scores) if min_scores else None
+
+    @hybrid_property
+    def best_logloss(self):
+        """Best LogLoss score across all model selections and trainings."""
+        # Get the minimum LogLoss for each model selection
+        min_scores = [
+            min(
+                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 
+                for score in mt.score
+            )
+        ]
+        return min(min_scores) if min_scores else None
+
+    @hybrid_property
+    def avg_rmse(self):
+        """Average 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 
+                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 
+                for score in mt.score
+            )
+        ]
+        return mean(min_scores) if min_scores else None
+
+    @hybrid_property
+    def avg_logloss(self):
+        """Average LogLoss score across all model selections and trainings."""
+        # Get the minimum LogLoss for each model selection
+        min_scores = [
+            min(
+                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 
+                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)
@@ -70,12 +164,7 @@ class Experiment(Base):
         cascade="all, delete-orphan",
         lazy="selectin",
     )
-    model_selections = relationship(
-        "ModelSelection",
-        back_populates="experiment",
-        cascade="all, delete-orphan",
-        lazy="selectin",
-    )
+
     targets = relationship(
         "Target",
         secondary=lecrapaud_experiment_target_association,
@@ -90,6 +179,88 @@ class Experiment(Base):
         ),
     )
 
+    @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}%'))
+            .order_by(cls.created_at.desc())
+            .first()
+        )
+
+    @classmethod
+    @with_db
+    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':
+            # 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()
+            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]
+            
+            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
+        
+        return (
+            db.query(cls)
+            .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.14.8.dist-info → lecrapaud-0.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lecrapaud
-Version: 0.14.8
+Version: 0.15.0
 Summary: Framework for machine and deep learning, with regression, classification and time series analysis
 License: Apache License
 Author: Pierre H. Gallet
@@ -19,6 +19,7 @@ Requires-Dist: mlxtend (>=0.23.4)
 Requires-Dist: numpy (>=2.1.3)
 Requires-Dist: openai (>=1.88.0)
 Requires-Dist: pandas (>=2.3.0)
+Requires-Dist: pydantic (>=2.9.2)
 Requires-Dist: python-dotenv (>=1.1.0)
 Requires-Dist: scikit-learn (>=1.6.1)
 Requires-Dist: scipy (<1.14.0)

{lecrapaud-0.14.8.dist-info → lecrapaud-0.15.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 lecrapaud/__init__.py,sha256=oCxbtw_nk8rlOXbXbWo0RRMlsh6w-hTiZ6e5PRG_wp0,28
-lecrapaud/api.py,sha256=j3aCdg4J6DCgmBoLiOWd_b-ji2wZVeyoFfoXd07rBXQ,19751
+lecrapaud/api.py,sha256=Pu4761gQuQBmey_P3s9y6Kf4KWD4t9O0OcH9sDuw3xA,20239
 lecrapaud/config.py,sha256=N8kQS1bNEXp6loIw7_X2_OjrbY4_a7UZhZcT1XgsYAs,1121
 lecrapaud/db/__init__.py,sha256=82o9fMfaqKXPh2_rt44EzNRVZV1R4LScEnQYvj_TjK0,34
 lecrapaud/db/alembic/README,sha256=MVlc9TYmr57RbhXET6QxgyCcwWP7w-vLkEsirENqiIQ,38
@@ -12,7 +12,7 @@ lecrapaud/db/alembic/versions/2025_06_25_1759-72aa496ca65b_.py,sha256=MiqooJuZ1e
 lecrapaud/db/alembic.ini,sha256=TXrZB4pWVLn2EUg867yp6paA_19vGeirO95mTPA3nbs,3699
 lecrapaud/db/models/__init__.py,sha256=Lhyw9fVLdom0Fc6yIP-ip8FjkU1EwVwjae5q2VM815Q,740
 lecrapaud/db/models/base.py,sha256=J9ew-0z_-tnWAwhVvOmVDys2R6jPF_oSca_ny6wpXQE,7606
-lecrapaud/db/models/experiment.py,sha256=5vKttTRLCcb2oS9-BHZhGxRRckM8E3C8LBdW34tPJuQ,3964
+lecrapaud/db/models/experiment.py,sha256=gOrP28lEvOAxAwYIAxMkB3ip-TDxHMuSeHGv975ufrI,10288
 lecrapaud/db/models/feature.py,sha256=5o77O2FyRObnLOCGNj8kaPSGM3pLv1Ov6mXXHYkmnYY,1136
 lecrapaud/db/models/feature_selection.py,sha256=mk42xuw1Sm_7Pznfg7TNc5_S4hscdw79QgIe3Bt9ZRI,3245
 lecrapaud/db/models/feature_selection_rank.py,sha256=Ydsb_rAT58FoSH13wkGjGPByzsjPx3DITXgJ2jgZmow,2198
@@ -39,7 +39,7 @@ lecrapaud/misc/test-gpu-transformers.ipynb,sha256=k6MBSs_Um1h4PykvE-LTBcdpbWLbIF
 lecrapaud/model_selection.py,sha256=vV2oO_fhhJ4dozOQCn_ySJzQT5gMVtQbLR4Wf59bi3A,67885
 lecrapaud/search_space.py,sha256=-JkzuMhaomdwiWi4HvVQY5hiw3-oREemJA16tbwEIp4,34854
 lecrapaud/utils.py,sha256=JdBB1NvbNIx4y0Una-kSZdo1_ZEocc5hwyYFIZKHmGg,8305
-lecrapaud-0.14.8.dist-info/LICENSE,sha256=MImCryu0AnqhJE_uAZD-PIDKXDKb8sT7v0i1NOYeHTM,11350
-lecrapaud-0.14.8.dist-info/METADATA,sha256=6ZreLSTSEwgFC8hpaqA8PInDhL-T20n2uwLGg1Uabu4,11047
-lecrapaud-0.14.8.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-lecrapaud-0.14.8.dist-info/RECORD,,
+lecrapaud-0.15.0.dist-info/LICENSE,sha256=MImCryu0AnqhJE_uAZD-PIDKXDKb8sT7v0i1NOYeHTM,11350
+lecrapaud-0.15.0.dist-info/METADATA,sha256=yHTluJ8CMpXc9feZ6ZQhdoWwdMyR2bD8AImPgVf84uc,11081
+lecrapaud-0.15.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+lecrapaud-0.15.0.dist-info/RECORD,,