Sync from GitHub via hub-sync

artifacts/models/p1_historical_metadata.json

@@ -1,5 +1,6 @@
 {
   "artifact_role": "P1_historical_prediction_model",
+  "runtime_model_role": "historical",
   "training_notebook": "notebooks/experience_1.ipynb",
   "training_script": "scripts/experience_1.py",
   "training_entrypoint": "scripts/experience_1.py",
@@ -12,7 +13,7 @@
   "parameter_grid_size": 3,
   "tuning_stage": "systematic_grid_search",
   "regularization_profile": "parameter_grid_search",
-  "trained_at_utc": "2026-05-08T13:57:00.000704+00:00",
+  "trained_at_utc": "2026-05-10T22:36:57.656730+00:00",
   "dataset_source": "/Users/steph/Code/Python/Jupyter/OCR_Projet12/artifacts/experiments/experience_1/dataset_consolide_historique_colonnes.csv",
   "target_year": 2016,
   "target_column": "target_yield_t_ha_2016",
@@ -105,12 +106,44 @@
   "area_role": "group_only_not_feature",
   "split_strategy": "GroupShuffleSplit(area, test_size=0.2, random_state=42)",
   "metrics": {
-    "test_rmse": 2.0592505240003227,
+    "test_rmse": 2.059250524000323,
     "test_mae": 0.8025563824483579,
     "test_r2": 0.9468391265704531,
-    "cv_val_rmse_mean": 1.5814357123886047,
-    "cv_val_mae_mean": 0.6463164060176476,
+    "cv_val_rmse_mean": 1.581435712388605,
+    "cv_val_mae_mean": 0.6463164060176475,
     "cv_val_r2_mean": 0.9623090308612253
   },
-  "mlflow_run_id": "89a0b166132d4e9f91b8b520eaa34ed3"
+  "mlflow_run_id": "1b8857069dc941109703fbee6fb2b61a",
+  "registered_model_name": "p1_historical_pipeline",
+  "registered_model_version": "7",
+  "registered_model_run_id": "8dee2459e8b84ccba75596514fd5a70a",
+  "model_uri": "models:/p1_historical_pipeline/7",
+  "registry_source_run_id": "8dee2459e8b84ccba75596514fd5a70a",
+  "registered_model_stage": "None",
+  "registered_model_source": "models:/m-45ba375e4c5345adad84f2ea32d9df9f",
+  "tracking_uri": "sqlite:////Users/steph/Code/Python/Jupyter/OCR_Projet12/artifacts/mlflow.db",
+  "exported_at_utc": "2026-05-10T22:37:27.427985+00:00",
+  "artifact_path": "artifacts/models/p1_historical_pipeline.joblib",
+  "metadata_path": "artifacts/models/p1_historical_metadata.json",
+  "output_path": "artifacts/models/p1_historical_pipeline.joblib",
+  "output_metadata_path": "artifacts/models/p1_historical_metadata.json",
+  "role": "historical",
+  "source_run_name": "experience_1__runtime_historical",
+  "source_experiment_id": "4",
+  "source_run_metrics": {
+    "test_rmse": 2.059250524000323,
+    "test_mae": 0.8025563824483579,
+    "test_r2": 0.9468391265704531,
+    "cv_val_rmse_mean": 1.581435712388605,
+    "cv_val_mae_mean": 0.6463164060176475,
+    "cv_val_r2_mean": 0.9623090308612253
+  },
+  "source_run_params": {
+    "experience_name": "experience_1",
+    "runtime_model_role": "historical",
+    "registered_model_name": "p1_historical_pipeline",
+    "training_entrypoint": "scripts/experience_1.py",
+    "target_year": "2016",
+    "best_candidate_model_name": "random_forest_search_01"
+  }
 }

artifacts/models/p1_historical_pipeline.joblib

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:edbb02f829fbb315e6c51ea7a64c856da2e3585fe6b50a9a3e40b671f41200f4
-size 3646243
+oid sha256:807b6071dc5a98528ac45dc0a799af64bfa0ace91f3d855eb392adce5a529242
+size 3646451

artifacts/models/p23_simulation_metadata.json

@@ -1,6 +1,6 @@
 {
   "model_name": "linear_regression",
-  "trained_at_utc": "2026-05-08T13:57:01.647971+00:00",
+  "trained_at_utc": "2026-05-10T22:37:15.882903+00:00",
   "dataset_source": "data/simulation/crop_yield.csv",
   "feature_columns": [
     "region",
@@ -22,5 +22,36 @@
     "test_r2": 0.9139501848982343
   },
   "strategy": "2_models_3_predictions_combined",
-  "role": "local_adjustment_model_for_P2_and_P3"
+  "role": "simulation",
+  "runtime_model_role": "simulation",
+  "registered_model_name": "p23_simulation_pipeline",
+  "registered_model_version": "6",
+  "registered_model_run_id": "7a9fc5eba2a146058618994287c53538",
+  "model_uri": "models:/p23_simulation_pipeline/6",
+  "registered_model_stage": "None",
+  "registered_model_source": "models:/m-1d4b5fa94ca945809af904589800a72a",
+  "tracking_uri": "sqlite:////Users/steph/Code/Python/Jupyter/OCR_Projet12/artifacts/mlflow.db",
+  "exported_at_utc": "2026-05-10T22:37:27.484951+00:00",
+  "artifact_path": "artifacts/models/p23_simulation_pipeline.joblib",
+  "metadata_path": "artifacts/models/p23_simulation_metadata.json",
+  "output_path": "artifacts/models/p23_simulation_pipeline.joblib",
+  "output_metadata_path": "artifacts/models/p23_simulation_metadata.json",
+  "source_run_name": "simulation_runtime__runtime_model",
+  "source_experiment_id": "5",
+  "source_run_metrics": {
+    "train_rmse": 0.49987819477652967,
+    "train_mae": 0.39889442485099674,
+    "train_r2": 0.9130634145187704,
+    "test_rmse": 0.49668933266948173,
+    "test_mae": 0.39606497055687334,
+    "test_r2": 0.9139501848982343
+  },
+  "source_run_params": {
+    "runtime_model_role": "simulation",
+    "registered_model_name": "p23_simulation_pipeline",
+    "training_entrypoint": "scripts/train_simulation_model.py",
+    "model_name": "linear_regression",
+    "dataset_source": "data/simulation/crop_yield.csv",
+    "sample_size": "200000"
+  }
 }

artifacts/models/p23_simulation_pipeline.joblib

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:592f4e1bc4c3edca2960f59b5daea515a5bc845ce4117de327d1e8c0280509b7
-size 4820
+oid sha256:bb2405e6848232fddcd2a15c44384decf4f0b3d98f2d5b0e948296f172c34ec7
+size 4870

scripts/deployment_payload.py

@@ -9,15 +9,23 @@ from __future__ import annotations
 import argparse
 from pathlib import Path
 import shutil
+import sys
 
 
 PROJECT_ROOT = Path(__file__).resolve().parents[1]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from scripts.runtime_model_specs import (
+    HISTORICAL_RUNTIME_MODEL_SPEC,
+    SIMULATION_RUNTIME_MODEL_SPEC,
+)
 
 DEPLOYMENT_REQUIRED_ARTIFACTS = [
-    Path("artifacts/models/p1_historical_pipeline.joblib"),
-    Path("artifacts/models/p1_historical_metadata.json"),
-    Path("artifacts/models/p23_simulation_pipeline.joblib"),
-    Path("artifacts/models/p23_simulation_metadata.json"),
+    HISTORICAL_RUNTIME_MODEL_SPEC.output_model_path.relative_to(PROJECT_ROOT),
+    HISTORICAL_RUNTIME_MODEL_SPEC.output_metadata_path.relative_to(PROJECT_ROOT),
+    SIMULATION_RUNTIME_MODEL_SPEC.output_model_path.relative_to(PROJECT_ROOT),
+    SIMULATION_RUNTIME_MODEL_SPEC.output_metadata_path.relative_to(PROJECT_ROOT),
     Path("artifacts/experiments/experience_1/dataset_consolide_historique_colonnes.csv"),
 ]
 
@@ -44,10 +52,22 @@ PAYLOAD_FILE_SPECS = [
     (Path("data/dataset_consolide.csv"), Path("data/dataset_consolide.csv")),
     (Path("data/simulation/crop_yield.csv"), Path("data/simulation/crop_yield.csv")),
     (Path("main.py"), Path("main.py")),
-    (Path("artifacts/models/p1_historical_pipeline.joblib"), Path("artifacts/models/p1_historical_pipeline.joblib")),
-    (Path("artifacts/models/p1_historical_metadata.json"), Path("artifacts/models/p1_historical_metadata.json")),
-    (Path("artifacts/models/p23_simulation_pipeline.joblib"), Path("artifacts/models/p23_simulation_pipeline.joblib")),
-    (Path("artifacts/models/p23_simulation_metadata.json"), Path("artifacts/models/p23_simulation_metadata.json")),
+    (
+        HISTORICAL_RUNTIME_MODEL_SPEC.output_model_path.relative_to(PROJECT_ROOT),
+        HISTORICAL_RUNTIME_MODEL_SPEC.output_model_path.relative_to(PROJECT_ROOT),
+    ),
+    (
+        HISTORICAL_RUNTIME_MODEL_SPEC.output_metadata_path.relative_to(PROJECT_ROOT),
+        HISTORICAL_RUNTIME_MODEL_SPEC.output_metadata_path.relative_to(PROJECT_ROOT),
+    ),
+    (
+        SIMULATION_RUNTIME_MODEL_SPEC.output_model_path.relative_to(PROJECT_ROOT),
+        SIMULATION_RUNTIME_MODEL_SPEC.output_model_path.relative_to(PROJECT_ROOT),
+    ),
+    (
+        SIMULATION_RUNTIME_MODEL_SPEC.output_metadata_path.relative_to(PROJECT_ROOT),
+        SIMULATION_RUNTIME_MODEL_SPEC.output_metadata_path.relative_to(PROJECT_ROOT),
+    ),
     (
         Path("artifacts/experiments/experience_1/dataset_consolide_historique_colonnes.csv"),
         Path("artifacts/experiments/experience_1/dataset_consolide_historique_colonnes.csv"),

scripts/experience_1.py

@@ -44,13 +44,20 @@ PROJECT_ROOT = Path(__file__).resolve().parents[1]
 if str(PROJECT_ROOT) not in sys.path:
     sys.path.insert(0, str(PROJECT_ROOT))
 
-from scripts.mlflow_logging import log_named_sklearn_model
+from scripts.mlflow_logging import log_and_register_sklearn_model, log_named_sklearn_model
+from scripts.mlflow_config import (
+    DEFAULT_MLFLOW_TRACKING_URI,
+    EXPERIENCE_1_EXPERIMENT_NAME,
+    mlflow_artifacts_dir_for_tracking_uri,
+    normalize_tracking_uri,
+)
 from scripts.project_config import DEFAULT_CONFIG_PATH, load_preparation_config
+from scripts.runtime_model_specs import HISTORICAL_RUNTIME_MODEL_SPEC
 
 
 SEED = 42
 CV_N_SPLITS = 4
-MLFLOW_EXPERIMENT_NAME = "experience_1"
+MLFLOW_EXPERIMENT_NAME = EXPERIENCE_1_EXPERIMENT_NAME
 SEARCH_SPACE_DEFINITION = {
     "search_method": "parameter_grid",
     "scope": "all_candidate_families",
@@ -310,9 +317,9 @@ def build_experience_paths(
     cv_dir.mkdir(parents=True, exist_ok=True)
     models_dir.mkdir(parents=True, exist_ok=True)
 
-    resolved_tracking_uri = tracking_uri or f"sqlite:///{(artifacts_dir / 'mlflow.db').resolve()}"
+    resolved_tracking_uri = normalize_tracking_uri(tracking_uri or DEFAULT_MLFLOW_TRACKING_URI)
     mlflow_db_path = Path(resolved_tracking_uri.removeprefix("sqlite:///")).resolve()
-    mlflow_artifacts_dir = artifacts_dir / "mlruns"
+    mlflow_artifacts_dir = mlflow_artifacts_dir_for_tracking_uri(resolved_tracking_uri)
     mlflow_experiment_artifact_dir = mlflow_artifacts_dir / MLFLOW_EXPERIMENT_NAME
     mlflow_experiment_artifact_dir.mkdir(parents=True, exist_ok=True)
 
@@ -1246,6 +1253,7 @@ def export_p1_artifact(
 
     p1_metadata = {
         "artifact_role": "P1_historical_prediction_model",
+        "runtime_model_role": HISTORICAL_RUNTIME_MODEL_SPEC.role,
         "training_notebook": "notebooks/experience_1.ipynb",
         "training_script": "scripts/experience_1.py",
         "training_entrypoint": "scripts/experience_1.py",
@@ -1277,6 +1285,41 @@ def export_p1_artifact(
         "mlflow_run_id": str(results_df.loc[0, "run_id"]) if "run_id" in results_df.columns else None,
     }
 
+    with mlflow.start_run(run_name=f"{MLFLOW_EXPERIMENT_NAME}__runtime_historical") as runtime_run:
+        mlflow.log_param("experience_name", MLFLOW_EXPERIMENT_NAME)
+        mlflow.log_param("runtime_model_role", HISTORICAL_RUNTIME_MODEL_SPEC.role)
+        mlflow.log_param("registered_model_name", HISTORICAL_RUNTIME_MODEL_SPEC.registered_model_name)
+        mlflow.log_param("training_entrypoint", "scripts/experience_1.py")
+        mlflow.log_param("target_year", context.target_year)
+        mlflow.log_param("best_candidate_model_name", best_model_name)
+        mlflow.log_metric("test_rmse", p1_metadata["metrics"]["test_rmse"])
+        mlflow.log_metric("test_mae", p1_metadata["metrics"]["test_mae"])
+        mlflow.log_metric("test_r2", p1_metadata["metrics"]["test_r2"])
+        mlflow.log_metric("cv_val_rmse_mean", p1_metadata["metrics"]["cv_val_rmse_mean"])
+        mlflow.log_metric("cv_val_mae_mean", p1_metadata["metrics"]["cv_val_mae_mean"])
+        mlflow.log_metric("cv_val_r2_mean", p1_metadata["metrics"]["cv_val_r2_mean"])
+        mlflow.log_artifact(str(paths.dataset_path))
+        mlflow.log_artifact(str(paths.model_results_path))
+        runtime_registration = log_and_register_sklearn_model(
+            p1_pipeline,
+            artifact_name=HISTORICAL_RUNTIME_MODEL_SPEC.registered_model_name,
+            registered_model_name=HISTORICAL_RUNTIME_MODEL_SPEC.registered_model_name,
+            model_metadata={
+                "runtime_model_role": HISTORICAL_RUNTIME_MODEL_SPEC.role,
+                "training_entrypoint": "scripts/experience_1.py",
+            },
+        )
+
+    p1_metadata.update(
+        {
+            "registered_model_name": runtime_registration["registered_model_name"],
+            "registered_model_version": runtime_registration["registered_model_version"],
+            "registered_model_run_id": runtime_registration["run_id"],
+            "model_uri": runtime_registration["model_uri"],
+            "registry_source_run_id": runtime_run.info.run_id,
+        }
+    )
+
     joblib.dump(p1_pipeline, paths.p1_model_path)
     paths.p1_metadata_path.write_text(
         json.dumps(p1_metadata, indent=2, ensure_ascii=True),
@@ -1305,7 +1348,7 @@ def run_experience_1(
     """
     resolved_config_path = Path(config_path) if config_path is not None else DEFAULT_CONFIG_PATH
     config = load_preparation_config(resolved_config_path, ensure_dirs=True)
-    resolved_tracking_uri = tracking_uri or f"sqlite:///{(Path(config['ARTIFACTS_DIR']) / 'mlflow.db').resolve()}"
+    resolved_tracking_uri = normalize_tracking_uri(tracking_uri or DEFAULT_MLFLOW_TRACKING_URI)
     paths = build_experience_paths(
         artifacts_dir=Path(config["ARTIFACTS_DIR"]),
         tracking_uri=resolved_tracking_uri,
@@ -1362,6 +1405,10 @@ def run_experience_1(
         "best_test_rmse": float(results_df.loc[0, "test_rmse"]),
         "best_test_r2": float(results_df.loc[0, "test_r2"]),
         "tracked_models": list(results_df["model"]),
+        "registered_model_name": p1_metadata.get("registered_model_name"),
+        "registered_model_version": p1_metadata.get("registered_model_version"),
+        "registered_model_run_id": p1_metadata.get("registered_model_run_id"),
+        "model_uri": p1_metadata.get("model_uri"),
         "p1_metadata": p1_metadata,
     }
 

scripts/mlflow_config.py

@@ -0,0 +1,55 @@
+"""Configuration MLflow commune aux scripts et a l'interface locale."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+MLFLOW_DB_PATH = (PROJECT_ROOT / "artifacts" / "mlflow.db").resolve()
+MLFLOW_ARTIFACTS_DIR = (PROJECT_ROOT / "artifacts" / "mlruns").resolve()
+DEFAULT_MLFLOW_TRACKING_URI = f"sqlite:///{MLFLOW_DB_PATH}"
+
+EXPERIENCE_1_EXPERIMENT_NAME = "experience_1"
+SIMULATION_RUNTIME_EXPERIMENT_NAME = "simulation_runtime"
+FULL_PIPELINE_EXPERIMENT_NAME = "run_full_pipeline"
+
+
+def normalize_tracking_uri(tracking_uri: str | None = None) -> str:
+    """Retourne un tracking URI MLflow stable depuis la racine du projet."""
+    resolved_uri = tracking_uri or DEFAULT_MLFLOW_TRACKING_URI
+    if not resolved_uri.startswith("sqlite:///"):
+        return resolved_uri
+
+    db_path = Path(resolved_uri.removeprefix("sqlite:///"))
+    if not db_path.is_absolute():
+        db_path = (PROJECT_ROOT / db_path).resolve()
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    return f"sqlite:///{db_path}"
+
+
+def ensure_mlflow_directories() -> None:
+    """Cree les dossiers MLflow attendus par le projet."""
+    MLFLOW_DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    MLFLOW_ARTIFACTS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def mlflow_artifacts_dir_for_tracking_uri(tracking_uri: str | None = None) -> Path:
+    """Retourne la racine d'artefacts adaptee au tracking URI fourni."""
+    resolved_uri = normalize_tracking_uri(tracking_uri)
+    if resolved_uri == DEFAULT_MLFLOW_TRACKING_URI:
+        artifact_root = MLFLOW_ARTIFACTS_DIR
+    elif resolved_uri.startswith("sqlite:///"):
+        artifact_root = Path(resolved_uri.removeprefix("sqlite:///")).resolve().parent / "mlruns"
+    else:
+        artifact_root = MLFLOW_ARTIFACTS_DIR
+
+    artifact_root.mkdir(parents=True, exist_ok=True)
+    return artifact_root
+
+
+def experiment_artifact_location(experiment_name: str, tracking_uri: str | None = None) -> str:
+    """Retourne l'emplacement d'artefacts standard d'une experience MLflow."""
+    artifact_dir = mlflow_artifacts_dir_for_tracking_uri(tracking_uri) / experiment_name
+    artifact_dir.mkdir(parents=True, exist_ok=True)
+    return artifact_dir.resolve().as_uri()

scripts/mlflow_logging.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 from pathlib import Path
 from typing import Any
 
@@ -10,6 +11,30 @@ import mlflow
 import mlflow.pyfunc
 import mlflow.sklearn
 import pandas as pd
+from mlflow.tracking import MlflowClient
+
+
+SKLEARN_PICKLE_WARNING_PREFIX = (
+    "Saving scikit-learn models in the pickle or cloudpickle format requires exercising caution"
+)
+
+
+class _SuppressSklearnPickleWarning(logging.Filter):
+    """Filtre le warning MLflow repete sur la serialisation pickle/cloudpickle."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Retourne `False` uniquement pour le warning verbeux attendu."""
+        return SKLEARN_PICKLE_WARNING_PREFIX not in record.getMessage()
+
+
+def configure_mlflow_sklearn_logging() -> None:
+    """Rend les logs MLflow sklearn lisibles pendant les entrainements longs."""
+    logger = logging.getLogger("mlflow.sklearn")
+    if not any(isinstance(item, _SuppressSklearnPickleWarning) for item in logger.filters):
+        logger.addFilter(_SuppressSklearnPickleWarning())
+
+
+configure_mlflow_sklearn_logging()
 
 
 def sanitize_logged_model_name(raw_name: str) -> str:
@@ -53,6 +78,89 @@ def log_named_sklearn_model(estimator: Any, *, model_name: str) -> str:
     return logged_model_name
 
 
+def _registered_model_version_sort_key(version: Any) -> tuple[int, str]:
+    """Produit une cle de tri robuste pour les versions du registry MLflow."""
+    raw_version = str(getattr(version, "version", version))
+    return (int(raw_version), raw_version) if raw_version.isdigit() else (-1, raw_version)
+
+
+def resolve_registered_model_version_for_run(
+    *,
+    registered_model_name: str,
+    run_id: str,
+    tracking_uri: str | None = None,
+) -> Any:
+    """Recupere la version du registry associee a un run MLflow donne.
+
+    Args:
+        registered_model_name: Nom du registered model a inspecter.
+        run_id: Identifiant du run source.
+        tracking_uri: Tracking URI MLflow optionnel.
+
+    Returns:
+        Any: Objet version retourne par le client MLflow.
+    """
+    client = MlflowClient(tracking_uri=tracking_uri)
+    versions = [
+        version
+        for version in client.search_model_versions(f"name = '{registered_model_name}'")
+        if str(getattr(version, "run_id", "")) == str(run_id)
+    ]
+    if not versions:
+        raise RuntimeError(
+            "Registered model version could not be resolved for "
+            f"model={registered_model_name!r} and run_id={run_id!r}."
+        )
+    return max(versions, key=_registered_model_version_sort_key)
+
+
+def log_and_register_sklearn_model(
+    estimator: Any,
+    *,
+    artifact_name: str,
+    registered_model_name: str,
+    model_metadata: dict[str, Any] | None = None,
+    await_registration_for: int = 300,
+) -> dict[str, str]:
+    """Journalise un estimateur et l'enregistre comme registered model MLflow.
+
+    Args:
+        estimator: Estimateur scikit-learn a enregistrer.
+        artifact_name: Nom de l'artefact de run.
+        registered_model_name: Nom du registered model cible.
+        model_metadata: Metadonnees MLflow optionnelles.
+        await_registration_for: Duree d'attente maximale de l'enregistrement.
+
+    Returns:
+        dict[str, str]: Contexte de registry resolu apres l'enregistrement.
+    """
+    active_run = mlflow.active_run()
+    if active_run is None:
+        raise RuntimeError("An active MLflow run is required before registering a model.")
+
+    logged_model_name = sanitize_logged_model_name(artifact_name)
+    model_info = mlflow.sklearn.log_model(
+        estimator,
+        name=logged_model_name,
+        registered_model_name=registered_model_name,
+        metadata=model_metadata,
+        await_registration_for=await_registration_for,
+    )
+    resolved_version = resolve_registered_model_version_for_run(
+        registered_model_name=registered_model_name,
+        run_id=active_run.info.run_id,
+        tracking_uri=mlflow.get_tracking_uri(),
+    )
+    return {
+        "logged_model_name": logged_model_name,
+        "registered_model_name": registered_model_name,
+        "registered_model_version": str(resolved_version.version),
+        "model_uri": f"models:/{registered_model_name}/{resolved_version.version}",
+        "run_id": active_run.info.run_id,
+        "logged_model_uri": str(getattr(model_info, "model_uri", "")),
+    }
+
+
 class EvaluationPredictionLookupModel(mlflow.pyfunc.PythonModel):
     """MLflow pyfunc model exposing precomputed evaluation predictions by key lookup.
 

scripts/prediction_adjustment.py

@@ -24,15 +24,19 @@ from sklearn.model_selection import train_test_split
 from sklearn.pipeline import Pipeline
 from sklearn.preprocessing import OneHotEncoder
 
+from scripts.runtime_model_specs import (
+    HISTORICAL_RUNTIME_MODEL_SPEC,
+    SIMULATION_RUNTIME_MODEL_SPEC,
+)
 from scripts.simulation_dataset import load_normalized_simulation_dataset
 
 PROJECT_ROOT = Path(__file__).resolve().parents[1]
 HISTORICAL_WIDE_DATASET_PATH = PROJECT_ROOT / "artifacts/experiments/experience_1/dataset_consolide_historique_colonnes.csv"
-HISTORICAL_MODEL_PATH = PROJECT_ROOT / "artifacts/models/p1_historical_pipeline.joblib"
-HISTORICAL_METADATA_PATH = PROJECT_ROOT / "artifacts/models/p1_historical_metadata.json"
+HISTORICAL_MODEL_PATH = HISTORICAL_RUNTIME_MODEL_SPEC.output_model_path
+HISTORICAL_METADATA_PATH = HISTORICAL_RUNTIME_MODEL_SPEC.output_metadata_path
 SIMULATION_DATASET_PATH = PROJECT_ROOT / "data/simulation/crop_yield.csv"
-SIMULATION_MODEL_PATH = PROJECT_ROOT / "artifacts/models/p23_simulation_pipeline.joblib"
-SIMULATION_METADATA_PATH = PROJECT_ROOT / "artifacts/models/p23_simulation_metadata.json"
+SIMULATION_MODEL_PATH = SIMULATION_RUNTIME_MODEL_SPEC.output_model_path
+SIMULATION_METADATA_PATH = SIMULATION_RUNTIME_MODEL_SPEC.output_metadata_path
 
 SEED = 42
 SIMULATION_SAMPLE_SIZE = 200_000

scripts/project_config.py

@@ -1,4 +1,4 @@
-"""Centralise le chargement de la configuration de preparation du projet."""
+"""Centralise le chargement de la configuration de préparation du projet."""
 
 from pathlib import Path
 
@@ -10,7 +10,7 @@ DEFAULT_CONFIG_PATH = PROJECT_ROOT / "config" / "project_paths.yaml"
 
 
 def _resolve_path(raw_path: str) -> Path:
-    """Resout un chemin de configuration relativement a la racine du projet."""
+    """Résout un chemin de configuration relativement à la racine du projet."""
     path = Path(raw_path)
     if path.is_absolute():
         return path
@@ -18,13 +18,13 @@ def _resolve_path(raw_path: str) -> Path:
 
 
 def ensure_preparation_directories(config: dict[str, object]) -> dict[str, object]:
-    """Cree les dossiers cibles attendus par la preparation.
+    """Crée les dossiers cibles attendus par la préparation.
 
     Args:
         config: Configuration chargee depuis `project_paths.yaml`.
 
     Returns:
-        dict[str, object]: Configuration inchangee, pour permettre le chainage.
+        dict[str, object]: Configuration inchangée, pour permettre le chainage.
     """
     artifacts_dir = config["ARTIFACTS_DIR"]
     pca_artifacts_dir = config["PCA_ARTIFACTS_DIR"]
@@ -45,14 +45,14 @@ def load_preparation_config(
     *,
     ensure_dirs: bool = False,
 ) -> dict[str, object]:
-    """Charge la configuration de preparation depuis le fichier YAML du projet.
+    """Charge la configuration de préparation depuis le fichier YAML du projet.
 
     Args:
         config_path: Chemin optionnel vers un fichier YAML de configuration.
-        ensure_dirs: Cree les dossiers cibles si `True`.
+        ensure_dirs: Crée les dossiers cibles si `True`.
 
     Returns:
-        dict[str, object]: Configuration normalisee avec des `Path` resolus.
+        dict[str, object]: Configuration normalisée avec des `Path` résolus.
     """
     path = config_path or DEFAULT_CONFIG_PATH
     raw_config = yaml.safe_load(path.read_text())

scripts/promote_registered_model.py

@@ -1,12 +1,9 @@
-"""Exporte un registered model MLflow vers un artefact local versionne.
-
-Le script applique volontairement une selection stricte du modele source pour
-eviter les exports ambigus quand le registre MLflow contient plusieurs modeles.
-"""
+"""Promouvoit les deux registered models runtime depuis MLflow vers le disque."""
 
 from __future__ import annotations
 
 import argparse
+from dataclasses import replace
 from datetime import datetime, timezone
 import json
 from pathlib import Path
@@ -17,45 +14,71 @@ import mlflow
 import mlflow.sklearn
 from mlflow.tracking import MlflowClient
 
-
-PROJECT_ROOT = Path(__file__).resolve().parents[1]
-DEFAULT_TRACKING_URI = f"sqlite:///{(PROJECT_ROOT / 'artifacts' / 'mlflow.db').resolve()}"
-DEFAULT_MODEL_OUTPUT_PATH = PROJECT_ROOT / "artifacts" / "models" / "best_pipeline.joblib"
-DEFAULT_METADATA_OUTPUT_PATH = PROJECT_ROOT / "artifacts" / "models" / "best_pipeline_metadata.json"
+from scripts.mlflow_config import normalize_tracking_uri
+from scripts.runtime_model_specs import (
+    DEFAULT_MLFLOW_TRACKING_URI,
+    DEFAULT_MODELS_DIR,
+    HISTORICAL_RUNTIME_MODEL_SPEC,
+    RuntimeModelSpec,
+    SIMULATION_RUNTIME_MODEL_SPEC,
+)
+
+
+REQUIRED_RUNTIME_METADATA_FIELDS = {
+    "runtime_model_role",
+    "registered_model_name",
+    "registered_model_version",
+    "registered_model_run_id",
+    "model_uri",
+    "tracking_uri",
+    "exported_at_utc",
+    "artifact_path",
+    "metadata_path",
+}
 
 
 def parse_args() -> argparse.Namespace:
-    """Construit l'interface en ligne de commande du script d'export."""
+    """Construit l'interface CLI du script de promotion runtime."""
     parser = argparse.ArgumentParser(
         description=(
-            "Exporte un registered model MLflow vers artifacts/models/best_pipeline.joblib. "
-            "Sans --registered-model, le script n'accepte qu'un seul registered model dans le registre."
+            "Promote the two MLflow registered models used by the FastAPI runtime "
+            "and export them to artifacts/models/."
         )
     )
     parser.add_argument(
         "--tracking-uri",
-        default=DEFAULT_TRACKING_URI,
+        default=DEFAULT_MLFLOW_TRACKING_URI,
         help="Tracking URI MLflow. Par defaut: base SQLite locale du projet.",
     )
     parser.add_argument(
-        "--registered-model",
+        "--models-dir",
+        default=str(DEFAULT_MODELS_DIR),
+        help="Dossier cible pour les artefacts runtime exportes.",
+    )
+    parser.add_argument(
+        "--historical-registered-model",
         default=None,
-        help="Nom du registered model MLflow a exporter.",
+        help="Nom du registered model historique a exporter.",
     )
     parser.add_argument(
-        "--version",
+        "--historical-version",
         default=None,
-        help="Version du registered model a exporter. Par defaut: derniere version disponible.",
+        help="Version MLflow du modele historique a exporter.",
     )
     parser.add_argument(
-        "--output-model-path",
-        default=str(DEFAULT_MODEL_OUTPUT_PATH),
-        help="Chemin de sortie du pipeline joblib exporte.",
+        "--simulation-registered-model",
+        default=None,
+        help="Nom du registered model local/simulation a exporter.",
+    )
+    parser.add_argument(
+        "--simulation-version",
+        default=None,
+        help="Version MLflow du modele local/simulation a exporter.",
     )
     parser.add_argument(
-        "--output-metadata-path",
-        default=str(DEFAULT_METADATA_OUTPUT_PATH),
-        help="Chemin de sortie des metadonnees JSON.",
+        "--json",
+        action="store_true",
+        help="Imprime le resume de promotion au format JSON.",
     )
     return parser.parse_args()
 
@@ -64,73 +87,114 @@ def project_relative_path(path: Path) -> str:
     """Retourne un chemin relatif au projet si possible."""
     resolved = path.resolve()
     try:
-        return str(resolved.relative_to(PROJECT_ROOT))
+        return str(resolved.relative_to(Path(__file__).resolve().parents[1]))
     except ValueError:
         return str(resolved)
 
 
+def json_ready(value: Any) -> Any:
+    """Convertit recursivement les types Python en valeurs serialisables JSON."""
+    if isinstance(value, dict):
+        return {str(key): json_ready(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [json_ready(item) for item in value]
+    if isinstance(value, tuple):
+        return [json_ready(item) for item in value]
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, datetime):
+        return value.isoformat()
+    return value
+
+
 def normalize_registered_model_names(models: list[Any]) -> list[str]:
     """Extrait et trie les noms de registered models MLflow."""
     return sorted(str(model.name) for model in models)
 
 
-def resolve_registered_model_name(available_names: list[str], requested_name: str | None = None) -> str:
-    """Selectionne un registered model de maniere non ambigue.
+def with_models_dir(spec: RuntimeModelSpec, models_dir: Path) -> RuntimeModelSpec:
+    """Construit une specification identique avec un dossier cible surcharge."""
+    return replace(
+        spec,
+        output_model_path=models_dir / spec.output_model_path.name,
+        output_metadata_path=models_dir / spec.output_metadata_path.name,
+    )
 
-    Args:
-        available_names: Noms presents dans le registre MLflow.
-        requested_name: Nom explicitement demande, si fourni.
 
-    Returns:
-        str: Nom du registered model retenu.
-    """
-    if requested_name:
+def resolve_registered_model_name_for_role(
+    *,
+    role_spec: RuntimeModelSpec,
+    available_names: list[str],
+    requested_name: str | None = None,
+) -> str:
+    """Selectionne le registered model a promouvoir pour un role donne."""
+    if requested_name is not None:
         if requested_name not in available_names:
-            available = ", ".join(available_names) if available_names else "aucun"
+            available = ", ".join(available_names) if available_names else "none"
             raise ValueError(
-                f"Registered model introuvable: {requested_name}. "
-                f"Modeles disponibles: {available}."
+                f"Requested registered model {requested_name!r} for role "
+                f"{role_spec.role!r} was not found. Available registered models: {available}."
             )
         return requested_name
 
-    if not available_names:
+    matching_names = [name for name in available_names if name == role_spec.registered_model_name]
+    if not matching_names:
         raise ValueError(
-            "Aucun registered model MLflow trouvé. "
-            "Sélectionnez d'abord un registered model avec --registered-model."
+            f"No MLflow registered model found for role {role_spec.role!r}. "
+            f"Expected one of: {role_spec.registered_model_name}."
         )
-
-    if len(available_names) > 1:
-        available = ", ".join(available_names)
+    if len(matching_names) > 1:
         raise ValueError(
-            "Plusieurs registered models MLflow trouvés. "
-            f"Sélectionnez explicitement un registered model avec --registered-model. "
-            f"Modeles disponibles: {available}."
+            f"Multiple candidate registered models found for role {role_spec.role!r}. "
+            f"Please pass --{role_spec.role}-registered-model."
         )
-
-    return available_names[0]
+    return matching_names[0]
 
 
-def _version_sort_key(version: str) -> tuple[int, str]:
+def _version_sort_key(version: Any) -> tuple[int, str]:
     """Produit une cle de tri robuste pour les versions MLflow."""
-    value = str(version)
-    return (int(value), value) if value.isdigit() else (-1, value)
+    raw_value = str(getattr(version, "version", version))
+    return (int(raw_value), raw_value) if raw_value.isdigit() else (-1, raw_value)
 
 
-def resolve_model_version(versions: list[Any], requested_version: str | None = None) -> Any:
-    """Selectionne la version a exporter pour un registered model donne."""
+def resolve_model_version_for_role(
+    versions: list[Any],
+    *,
+    role_spec: RuntimeModelSpec,
+    registered_model_name: str,
+    requested_version: str | None = None,
+    allow_latest_version: bool = False,
+) -> Any:
+    """Selectionne strictement la version a exporter pour un role runtime."""
     if requested_version is not None:
         for version in versions:
             if str(version.version) == str(requested_version):
                 return version
-        available = ", ".join(str(version.version) for version in versions) if versions else "aucune"
+        available = ", ".join(str(version.version) for version in versions) if versions else "none"
         raise ValueError(
-            f"Version introuvable: {requested_version}. Versions disponibles: {available}."
+            f"Requested version {requested_version!r} for role {role_spec.role!r} and "
+            f"registered model {registered_model_name!r} does not exist. "
+            f"Available versions: {available}."
         )
 
     if not versions:
-        raise ValueError("Aucune version disponible pour le registered model sélectionné.")
+        raise ValueError(
+            f"Registered model exists but no version could be resolved for role "
+            f"{role_spec.role!r}."
+        )
+
+    if allow_latest_version:
+        return max(versions, key=_version_sort_key)
+
+    if len(versions) > 1:
+        available = ", ".join(str(version.version) for version in sorted(versions, key=_version_sort_key))
+        raise ValueError(
+            f"Multiple versions are available for role {role_spec.role!r} and "
+            f"registered model {registered_model_name!r}. "
+            f"Please pass --{role_spec.role}-version. Available versions: {available}."
+        )
 
-    return max(versions, key=lambda version: _version_sort_key(str(version.version)))
+    return versions[0]
 
 
 def read_json_if_exists(path: Path) -> dict[str, Any]:
@@ -140,48 +204,49 @@ def read_json_if_exists(path: Path) -> dict[str, Any]:
     return json.loads(path.read_text(encoding="utf-8"))
 
 
-def json_ready(value: Any) -> Any:
-    """Convertit recursivement les types Python en valeurs serialisables JSON."""
-    if isinstance(value, dict):
-        return {str(key): json_ready(item) for key, item in value.items()}
-    if isinstance(value, list):
-        return [json_ready(item) for item in value]
-    if isinstance(value, tuple):
-        return [json_ready(item) for item in value]
-    if isinstance(value, Path):
-        return str(value)
-    if isinstance(value, datetime):
-        return value.isoformat()
-    return value
+def export_registered_model(
+    *,
+    tracking_uri: str,
+    registered_model_name: str,
+    model_version: Any,
+    model_output_path: Path,
+) -> None:
+    """Charge un modele depuis MLflow et l'exporte en `joblib` local."""
+    mlflow.set_tracking_uri(tracking_uri)
+    model_uri = f"models:/{registered_model_name}/{model_version.version}"
+    estimator = mlflow.sklearn.load_model(model_uri)
+    model_output_path.parent.mkdir(parents=True, exist_ok=True)
+    joblib.dump(estimator, model_output_path)
+
+
+def validate_exported_artifact(model_output_path: Path) -> None:
+    """Verifie que l'artefact joblib exporte existe et est rechargeable."""
+    if not model_output_path.exists():
+        raise RuntimeError(f"Exported artifact is missing or cannot be loaded: {model_output_path}")
+    try:
+        joblib.load(model_output_path)
+    except Exception as exc:  # pragma: no cover - defensive branch
+        raise RuntimeError(
+            f"Exported artifact is missing or cannot be loaded: {model_output_path}"
+        ) from exc
 
 
 def build_export_metadata(
     *,
     existing_metadata: dict[str, Any],
+    role_spec: RuntimeModelSpec,
     registered_model_name: str,
     model_version: Any,
     tracking_uri: str,
     model_output_path: Path,
+    metadata_output_path: Path,
     source_run: Any | None,
 ) -> dict[str, Any]:
-    """Construit les metadonnees de tracabilite de l'export local.
-
-    Args:
-        existing_metadata: Metadonnees deja presentes sur disque.
-        registered_model_name: Nom du registered model exporte.
-        model_version: Version MLflow exportee.
-        tracking_uri: Tracking URI source.
-        model_output_path: Chemin du joblib genere.
-        source_run: Run MLflow source, si disponible.
-
-    Returns:
-        dict[str, Any]: Metadonnees consolidees de l'export.
-    """
+    """Construit les metadonnees de tracabilite de l'export runtime."""
     metadata = dict(existing_metadata)
-
     metadata.update(
         {
-            "artifact_role": "mlflow_registered_model_export",
+            "runtime_model_role": role_spec.role,
             "registered_model_name": registered_model_name,
             "registered_model_version": str(model_version.version),
             "registered_model_stage": str(getattr(model_version, "current_stage", "None") or "None"),
@@ -191,8 +256,10 @@ def build_export_metadata(
             "tracking_uri": tracking_uri,
             "exported_at_utc": datetime.now(timezone.utc).isoformat(),
             "artifact_path": project_relative_path(model_output_path),
-            "used_by_final_api": False,
-            "consumer": "single_model_export_pipeline",
+            "metadata_path": project_relative_path(metadata_output_path),
+            "output_path": project_relative_path(model_output_path),
+            "output_metadata_path": project_relative_path(metadata_output_path),
+            "role": role_spec.role,
         }
     )
 
@@ -207,69 +274,163 @@ def build_export_metadata(
     return metadata
 
 
-def export_registered_model(
-    *,
-    tracking_uri: str,
-    registered_model_name: str,
-    model_version: Any,
-    model_output_path: Path,
-) -> None:
-    """Charge un modele depuis MLflow et l'exporte en `joblib` local."""
-    mlflow.set_tracking_uri(tracking_uri)
-    model_uri = f"models:/{registered_model_name}/{model_version.version}"
-    estimator = mlflow.sklearn.load_model(model_uri)
-    model_output_path.parent.mkdir(parents=True, exist_ok=True)
-    joblib.dump(estimator, model_output_path)
-
+def validate_runtime_metadata(metadata: dict[str, Any], *, role_spec: RuntimeModelSpec) -> None:
+    """Verifie que les metadonnees exportees sont coherentes pour le runtime."""
+    missing_fields = sorted(
+        field_name for field_name in REQUIRED_RUNTIME_METADATA_FIELDS if not metadata.get(field_name)
+    )
+    if missing_fields:
+        raise RuntimeError(
+            f"Metadata validation failed for role {role_spec.role!r}. "
+            f"Missing fields: {', '.join(missing_fields)}."
+        )
 
-def main() -> None:
-    """Execute l'export du registered model depuis la CLI."""
-    args = parse_args()
-    tracking_uri = str(args.tracking_uri)
-    model_output_path = Path(args.output_model_path).resolve()
-    metadata_output_path = Path(args.output_metadata_path).resolve()
+    if metadata.get("runtime_model_role") != role_spec.role:
+        raise RuntimeError(
+            f"Metadata validation failed for role {role_spec.role!r}. "
+            f"Unexpected runtime_model_role={metadata.get('runtime_model_role')!r}."
+        )
 
-    mlflow.set_tracking_uri(tracking_uri)
-    client = MlflowClient(tracking_uri=tracking_uri)
 
-    registered_models = list(client.search_registered_models())
-    available_names = normalize_registered_model_names(registered_models)
-    registered_model_name = resolve_registered_model_name(
-        available_names,
-        requested_name=args.registered_model,
+def promote_single_registered_model(
+    *,
+    client: MlflowClient,
+    tracking_uri: str,
+    role_spec: RuntimeModelSpec,
+    available_names: list[str],
+    requested_name: str | None = None,
+    requested_version: str | None = None,
+    allow_latest_version: bool = False,
+) -> dict[str, Any]:
+    """Promouvoit un registered model runtime unique depuis MLflow."""
+    registered_model_name = resolve_registered_model_name_for_role(
+        role_spec=role_spec,
+        available_names=available_names,
+        requested_name=requested_name,
     )
-
-    model_versions = list(client.search_model_versions(f"name = '{registered_model_name}'"))
-    selected_version = resolve_model_version(model_versions, requested_version=args.version)
-    source_run = client.get_run(selected_version.run_id) if getattr(selected_version, "run_id", None) else None
-
-    export_registered_model(
-        tracking_uri=tracking_uri,
+    versions = list(client.search_model_versions(f"name = '{registered_model_name}'"))
+    selected_version = resolve_model_version_for_role(
+        versions,
+        role_spec=role_spec,
         registered_model_name=registered_model_name,
-        model_version=selected_version,
-        model_output_path=model_output_path,
+        requested_version=requested_version,
+        allow_latest_version=allow_latest_version,
     )
+    source_run = client.get_run(selected_version.run_id) if getattr(selected_version, "run_id", None) else None
 
-    existing_metadata = read_json_if_exists(metadata_output_path)
+    try:
+        export_registered_model(
+            tracking_uri=tracking_uri,
+            registered_model_name=registered_model_name,
+            model_version=selected_version,
+            model_output_path=role_spec.output_model_path,
+        )
+    except Exception as exc:  # pragma: no cover - defensive branch
+        raise RuntimeError(
+            f"Export failed for role {role_spec.role!r} and model {registered_model_name!r}."
+        ) from exc
+
+    validate_exported_artifact(role_spec.output_model_path)
+    existing_metadata = read_json_if_exists(role_spec.output_metadata_path)
     export_metadata = build_export_metadata(
         existing_metadata=existing_metadata,
+        role_spec=role_spec,
         registered_model_name=registered_model_name,
         model_version=selected_version,
         tracking_uri=tracking_uri,
-        model_output_path=model_output_path,
+        model_output_path=role_spec.output_model_path,
+        metadata_output_path=role_spec.output_metadata_path,
         source_run=source_run,
     )
-    metadata_output_path.parent.mkdir(parents=True, exist_ok=True)
-    metadata_output_path.write_text(
+    role_spec.output_metadata_path.parent.mkdir(parents=True, exist_ok=True)
+    role_spec.output_metadata_path.write_text(
         json.dumps(json_ready(export_metadata), indent=2, ensure_ascii=True),
         encoding="utf-8",
     )
+    validate_runtime_metadata(export_metadata, role_spec=role_spec)
+
+    return {
+        "role": role_spec.role,
+        "registered_model_name": registered_model_name,
+        "registered_model_version": str(selected_version.version),
+        "registered_model_run_id": getattr(selected_version, "run_id", None),
+        "model_uri": f"models:/{registered_model_name}/{selected_version.version}",
+        "artifact_path": project_relative_path(role_spec.output_model_path),
+        "metadata_path": project_relative_path(role_spec.output_metadata_path),
+    }
+
+
+def promote_registered_models(
+    *,
+    tracking_uri: str = DEFAULT_MLFLOW_TRACKING_URI,
+    models_dir: str | Path = DEFAULT_MODELS_DIR,
+    historical_registered_model: str | None = None,
+    historical_version: str | None = None,
+    simulation_registered_model: str | None = None,
+    simulation_version: str | None = None,
+    allow_latest_version: bool = False,
+) -> dict[str, Any]:
+    """Promouvoit les deux registered models runtime depuis MLflow."""
+    tracking_uri = normalize_tracking_uri(tracking_uri)
+    resolved_models_dir = Path(models_dir).resolve()
+    historical_spec = with_models_dir(HISTORICAL_RUNTIME_MODEL_SPEC, resolved_models_dir)
+    simulation_spec = with_models_dir(SIMULATION_RUNTIME_MODEL_SPEC, resolved_models_dir)
+
+    mlflow.set_tracking_uri(tracking_uri)
+    client = MlflowClient(tracking_uri=tracking_uri)
+    registered_models = list(client.search_registered_models())
+    available_names = normalize_registered_model_names(registered_models)
+
+    historical_summary = promote_single_registered_model(
+        client=client,
+        tracking_uri=tracking_uri,
+        role_spec=historical_spec,
+        available_names=available_names,
+        requested_name=historical_registered_model,
+        requested_version=historical_version,
+        allow_latest_version=allow_latest_version,
+    )
+    simulation_summary = promote_single_registered_model(
+        client=client,
+        tracking_uri=tracking_uri,
+        role_spec=simulation_spec,
+        available_names=available_names,
+        requested_name=simulation_registered_model,
+        requested_version=simulation_version,
+        allow_latest_version=allow_latest_version,
+    )
+    return {
+        "tracking_uri": tracking_uri,
+        "models_dir": project_relative_path(resolved_models_dir),
+        "historical": historical_summary,
+        "simulation": simulation_summary,
+    }
 
-    print(f"Registered model exporté : {registered_model_name}")
-    print(f"Version exportée : {selected_version.version}")
-    print(f"Run source : {getattr(selected_version, 'run_id', None)}")
-    print(f"Pipeline joblib : {model_output_path}")
-    print(f"Metadonnées : {metadata_output_path}")
+
+def main() -> None:
+    """Execute la promotion runtime depuis la CLI."""
+    args = parse_args()
+    summary = promote_registered_models(
+        tracking_uri=str(args.tracking_uri),
+        models_dir=args.models_dir,
+        historical_registered_model=args.historical_registered_model,
+        historical_version=args.historical_version,
+        simulation_registered_model=args.simulation_registered_model,
+        simulation_version=args.simulation_version,
+    )
+    if args.json:
+        print(json.dumps(summary, indent=2, ensure_ascii=True))
+        return
+
+    for role_name in ("historical", "simulation"):
+        role_summary = summary[role_name]
+        print(
+            "[promotion] "
+            f"role={role_summary['role']} "
+            f"registered_model={role_summary['registered_model_name']} "
+            f"version={role_summary['registered_model_version']} "
+            f"artifact={role_summary['artifact_path']}"
+        )
 
 
 if __name__ == "__main__":

scripts/run_full_pipeline.py

@@ -1,31 +1,122 @@
-"""Orchestre la chaine locale du projet, de la preparation a la validation."""
+"""Orchestre la chaine locale officielle, de la preparation a la validation."""
 
 from __future__ import annotations
 
 import argparse
 import json
+import math
+from numbers import Real
 from pathlib import Path
 import sys
 
+import mlflow
+from mlflow.tracking import MlflowClient
+
 
 PROJECT_ROOT = Path(__file__).resolve().parents[1]
 if str(PROJECT_ROOT) not in sys.path:
     sys.path.insert(0, str(PROJECT_ROOT))
 
-from scripts.pipeline_utils import ensure_paths_exist, execute_notebook, relative_to_project
+from scripts.mlflow_config import (
+    DEFAULT_MLFLOW_TRACKING_URI,
+    FULL_PIPELINE_EXPERIMENT_NAME,
+    experiment_artifact_location,
+    normalize_tracking_uri,
+)
+from scripts.promote_registered_model import promote_registered_models
 from scripts.run_preparation import run_preparation
 from scripts.train_historical_model import train_historical_model
 from scripts.train_simulation_model import train_simulation_model
 from scripts.validate_runtime import validate_runtime
 
 
-EXPERIENCE_2_NOTEBOOK_PATH = Path("notebooks/experience_2.ipynb")
-EXPERIENCE_2_OUTPUTS = [
-    Path("artifacts/experiments/experience_2/dataset_series_temporelles.csv"),
-    Path("artifacts/experiments/experience_2/model_results.csv"),
-    Path("artifacts/experiments/experience_2/experience_2_summary.csv"),
-]
-EXPERIENCE_3_NOTEBOOK_PATH = Path("notebooks/experience_3.ipynb")
+def _ensure_full_pipeline_experiment(tracking_uri: str) -> None:
+    """Prepare l'experience MLflow qui trace les executions du pipeline complet."""
+    mlflow.set_tracking_uri(tracking_uri)
+    while mlflow.active_run() is not None:
+        mlflow.end_run()
+
+    client = MlflowClient(tracking_uri=tracking_uri)
+    experiment = client.get_experiment_by_name(FULL_PIPELINE_EXPERIMENT_NAME)
+    if experiment is None:
+        client.create_experiment(
+            FULL_PIPELINE_EXPERIMENT_NAME,
+            artifact_location=experiment_artifact_location(
+                FULL_PIPELINE_EXPERIMENT_NAME,
+                tracking_uri=tracking_uri,
+            ),
+        )
+    mlflow.set_experiment(FULL_PIPELINE_EXPERIMENT_NAME)
+
+
+def _log_numeric_metrics(prefix: str, metrics: object) -> None:
+    """Journalise les metriques numeriques disponibles dans un dictionnaire."""
+    if not isinstance(metrics, dict):
+        return
+
+    for metric_name, metric_value in metrics.items():
+        if isinstance(metric_value, bool) or not isinstance(metric_value, Real):
+            continue
+        numeric_value = float(metric_value)
+        if math.isfinite(numeric_value):
+            mlflow.log_metric(f"{prefix}_{metric_name}", numeric_value)
+
+
+def _log_param_if_present(name: str, value: object) -> None:
+    """Journalise un parametre MLflow seulement s'il est renseigne."""
+    if value is not None:
+        mlflow.log_param(name, value)
+
+
+def log_pipeline_summary_to_mlflow(
+    summary: dict[str, object],
+    *,
+    tracking_uri: str,
+    skip_preparation: bool,
+    skip_runtime_validation: bool,
+    reuse_simulation_artifact: bool,
+    simulation_sample_size: int,
+) -> dict[str, str]:
+    """Ajoute une trace MLflow lisible pour une execution de `run_full_pipeline.py`."""
+    resolved_tracking_uri = normalize_tracking_uri(tracking_uri)
+    _ensure_full_pipeline_experiment(resolved_tracking_uri)
+    serializable_summary = json.loads(json.dumps(summary, ensure_ascii=True, default=str))
+
+    with mlflow.start_run(run_name=FULL_PIPELINE_EXPERIMENT_NAME) as run:
+        mlflow.log_param("entrypoint", "scripts/run_full_pipeline.py")
+        mlflow.log_param("skip_preparation", bool(skip_preparation))
+        mlflow.log_param("skip_runtime_validation", bool(skip_runtime_validation))
+        mlflow.log_param("reuse_simulation_artifact", bool(reuse_simulation_artifact))
+        mlflow.log_param("simulation_sample_size", int(simulation_sample_size))
+
+        historical_model = serializable_summary.get("historical_model", {})
+        simulation_model = serializable_summary.get("simulation_model", {})
+        runtime_validation = serializable_summary.get("runtime_validation", {})
+
+        if isinstance(historical_model, dict):
+            _log_param_if_present("historical_registered_model", historical_model.get("registered_model_name"))
+            _log_param_if_present(
+                "historical_registered_model_version",
+                historical_model.get("registered_model_version"),
+            )
+            _log_numeric_metrics("historical", historical_model.get("metrics"))
+        if isinstance(simulation_model, dict):
+            _log_param_if_present("simulation_registered_model", simulation_model.get("registered_model_name"))
+            _log_param_if_present(
+                "simulation_registered_model_version",
+                simulation_model.get("registered_model_version"),
+            )
+            _log_numeric_metrics("simulation", simulation_model.get("metrics"))
+        if isinstance(runtime_validation, dict):
+            mlflow.log_param("runtime_validation_skipped", bool(runtime_validation.get("skipped", False)))
+            _log_param_if_present("runtime_validation_status", runtime_validation.get("status", "executed"))
+
+        mlflow.log_dict(serializable_summary, "pipeline_summary.json")
+        return {
+            "experiment_name": FULL_PIPELINE_EXPERIMENT_NAME,
+            "run_id": run.info.run_id,
+            "tracking_uri": resolved_tracking_uri,
+        }
 
 
 def parse_args() -> argparse.Namespace:
@@ -38,21 +129,11 @@ def parse_args() -> argparse.Namespace:
         action="store_true",
         help="Reuse the existing preparation outputs instead of re-executing preparation.ipynb.",
     )
-    parser.add_argument(
-        "--run-experience-2",
-        action="store_true",
-        help="Optionally execute the abandoned complementary temporal notebook.",
-    )
     parser.add_argument(
         "--skip-runtime-validation",
         action="store_true",
         help="Skip the final smoke test against the runtime service.",
     )
-    parser.add_argument(
-        "--run-experience-3",
-        action="store_true",
-        help="Also execute notebooks/experience_3.ipynb after the artifacts are rebuilt.",
-    )
     parser.add_argument(
         "--reuse-simulation-artifact",
         action="store_true",
@@ -75,6 +156,21 @@ def parse_args() -> argparse.Namespace:
         default="python3",
         help="Jupyter kernel used to execute notebook-backed stages.",
     )
+    parser.add_argument(
+        "--tracking-uri",
+        default=DEFAULT_MLFLOW_TRACKING_URI,
+        help="Tracking URI MLflow partage entre entrainement et promotion.",
+    )
+    parser.add_argument(
+        "--historical-version",
+        default=None,
+        help="Version MLflow historique a promouvoir. Par defaut, le pipeline prend la derniere version.",
+    )
+    parser.add_argument(
+        "--simulation-version",
+        default=None,
+        help="Version MLflow simulation a promouvoir. Par defaut, le pipeline prend la derniere version.",
+    )
     parser.add_argument(
         "--json",
         action="store_true",
@@ -86,74 +182,78 @@ def parse_args() -> argparse.Namespace:
 def run_full_pipeline(
     *,
     skip_preparation: bool = False,
-    run_experience_2: bool = False,
     skip_runtime_validation: bool = False,
-    run_experience_3: bool = False,
     reuse_simulation_artifact: bool = False,
     simulation_sample_size: int = 200_000,
     notebook_timeout_seconds: int = 7200,
     kernel_name: str = "python3",
+    tracking_uri: str = DEFAULT_MLFLOW_TRACKING_URI,
+    historical_version: str | None = None,
+    simulation_version: str | None = None,
 ) -> dict[str, object]:
     """Execute les principales etapes de regeneration des artefacts.
 
     Args:
         skip_preparation: Saute `preparation.ipynb` si les sorties existent deja.
-        run_experience_2: Execute explicitement le notebook temporel abandonne.
         skip_runtime_validation: Saute le smoke test final.
-        run_experience_3: Execute aussi le notebook de verification de stack.
         reuse_simulation_artifact: Reutilise le modele local existant au lieu de le reentrainer.
         simulation_sample_size: Taille d'echantillon pour le modele local.
         notebook_timeout_seconds: Timeout applique a chaque notebook execute.
         kernel_name: Kernel Jupyter a utiliser.
+        tracking_uri: Tracking URI MLflow utilise pour l'entrainement et la promotion.
+        historical_version: Version historique a promouvoir, ou derniere version si absent.
+        simulation_version: Version simulation a promouvoir, ou derniere version si absent.
 
     Returns:
         dict[str, object]: Resume des etapes executees et des artefacts verifies.
     """
-    results: dict[str, object] = {}
+    tracking_uri = normalize_tracking_uri(tracking_uri)
+    results: dict[str, object] = {
+        "mlflow": {
+            "tracking_uri": tracking_uri,
+            "pipeline_experiment": FULL_PIPELINE_EXPERIMENT_NAME,
+        }
+    }
 
     if not skip_preparation:
         results["preparation"] = run_preparation(
             timeout_seconds=notebook_timeout_seconds,
             kernel_name=kernel_name,
         )
+    else:
+        results["preparation"] = {"skipped": True}
 
     results["historical_model"] = train_historical_model(
+        tracking_uri=tracking_uri,
         cv_splits=4,
     )
 
-    if run_experience_2:
-        print(f"[experience_2] Executing {relative_to_project(EXPERIENCE_2_NOTEBOOK_PATH)}")
-        execute_notebook(
-            EXPERIENCE_2_NOTEBOOK_PATH,
-            timeout_seconds=notebook_timeout_seconds,
-            kernel_name=kernel_name,
-        )
-        resolved_outputs = ensure_paths_exist(EXPERIENCE_2_OUTPUTS, label="experience_2 outputs")
-        print("[experience_2] Outputs validated")
-        results["experience_2"] = {
-            "notebook": relative_to_project(EXPERIENCE_2_NOTEBOOK_PATH),
-            "outputs": [relative_to_project(path) for path in resolved_outputs],
-        }
-
     results["simulation_model"] = train_simulation_model(
         force_retrain=not reuse_simulation_artifact,
         save_artifact=True,
         sample_size=simulation_sample_size,
+        tracking_uri=tracking_uri,
+    )
+    results["registered_model_promotion"] = promote_registered_models(
+        tracking_uri=tracking_uri,
+        historical_version=historical_version,
+        simulation_version=simulation_version,
+        allow_latest_version=True,
     )
-
-    if run_experience_3:
-        print(f"[experience_3] Executing {relative_to_project(EXPERIENCE_3_NOTEBOOK_PATH)}")
-        execute_notebook(
-            EXPERIENCE_3_NOTEBOOK_PATH,
-            timeout_seconds=notebook_timeout_seconds,
-            kernel_name=kernel_name,
-        )
-        results["experience_3"] = {
-            "notebook": relative_to_project(EXPERIENCE_3_NOTEBOOK_PATH),
-        }
 
     if not skip_runtime_validation:
         results["runtime_validation"] = validate_runtime()
+    else:
+        results["runtime_validation"] = {"skipped": True}
+
+    results["pipeline_run"] = log_pipeline_summary_to_mlflow(
+        results,
+        tracking_uri=tracking_uri,
+        skip_preparation=skip_preparation,
+        skip_runtime_validation=skip_runtime_validation,
+        reuse_simulation_artifact=reuse_simulation_artifact,
+        simulation_sample_size=simulation_sample_size,
+    )
 
     return results
 
@@ -163,13 +263,14 @@ def main() -> None:
     args = parse_args()
     summary = run_full_pipeline(
         skip_preparation=args.skip_preparation,
-        run_experience_2=args.run_experience_2,
         skip_runtime_validation=args.skip_runtime_validation,
-        run_experience_3=args.run_experience_3,
         reuse_simulation_artifact=args.reuse_simulation_artifact,
         simulation_sample_size=args.simulation_sample_size,
         notebook_timeout_seconds=args.notebook_timeout_seconds,
         kernel_name=args.kernel_name,
+        tracking_uri=args.tracking_uri,
+        historical_version=args.historical_version,
+        simulation_version=args.simulation_version,
     )
     if args.json:
         print(json.dumps(summary, indent=2, ensure_ascii=True))

scripts/runtime_model_specs.py

@@ -0,0 +1,41 @@
+"""Centralise les contrats des deux modeles runtime du projet."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from scripts.mlflow_config import DEFAULT_MLFLOW_TRACKING_URI, PROJECT_ROOT
+
+
+DEFAULT_MODELS_DIR = PROJECT_ROOT / "artifacts" / "models"
+
+
+@dataclass(frozen=True)
+class RuntimeModelSpec:
+    """Decrit un modele runtime attendu par l'API finale."""
+
+    role: str
+    registered_model_name: str
+    output_model_path: Path
+    output_metadata_path: Path
+
+
+HISTORICAL_RUNTIME_MODEL_SPEC = RuntimeModelSpec(
+    role="historical",
+    registered_model_name="p1_historical_pipeline",
+    output_model_path=DEFAULT_MODELS_DIR / "p1_historical_pipeline.joblib",
+    output_metadata_path=DEFAULT_MODELS_DIR / "p1_historical_metadata.json",
+)
+
+SIMULATION_RUNTIME_MODEL_SPEC = RuntimeModelSpec(
+    role="simulation",
+    registered_model_name="p23_simulation_pipeline",
+    output_model_path=DEFAULT_MODELS_DIR / "p23_simulation_pipeline.joblib",
+    output_metadata_path=DEFAULT_MODELS_DIR / "p23_simulation_metadata.json",
+)
+
+RUNTIME_MODEL_SPECS = {
+    HISTORICAL_RUNTIME_MODEL_SPEC.role: HISTORICAL_RUNTIME_MODEL_SPEC,
+    SIMULATION_RUNTIME_MODEL_SPEC.role: SIMULATION_RUNTIME_MODEL_SPEC,
+}

scripts/train_historical_model.py

@@ -14,16 +14,17 @@ if str(PROJECT_ROOT) not in sys.path:
 
 from scripts.experience_1 import run_experience_1
 from scripts.pipeline_utils import ensure_paths_exist, relative_to_project
+from scripts.runtime_model_specs import HISTORICAL_RUNTIME_MODEL_SPEC
 
 
 EXPERIENCE_1_SCRIPT_PATH = Path("scripts/experience_1.py")
 HISTORICAL_OUTPUTS = [
     Path("artifacts/experiments/experience_1/dataset_consolide_historique_colonnes.csv"),
     Path("artifacts/experiments/experience_1/model_results.csv"),
-    Path("artifacts/models/p1_historical_pipeline.joblib"),
-    Path("artifacts/models/p1_historical_metadata.json"),
+    HISTORICAL_RUNTIME_MODEL_SPEC.output_model_path.relative_to(PROJECT_ROOT),
+    HISTORICAL_RUNTIME_MODEL_SPEC.output_metadata_path.relative_to(PROJECT_ROOT),
 ]
-HISTORICAL_METADATA_PATH = Path("artifacts/models/p1_historical_metadata.json")
+HISTORICAL_METADATA_PATH = HISTORICAL_RUNTIME_MODEL_SPEC.output_metadata_path.relative_to(PROJECT_ROOT)
 
 
 def parse_args() -> argparse.Namespace:
@@ -68,10 +69,15 @@ def train_historical_model(
     )
     return {
         "script": relative_to_project(EXPERIENCE_1_SCRIPT_PATH),
+        "artifact_source": "retrained",
         "training_notebook_reference": metadata.get("training_notebook"),
         "outputs": [relative_to_project(path) for path in resolved_outputs],
         "model_name": metadata.get("model_name"),
         "target_year": metadata.get("target_year"),
+        "registered_model_name": metadata.get("registered_model_name"),
+        "registered_model_version": metadata.get("registered_model_version"),
+        "registered_model_run_id": metadata.get("registered_model_run_id"),
+        "model_uri": metadata.get("model_uri"),
         "metrics": metrics,
     }
 

scripts/train_simulation_model.py

@@ -3,26 +3,41 @@
 from __future__ import annotations
 
 import argparse
+import json
 from pathlib import Path
 import sys
 
+import mlflow
+from mlflow.tracking import MlflowClient
+
 
 PROJECT_ROOT = Path(__file__).resolve().parents[1]
 if str(PROJECT_ROOT) not in sys.path:
     sys.path.insert(0, str(PROJECT_ROOT))
 
+from scripts.mlflow_logging import log_and_register_sklearn_model
+from scripts.mlflow_config import (
+    SIMULATION_RUNTIME_EXPERIMENT_NAME,
+    experiment_artifact_location,
+    normalize_tracking_uri,
+)
 from scripts.pipeline_utils import ensure_paths_exist, relative_to_project
 from scripts.prediction_adjustment import (
     SIMULATION_METADATA_PATH,
     SIMULATION_MODEL_PATH,
     load_or_train_simulation_model,
 )
+from scripts.runtime_model_specs import (
+    DEFAULT_MLFLOW_TRACKING_URI,
+    SIMULATION_RUNTIME_MODEL_SPEC,
+)
 
 
 SIMULATION_OUTPUTS = [
     SIMULATION_MODEL_PATH,
     SIMULATION_METADATA_PATH,
 ]
+SIMULATION_MLFLOW_EXPERIMENT_NAME = SIMULATION_RUNTIME_EXPERIMENT_NAME
 
 
 def parse_args() -> argparse.Namespace:
@@ -46,14 +61,66 @@ def parse_args() -> argparse.Namespace:
         action="store_true",
         help="Train in memory without rewriting the model artifacts.",
     )
+    parser.add_argument(
+        "--tracking-uri",
+        default=DEFAULT_MLFLOW_TRACKING_URI,
+        help="Tracking URI MLflow utilise pour journaliser et enregistrer le modele.",
+    )
     return parser.parse_args()
 
 
+def _ensure_simulation_mlflow_experiment(tracking_uri: str) -> None:
+    """Initialise l'experiment MLflow utilise par la brique de simulation."""
+    tracking_uri = normalize_tracking_uri(tracking_uri)
+    mlflow.set_tracking_uri(tracking_uri)
+    client = MlflowClient(tracking_uri=tracking_uri)
+    experiment = client.get_experiment_by_name(SIMULATION_MLFLOW_EXPERIMENT_NAME)
+    if experiment is None:
+        client.create_experiment(
+            SIMULATION_MLFLOW_EXPERIMENT_NAME,
+            artifact_location=experiment_artifact_location(
+                SIMULATION_MLFLOW_EXPERIMENT_NAME,
+                tracking_uri=tracking_uri,
+            ),
+        )
+    mlflow.set_experiment(SIMULATION_MLFLOW_EXPERIMENT_NAME)
+
+
+def _register_simulation_runtime_model(
+    *,
+    loaded_model,
+    tracking_uri: str,
+) -> dict[str, str]:
+    """Journalise et enregistre le modele local comme registered model MLflow."""
+    _ensure_simulation_mlflow_experiment(tracking_uri)
+    metrics = loaded_model.metadata.get("metrics", {})
+    with mlflow.start_run(run_name=f"{SIMULATION_MLFLOW_EXPERIMENT_NAME}__runtime_model"):
+        mlflow.log_param("runtime_model_role", SIMULATION_RUNTIME_MODEL_SPEC.role)
+        mlflow.log_param("registered_model_name", SIMULATION_RUNTIME_MODEL_SPEC.registered_model_name)
+        mlflow.log_param("training_entrypoint", "scripts/train_simulation_model.py")
+        mlflow.log_param("model_name", loaded_model.metadata.get("model_name"))
+        mlflow.log_param("dataset_source", loaded_model.metadata.get("dataset_source"))
+        mlflow.log_param("sample_size", loaded_model.metadata.get("sample_size"))
+        for metric_name, metric_value in metrics.items():
+            if metric_value is not None:
+                mlflow.log_metric(metric_name, float(metric_value))
+        return log_and_register_sklearn_model(
+            loaded_model.pipeline,
+            artifact_name=SIMULATION_RUNTIME_MODEL_SPEC.registered_model_name,
+            registered_model_name=SIMULATION_RUNTIME_MODEL_SPEC.registered_model_name,
+            model_metadata={
+                "runtime_model_role": SIMULATION_RUNTIME_MODEL_SPEC.role,
+                "training_entrypoint": "scripts/train_simulation_model.py",
+            },
+        )
+
+
 def train_simulation_model(
     *,
     force_retrain: bool = False,
     save_artifact: bool = True,
     sample_size: int = 200_000,
+    tracking_uri: str = DEFAULT_MLFLOW_TRACKING_URI,
 ) -> dict[str, object]:
     """Charge ou reentraine le modele local de simulation.
 
@@ -61,18 +128,42 @@ def train_simulation_model(
         force_retrain: Force le reentrainement meme si les artefacts existent.
         save_artifact: Ecrit les artefacts sur disque si `True`.
         sample_size: Nombre maximal de lignes echantillonnees pour l'entrainement.
+        tracking_uri: Tracking URI MLflow utilise pour le registry.
 
     Returns:
         dict[str, object]: Resume du dataset utilise, des metriques et des sorties.
     """
+    tracking_uri = normalize_tracking_uri(tracking_uri)
+    reused_existing_artifact = (
+        not force_retrain
+        and SIMULATION_MODEL_PATH.exists()
+        and SIMULATION_METADATA_PATH.exists()
+    )
     loaded_model, simulation_df = load_or_train_simulation_model(
         force_retrain=force_retrain,
         save_artifact=save_artifact,
         sample_size=sample_size,
     )
+    registration = _register_simulation_runtime_model(
+        loaded_model=loaded_model,
+        tracking_uri=tracking_uri,
+    )
+    loaded_model.metadata.update(
+        {
+            "runtime_model_role": SIMULATION_RUNTIME_MODEL_SPEC.role,
+            "registered_model_name": registration["registered_model_name"],
+            "registered_model_version": registration["registered_model_version"],
+            "registered_model_run_id": registration["run_id"],
+            "model_uri": registration["model_uri"],
+        }
+    )
 
     output_paths: list[str] = []
     if save_artifact:
+        SIMULATION_METADATA_PATH.write_text(
+            json.dumps(loaded_model.metadata, indent=2, ensure_ascii=True),
+            encoding="utf-8",
+        )
         resolved_outputs = ensure_paths_exist(SIMULATION_OUTPUTS, label="simulation model outputs")
         output_paths = [relative_to_project(path) for path in resolved_outputs]
 
@@ -85,6 +176,11 @@ def train_simulation_model(
     return {
         "dataset_rows": int(len(simulation_df)),
         "sample_size": loaded_model.metadata.get("sample_size"),
+        "artifact_source": "reused_existing" if reused_existing_artifact else "retrained",
+        "registered_model_name": registration["registered_model_name"],
+        "registered_model_version": registration["registered_model_version"],
+        "registered_model_run_id": registration["run_id"],
+        "model_uri": registration["model_uri"],
         "metrics": metrics,
         "outputs": output_paths,
     }
@@ -97,6 +193,7 @@ def main() -> None:
         force_retrain=args.force_retrain,
         save_artifact=not args.no_save,
         sample_size=args.sample_size,
+        tracking_uri=args.tracking_uri,
     )
 
 

streamlit/requirements.txt

@@ -5,5 +5,6 @@ pandas==2.3.3
 Pillow==11.3.0
 requests==2.32.5
 scikit-learn==1.8.0
+shap
 streamlit==1.49.1
 uvicorn==0.42.0