Commit 1

.gitignore

@@ -0,0 +1,214 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Models
+src/models
+src/notebooks
+src/data
+src/logs
+.joblib

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:venv",
+    "python-envs.defaultPackageManager": "ms-python.python:pip",
+    "python-envs.pythonProjects": []
+}

app.py

@@ -0,0 +1,3 @@
+import os
+from src.gradio.app import build_app 
+build_app().launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)))

main.py

@@ -0,0 +1,5 @@
+import os
+from src.gradio.app import build_app
+
+if __name__ == "__main__":
+    build_app().launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)))

src/config/features.yaml

@@ -0,0 +1,58 @@
+# Features réellement utilisées dans ton pipeline ML
+selected_features_full_columns:
+  # Target
+  - Calories_Burned
+
+  # Core features
+  - Age
+  - Gender
+  - Weight (kg)
+  - Height (m)
+  - Max_BPM
+  - Avg_BPM
+  - Resting_BPM
+  - Session_Duration (hours)
+  - Experience_Level
+  - Workout_Type
+  - Difficulty Level
+  - Body Part
+  - Equipment Needed
+  - Workout_Frequency (days/week)
+  - Water_Intake (liters)
+  - Fat_Percentage
+  - diet_type
+  - meal_type
+
+selected_features_test:
+  # Target
+  - Experience_Level
+
+  # Core features
+  - Age
+  - Gender
+  - Weight (kg)
+  - Height (m)
+  - Workout_Frequency (days/week)
+  - Workout_Type
+  # - Body Part
+  # - Fat_Percentage
+
+
+# Colonnes optionnelles présentes dans certains datasets
+#    Gardées ici pour un usage futur (Transfer Learning / Data Augmentation)
+optional_features:
+  - BMI
+  - sugar_g
+  - sodium_mg
+  - cholesterol_mg
+  - serving_size_g
+  - Name of Exercise
+  - Sets
+  - Reps
+  - Target Muscle Group
+  - Type of Muscle
+  - Benefit
+  - rating
+  - cooking_method
+  - prep_time_min
+  - cook_time_min

src/config/features_processed.yaml

@@ -0,0 +1,84 @@
+# Features finales utilisées après preprocessing / encodage
+#    → Colonnes réelles présentes dans X_train / X_test
+
+features_processed_full_columns:
+  - Age
+  - Weight (kg)
+  - Height (m)
+  - Gender_1.0
+  - Experience_Level
+  - Difficulty Level
+  - Workout_Frequency (days/week)
+  - Water_Intake (liters)
+  - Fat_Percentage
+  - Session_Duration (hours)
+  - Max_BPM
+  - Avg_BPM
+  - Resting_BPM
+
+  # One-hot Workout_Type
+  - Workout_Type_HIIT
+  - Workout_Type_Strength
+  - Workout_Type_Yoga
+
+  # One-hot Body Part
+  - Body Part_Arms
+  - Body Part_Back
+  - Body Part_Chest
+  - Body Part_Forearms
+  - Body Part_Legs
+  - Body Part_Shoulders
+
+  # One-hot Equipment Needed
+  - Equipment Needed_Bench or Step
+  - Equipment Needed_Bench or Sturdy Surface
+  - Equipment Needed_Bench, Barbell
+  - Equipment Needed_Box or Platform
+  - Equipment Needed_Cable Machine
+  - Equipment Needed_Cable Machine or Resistance Band
+  - Equipment Needed_Dumbbells
+  - Equipment Needed_Dumbbells or Barbell
+  - Equipment Needed_Kettlebell
+  - Equipment Needed_Low Bar or TRX
+  - Equipment Needed_None or Dumbbell
+  - Equipment Needed_None or Dumbbells
+  - Equipment Needed_Parallel Bars or Chair
+  - Equipment Needed_Pull-up Bar
+  - Equipment Needed_Resistance Band
+  - Equipment Needed_Resistance Band or Cable Machine
+  - Equipment Needed_Step or Box
+  - Equipment Needed_Wall
+
+  # One-hot diet_type
+  - diet_type_Paleo
+  - diet_type_Low-Carb
+  - diet_type_Vegetarian
+  - diet_type_Keto
+  - diet_type_Vegan
+
+  # One-hot meal_type
+  - meal_type_Lunch
+  - meal_type_Dinner
+  - meal_type_Snack
+
+
+features_processed_test:
+  - Age
+  - Weight (kg)
+  - Height (m)
+  - Gender_1.0
+  - Workout_Frequency (days/week)
+  # - Fat_Percentage
+
+  # One-hot Workout_Type
+  - Workout_Type_HIIT
+  - Workout_Type_Strength
+  - Workout_Type_Yoga
+
+  # # One-hot Body Part
+  # - Body Part_Arms
+  # - Body Part_Back
+  # - Body Part_Chest
+  # - Body Part_Forearms
+  # - Body Part_Legs
+  # - Body Part_Shoulders

src/config/inference.yaml

@@ -0,0 +1,159 @@
+# Spécifications "métier" pour l'inférence
+# Ces valeurs priment sur l'inférence automatique depuis X_train.
+
+inference_full_columns:
+
+  Age:
+    type: integer
+    min: 18
+    max: 60
+
+  Gender:
+    type: string
+    enum: ["Male", "Female", "Other", "Prefer not to say"]
+
+  Weight (kg):
+    type: number
+    min: 30.0
+    max: 200.0
+
+  Height (m):
+    type: number
+    min: 1.50
+    max: 2.30
+
+  Fat_Percentage:
+    type: number
+    min: 11.0
+    max: 35.0
+
+  Max_BPM:
+    type: number
+    min: 159
+    max: 200
+
+  Avg_BPM:
+    type: number
+    min: 119
+    max: 170
+
+  Resting_BPM:
+    type: number
+    min: 49.0
+    max: 75.0
+
+  Session_Duration (hours):
+    type: number
+    min: 0.1
+    max: 6
+
+  Workout_Type:
+    type: string
+    enum: ["Cardio", "Strength", "HIIT", "Yoga", "Pilates", "Other"]
+
+  Experience_Level:
+    type: number
+    min: 1.0
+    max: 3.05
+
+  Workout_Frequency (days/week):
+    type: number
+    min: 1.94
+    max: 5.06
+
+  Difficulty Level:
+    type: integer
+    enum: [0, 1, 2]
+    min: 0
+    max: 2
+
+  Body Part:
+    type: string
+    enum:
+      - Abs
+      - Arms
+      - Back
+      - Chest
+      - Forearms
+      - Legs
+      - Shoulders
+
+  Equipment Needed:
+    type: string
+    enum:
+      - Step or Box
+      - Parallel Bars or Chair
+      - Bench or Sturdy Surface
+      - None or Dumbbells
+      - Resistance Band
+      - Wall
+      - None or Dumbbell
+      - Dumbbells
+      - Dumbbells or Barbell
+      - Low Bar or TRX
+      - Cable Machine
+      - Box or Platform
+      - Bench or Chair
+      - Resistance Band or Cable Machine
+      - Kettlebell
+      - Bench or Step
+      - Pull-up Bar
+      - Barbell
+      - Cable Machine or Resistance Band
+
+  diet_type:
+    type: string
+    enum: ["Paleo", "Low-Carb", "Vegetarian", "Keto", "Vegan", "Balanced"]
+
+  meal_type:
+    type: string
+    enum: ["Breakfast", "Lunch", "Dinner", "Snack"]
+
+
+inference_test:
+
+  Age:
+    type: integer
+    min: 18
+    max: 60
+
+  Gender:
+    type: string
+    enum: ["Male", "Female", "Other", "Prefer not to say"]
+
+  Weight (kg):
+    type: number
+    min: 30.0
+    max: 200.0
+
+  Height (m):
+    type: number
+    min: 1.50
+    max: 2.30
+
+  # Fat_Percentage:
+  #   type: number
+  #   min: 11.0
+  #   max: 35.0
+
+  Workout_Frequency (days/week):
+    type: number
+    min: 0
+    max: 7
+
+  Workout_Type:
+    type: string
+    enum: ["Cardio", "Strength", "HIIT", "Yoga", "None"]
+
+
+
+  # Body Part:
+  #   type: string
+  #   enum:
+  #     - Abs
+  #     - Arms
+  #     - Back
+  #     - Chest
+  #     - Forearms
+  #     - Legs
+  #     - Shoulders

src/config/ui_defaults.yaml

@@ -0,0 +1,12 @@
+# Valeurs par défaut pour l'UI (Gradio)
+# Ces valeurs sont utilisées pour pré-remplir les champs de l'interface.
+
+UI_DEFAULTS:
+  Age: 55.92
+  Gender: "Female"
+  Weight (kg): 84.07
+  Height (m): 1.63
+  Workout_Type: "Yoga"
+  # Body Part: "Back"
+  Workout_Frequency (days/week): 3.97
+  # Fat_Percentage: 32.08817620708069

src/config/ui_examples.yaml

@@ -0,0 +1,67 @@
+# Exemples UI affichés sous les sliders / inputs
+# Chaque entrée représente un exemple complet d'utilisateur typique.
+UI_EXAMPLES:
+
+  - Experience_Level: 2.01
+    Age: 34.91
+    Gender: "Male"
+    Weight (kg): 65.27
+    Height (m): 1.62
+    Workout_Type: "Strength"
+    Workout_Frequency (days/week): 3.99
+
+  - Experience_Level: 2.01
+    Age: 23.37
+    Gender: "Female"
+    Weight (kg): 56.41
+    Height (m): 1.55
+    Workout_Type: "HIIT"
+    Workout_Frequency (days/week): 4.0
+
+  - Experience_Level: 1.02
+    Age: 33.2
+    Gender: "Female"
+    Weight (kg): 58.98
+    Height (m): 1.67
+    Workout_Type: "Cardio"
+    Workout_Frequency (days/week): 2.99
+
+  - Experience_Level: 1.99
+    Age: 38.69
+    Gender: "Female"
+    Weight (kg): 93.78
+    Height (m): 1.7
+    Workout_Type: "HIIT"
+    Workout_Frequency (days/week): 3.99
+
+  - Experience_Level: 2.0
+    Age: 45.09
+    Gender: "Male"
+    Weight (kg): 52.42
+    Height (m): 1.88
+    Workout_Type: "Strength"
+    Workout_Frequency (days/week): 4.0
+
+  - Experience_Level: 1.0
+    Age: 53.19
+    Gender: "Female"
+    Weight (kg): 105.05
+    Height (m): 1.84
+    Workout_Type: "Yoga"
+    Workout_Frequency (days/week): 3.02
+
+  - Experience_Level: 3.0
+    Age: 23.17
+    Gender: "Male"
+    Weight (kg): 58.41
+    Height (m): 1.78
+    Workout_Type: "Strength"
+    Workout_Frequency (days/week): 4.96
+
+  - Experience_Level: 2.01
+    Age: 55.92
+    Gender: "Female"
+    Weight (kg): 84.07
+    Height (m): 1.63
+    Workout_Type: "Yoga"
+    Workout_Frequency (days/week): 3.97

src/gradio/app.py

@@ -0,0 +1,104 @@
+from pathlib import Path
+import gradio as gr
+import pandas as pd
+import os
+
+# ---------- Paths ----------
+from .config import build_paths, UI_EXAMPLES
+
+HERE = Path(__file__).resolve()
+SRC_DIR = HERE.parents[1]
+
+p = build_paths(SRC_DIR)
+
+MODEL_DIR   = p["MODEL_DIR"]
+MODEL_PATH  = p["MODEL_PATH"]
+FEATURE_SCALER_PATH = p.get("FEATURE_SCALER_PATH")
+TARGET_SCALER_PATH  = p.get("TARGET_SCALER_PATH")
+ENCODER_PATH = p["ENCODER_PATH"]
+SCHEMA_PATH = p["SCHEMA_PATH"]
+LOGS_DIR    = p["LOGS_DIR"]; LOGS_DIR.mkdir(parents=True, exist_ok=True)
+DB_PATH     = p["DB_PATH"]
+REPORT_PATH = p["REPORT_PATH"]
+
+# ---------- Load model & schema ----------
+from .model_loader import load_model_and_schema, load_optional_joblib
+
+model, schema, TARGET_NAME, FEATURES, INTERNAL_EXPECTED = load_model_and_schema(
+    MODEL_PATH, SCHEMA_PATH
+)
+fx_scaler = load_optional_joblib(FEATURE_SCALER_PATH)
+y_scaler  = load_optional_joblib(TARGET_SCALER_PATH)
+encoder   = load_optional_joblib(ENCODER_PATH)
+UI_FEATURE_NAMES = [f["name"] for f in FEATURES]
+
+# ---------- Helpers ----------
+from .helpers.log_utils import log_prediction
+from .helpers.predict_utils import predict_single
+from .helpers.schema_utils import get_bounds
+from .helpers.report_utils import read_model_report, report_summary_df, report_metrics_df
+from .helpers.sqlite_utils import load_val_subset
+
+# ---------- UI ----------
+def build_app():
+    app_title   = f"TrAIn.me — (v5.0-minimal)"
+    app_desc_ml = "Personalize your experience"
+    app_desc_ex = "Choose your training program"
+    # app_desc_dl = "Generate your personalized exercise"
+    app_desc_dl_exec = "Execution generator"
+
+    from .pages.ml_tab import render_ml_tab
+    # from .pages.exercices_tab import render_list_of_exercices
+    # from .pages.dl_tab import render_dl_tab
+    from .pages.dl_execution_tab import render_dl_execution_tab
+    from .config import UI_EXAMPLES
+
+    with gr.Blocks(title=app_title) as demo:
+        gr.Markdown(f"# {app_title}\n{app_desc_ml} / {app_desc_dl_exec}")
+        with gr.Tabs():
+            # Onglet 1 : ML
+            level_out, wf_out, wt_out = render_ml_tab(
+                app_desc_ml=app_desc_ml,
+                feature_specs=FEATURES,
+                ui_feature_names=UI_FEATURE_NAMES,
+                internal_expected=INTERNAL_EXPECTED,
+                target_name=TARGET_NAME,
+                schema=schema,
+                ui_examples=UI_EXAMPLES,
+                db_path=DB_PATH,
+                model=model,
+                logs_dir=LOGS_DIR,
+                model_path=MODEL_PATH,
+                feature_scaler=fx_scaler,
+                target_scaler=y_scaler,
+                encoder=encoder,
+                report_path=REPORT_PATH,
+                on_load=demo.load,
+            )
+
+            # # Onglet 2 : liste des programmes
+            # selected_program_state, goal_state = render_list_of_exercices(
+            #     app_desc_ex=app_desc_ex,
+            #     level_out=level_out,
+            # )
+
+            # # Onglet 3 : DL – programme complet
+            # render_dl_tab(
+            #     app_desc_dl=app_desc_dl,
+            #     level_out=level_out,
+            #     wf_comp=wf_out,
+            #     wt_comp=wt_out,
+            #     selected_program_df=selected_program_state,
+            #     goal_state=goal_state,
+            # )
+
+            # Onglet 4 : DL – Execution generator
+            render_dl_execution_tab(
+                app_desc_dl_exec=app_desc_dl_exec
+            )
+
+    return demo
+
+
+if __name__ == "__main__":
+    build_app().launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)))

src/gradio/config.py

@@ -0,0 +1,94 @@
+import os
+from pathlib import Path
+import yaml
+from huggingface_hub import hf_hub_download
+
+# ---- Chaînes centralisées (sans logique) ----
+# Dossiers / fichiers "métier"
+MODEL_SUBDIR = ("models", "v1", "life_style_data")
+# MODEL_FILENAME = "model.joblib"
+# SCHEMA_FILENAME = "feature_schema.json"
+REPORT_FILENAME = "model_report.json"
+# Fichiers de scalers optionnels
+# FEATURE_SCALER_FILENAME = "feature_scaler.joblib"
+# TARGET_SCALER_FILENAME  = "target_scaler.joblib"
+# ENCODER_FILENAME = "encoder.joblib"
+# Repo HuggingFace Models
+MODEL_REPO_ID = "AIppyDev/life_style_data"
+
+# Le notebook s’exécute depuis son répertoire → on peut repartir du cwd
+current_dir = Path.cwd()
+# Valeurs par défaut UI (non normalisées)
+config_path = Path(current_dir / "src/config/ui_defaults.yaml")
+with open(config_path, "r", encoding="utf-8") as f:
+    UI_DEFAULTS = yaml.safe_load(f)["UI_DEFAULTS"]
+
+# Exemples UI (affichés sous les sliders)
+examples_path = Path(current_dir / "src/config/ui_examples.yaml")
+with open(examples_path, "r", encoding="utf-8") as f:
+    UI_EXAMPLES = yaml.safe_load(f)["UI_EXAMPLES"]
+
+
+
+# Base de validation (relative au repo src/)
+DB_RELATIVE = ("data", "processed", "life_style_data", "life_style_data_val.db")
+
+# ---- Résolution des chemins (avec ENV overrides optionnels) ----
+def build_paths(src_dir: Path) -> dict[str, Path]:
+    """
+    Construit tous les chemins nécessaires à l'app Gradio à partir de src_dir.
+    Les variables d'environnement suivantes peuvent override :
+      - MODEL_PATH, SCHEMA_PATH, MODEL_REPORT_PATH
+    """
+    model_dir = src_dir.joinpath(*MODEL_SUBDIR)
+
+    model_path_env = os.getenv("MODEL_PATH")
+    schema_path_env = os.getenv("SCHEMA_PATH")
+    report_path_env = os.getenv("MODEL_REPORT_PATH")
+
+    paths = {
+        "MODEL_DIR": model_dir,
+        "MODEL_PATH": Path(
+            hf_hub_download(
+                repo_id=MODEL_REPO_ID,
+                repo_type="model",
+                filename="life_style_data/model.joblib",
+            )
+        ) if not model_path_env else Path(model_path_env),
+
+        "SCHEMA_PATH": Path(
+            hf_hub_download(
+                repo_id=MODEL_REPO_ID,
+                repo_type="model",
+                filename="life_style_data/feature_schema.json",
+            )
+        ) if not schema_path_env else Path(schema_path_env),
+
+        "LOGS_DIR": src_dir / "logs",
+        "DB_PATH": src_dir.joinpath(*DB_RELATIVE),
+
+        "REPORT_PATH": Path(report_path_env) if report_path_env else model_dir / REPORT_FILENAME,
+
+        "FEATURE_SCALER_PATH": Path(
+            hf_hub_download(
+                repo_id=MODEL_REPO_ID,
+                repo_type="model",
+                filename="life_style_data/feature_scaler.joblib",
+            )
+        ),
+        "TARGET_SCALER_PATH": Path(
+            hf_hub_download(
+                repo_id=MODEL_REPO_ID,
+                repo_type="model",
+                filename="life_style_data/target_scaler.joblib",
+            )
+        ),
+        "ENCODER_PATH": Path(
+            hf_hub_download(
+                repo_id=MODEL_REPO_ID,
+                repo_type="model",
+                filename="life_style_data/encoder.joblib",
+            )
+        ),
+    }
+    return paths

src/gradio/data/corpus_car_FULL_1.txt

@@ -0,0 +1 @@
+l'objectif de cette vidéo c'est donc que vous trouviez la meilleure organisation pour vos training et je m'adresse à desgâts naturels en tant que mec naturel et de toute façon il y a que des mecs chargés pour dire oui mais chargé pas chargé c'est pareil pour tout le monde si c'était le cas vous auriez pas besoin de vous charger on va voir dans cette vidéo de la pire façon d'organiser ses entraînements à la meilleure en gros comment diviser vos training pour être le plus efficace possible je vais classer les différents styles de division d'entraînement les plus courants et utilisés en muscu à savoir le body qui est une technique qui vise à travailler l'ensemble du corps au sein de la même séance le half body avec le half body on divise le corps en deux en alternant en général une séance upper haut du corps et une séance lower bas du corps le PPL c'est une division en trois parties un push les muscles qui servent à pousser essentiellement les pecs triceps deltoïdes faisau moyen et antérieur poule les muscles qui servent à tirer donc essentiellement le dos les BPS deltoïde faisau postérieur et les jambes bien sûr qui regroupent les cuisses les fessiers et les mollet ensuite on verra le mix entre ALP et PPL donc vous l'avez compris comme son on indique c'est un mix des deux et pour terminer bien sûr le split c'est un terme un peu détourné parce que ça veut dire juste diviser mais dans le monde de la muscu on s'accorde à dire que c'est une division en général en 5 ou plus exemple de Split une s spec puis dos puis jambes puis épaule puis bras ça peut même aller plus loin dans la division mais on va garder celle-ci qui est la courante et bien sûr ça n'aurait aucun sens de faire ce classement si je prenais pas en compte le nombre de jours d'entraînement que vous faites dans la semaine donc vous allez voir que si vous vous entraînez une fois par semaine ou SEP fois c'est pas du tout les mêmes styles d'entraînement qu'il faut privilégier et pour terminer il y en aura pour tout le monde peu importe le nombre de jours où vous allez à la salle vous saurez après cette vidéo exactement comment diviser vos entraînements ok les gars on commence donc avec une séance par semaine pour introduire le sujet on sait que il faut stimuler le muscle d'accord deux fois par semaine pour avoir une progression optimale maintenant quand vous vous entraînez une fois par semaine bah vous pouvez pas stimuler chaque muscle deux fois vous comprenez bien mais une fois c'est OK une fois ça vous permet quand même de faire de la musculation d'avoir des résultats et ceux qui disent oui vaut mieux pas y aller que s'entraîner qu'une fois non moi je fais du paddle une fois par semaine j'ai pas un gros niveau ni de grosses ambitions pour autant à chaque fois que j'y vais je m'améliore un petit peu je prends plaisir et je suis meilleur qu'un gars qui n'y va pas du tout la progression oui elle est là mais elle sera lente la récupe bah elle sera très bonne vous avez pas à vous soucier de ça et juste avant de vous donner mon class si déjà vous vous engagez à aller à la salle une fois par semaine et que vous vous y tenez peut-être que par la suite vous allez pouvoir rajouter des séances et continuer à progresser un peu plus vite n'oubliez pas que en musculation ça sert à rien de s'y mettre à fond d' aller 2 heures par jour de faire des séances interminables de tout calculer au gram près si vous tenez pas sur la durée nous c'est ce qui a fait nos résultats c'est le fait de s'entraîner de manière régulière et de manière intense on est loin d'être ceux qui s'entraînent le plus de fois par semaine ni le plus longtemps pourtant on a des bons physiques bien sûr encore une fois pour pour terminer une séance par semaine vous allez pas avoir un physique de statue grec maintenant quelle est la meilleure répartition de quelle manière diviser ces entraînements quand on fait qu'une séance par semaine la pire de toutes bien sûr c'est le split parce que le split vous allez entraîner donc disons allez un split classique division en 4atre où on va faire les pecs avec les triceps le dos avec les biceps et cetera si vous diviser par 4 ça veut dire que chaque groupe musculaire vous allez le faire une fois par mois vous imaginez bien que là au niveau progression niveau résultat ça va pas être phénoménal donc c'est le pire ensuite vous avez le PPL pourquoi parce que c'est une division en trois parties donc vous allez faire chaque muscle une fois toutes les 3 semaines ensuite juste au-dessus très très proche vous avez half body plus PPL c'est quasi similaire ensuite vous avez le half body et là ça devient déjà un peu plus intéressant parce que chaque zone on va la travailler au moins une fois toutes les deux semaines et bien sûr le top du top si vous faites qu'une séance par semaine c'est le full body l'ensemble du corps parce que bien sûr bah vous allez au moins stimuler une fois chaque groupe musculaire dans la semaine ok on enchaîne maintenant avec deux séances par semaine déjà ça commence à être plus intéressant il y a une chose qui est importante si vous savez que vous pouvez aller à la salle deux fois par semaine si possible au moins d'accord un jour de repos entre les deux séances comme ça vous allez pouvoir travailler les mêmes zones musculaires deux fois dans la semaine si vous les mettez deux jours d'affilé malheureusement vous avez pas la récupération optimale pour refaire une même séance donc prenez au moins un jour de repos deux séances par semaine encore une fois et ben c'est mieux que une qui est moins bien que trois donc deux séances par semaine vous aurez deux fois plus de résultats pratiquement que la personne qui va y aller qu'une fois c'est encore une fois pas assez pour avoir un physique de statut grec d'accord note possible ok à moins que vous fassiez un autre sport qui va travailler de manière intense on va dire le physique vous pouvez quand même avoir un petit niveau voilà avec une bonne diète et cetera mais vous n attendez pas à des folies maintenant quel méthodologie quelle planification d'entraînement privilégié quand vous allez deux fois par semaine à la salle si vous avez bien écouté le split malheureusement encore une fois c'est la même division on va faire de séances par semaine donc on va attendre longtemps avant de retravailler le même muscle au minimum de semaines voire 3 semaines donc le split c'est le pire de tous juste au-dessus c'est pareil c'est le PPL vous avez aussi le mix ALP PPL juste au-dessus vous avez le half body qui est plutôt pas mal parce que vous allez bien mettre le focus et pouvoir faire un gros volume d'entraînement sur la zone qui est travaillée mais par contre vous allez la stimuler qu'une fois donc le half body c'est plutôt pas mal si vous faites vos deux jours d'affilé si par exemple vous entraînez mardi mercredi et ben vous savez que le half body c'est la meilleure solution maintenant si vous pouvez mettre au moins un jour de repos faites du full body et essayez de faire des séances qui sont plutôt longues avec des gros volumes d'entraînement bien sûr c'est du full body on va pas rester non plus 3h à la salle mais des séances d' 1h30 en full body en faisant au moins deux exercices pour les gros groupes musculaires et un exercice pour les petits groupes musculaires c'est ce qui me semble être le plus judicieux on passe aux choses sérieuses trois séances par semaine déjà avec trois séances par semaine on peut avoir un très bon physique déjà ça c'est une chose qu'il faut vous mettre en tête ça devient vraiment sérieux quand on est vraiment assidu qu'on s'entraîne de manière intelligente régulière avec de l'intensité en trois séances par semaine on peut vraiment avoir un très bon physique il y en a plein qui vont penser que le PPL c'est le plus adapté pour trois séances par semaine parce que bah justement c'est divisé en trois on va faire une séance push une séance poule une séance legs c'est parfait maintenant c'est pas la meilleure des répartition parce queon l'a vu tout à l'heure c'est mieux d'avoir plus de stimuli que ça dans la semaine du coup ce que je vous recommande si vous pouvez vous entraîner trois fois par semaine c'est de placer vos jours de repos entre chaque séance au moins un jour de repos entre chaque séance pour pouvoir retravailler le même muscle la séance suivante ou au moins travailler plusieurs fois les mêmes muscles dans la semaine donc si par exemple vous pouvez mettre lundi mercredi vendredi des entraînements c'est parfait et vous me voyez venir donc oui bien sûr la moins bonne des divisions ça va être le split encore une fois parce que on fait pas assez d'entraînement dans la semaine pour pouvoir stimuler de manière efficace chaque zone musculaire le pire c'est le split juste au-dessus vous avez le PPL juste au-dessus vous avez le half body plus PPL là où ça commence à être intéressant bah c'est le half body et pourquoi ça commence à être intéressant parce que une semaine sur deux vous allez faire la moitié du corps deux fois et l'autre moitié une fois et l'autre semaine et ben ça sera l'inverse la moitié du corps que vous avez fait deux fois la première semaine vous allez la faire une fois et celle que vous aviez fait une fois vous allez la faire deux fois donc c'est pas mal on va dire c'est une moyenne de 1,5 stimuli par muscle maintenant si vous voulez avoir chaque muscle stimulé deux fois le top du top c'est le full body avec bien sûr à chaque fois au moins un jour de repos entre chaque séance et c'est là vous allez avoir les résultats les plus optimaux quatre séances par semaine la marque des grands hommes la marque des hommes puissants bizarrement c'est à peu près le nombre de séances que moi je m'entraîne par semaine moi je vous avoue la vérité c'est que moi je vise 5 séances par semaine mais que il y a toujours un imprévu qui fait que en moyenne je tourne plus autour de 4 donc déjà avec qu sen par semaine ça devient vraiment sérieux d'accord vous pouvez avoir une grosse marge de progression ce qui est bien avec quatre séances par semaine c'est que vous pouvez plus varier vos entraînements ce qui est bien avec qu sances par semaine c'est que vous vous instaurer une vraie routine c'est ancré dans votre Lifestyle pratiquement plus de la moitié on va dire de la semaine vous allez à la salle donc quand vous le faites sur le long terme ça va vous apporter beaucoup de bénéfices d'accord dont la discipline et tout ce qui en découle motivation confiance en soi et cetera maintenant c'est là où ça va changer au niveau de la planification quatre séances par semaine bon vous savez à quel point je suis pas un fan du split et c'est pas pour faire le forceur mais même en faisant quatre séances par semaine le split c'est c'est pas ce qu'il y a de plus rentable pourquoi parce que quand vous faites du split vous divisez votre corps en quatre parties minimum donc si vous avez quatre séances par semaine vous stimulez chaque zone qu'une fois en général les mecs ils aiment bien faire PEC triceps dos biceps épaule jambes parfois même divisé quadr isquio bref le problème c'est qu'il y a pas assez de stimuli donc oui on peut mettre un gros volume d'entraînement sur la zone travaillée mais on le sait si c'est scientifiquement prouvé il vaut mieux avoir un volume d'entraîn plus faible mais stimulé deux fois la zone dans la semaine que de faire une séance interminable par exemple sur les pecs au final ça devient contreproductif donc le split je le mets encore en dernier et c'est la dernière fois vous inquiétez pas ensuite juste au-dessus et ben ça va être le full body l'autre extrême pourquoi parce que stimuler chaque zone quatre fois dans la semaine ça devient trop vous avez pas assez de récupération au final il y a trop de stimuli et pas assez de volume d'entraînement par groupe musculaire dans votre séance donc c'est pas on va dire la plus rentable il y a des gens qui le font même jusqu'à 7 fois vous pouvez faire du full body en fait tout se fait tout peut fonctionner mais le but et ce que je vous explique depuis tout à l'heure c'est le chemin le plus rapide en fonction du nombre de séances que vous avez à disposition le but c'est d'arriver à Rome le plus vite possible tous les chemins nous mènent à Rome maintenant nous on veut pas y aller par national on veut prendre l'autoroute donc split full body on laisse tomber maintenant là où ça devient intéressant c'est le pushpol legs donc le push pull legs ça devient déjà un peu plus intéressant parce queà chaque fois il va y avoir une des zones soit les muscles qui vous servent à pousser soit ceux qui vous servent à tirer soit les jambes qui vont être stimulés deux fois et à chaque semaine c'est un nouveau groupe musculaire qui est stimulé deux fois malheureusement ça reste trop faible d'accord il y a pas assez quand même de stimuli et on passe donc au half body mixé au PPL qui devient encore un peu plus intéressant parce que vous allez la plupart du temps stimuler deux fois chaque groupe musculaire d'accord si je fais upper lower PPL l si vous y allez quatre fois d'accord ça fait sence 1 2 3 4 et 1 2 3 4 et ainsi de suite vous voyez cette semaine là j'ai fait les muscles du haut du corps une fois push Pol deux fois donc ça c'est toujours le haut du corps ils ont été stimulés deux fois bref c'est intéressant parce que la plupart du temps vous allez stimuler deux fois chaque groupe musculaire mais à chaque semaine il y a un groupe qui est toujours un peu moins travaillé que les autres donc bien sûr vous l'avez compris le top du top quand vous faites quatre séance par semaine c'est de vous entraîner en half body pourquoi parce que vous allez avoir un volume d'entraînement conséquence sur chacune des zones et vous allez la stimuler cette zone deux fois dans la semaine ensuite les gars on enchaîne avec C séances par semaine c'est le top du top c'est ce que j'aimerais bien m'entraîner mais en même temps en même temps il faut laisser un petit peu respirer la concurrence faut leur donner un petit peu de la force donc je m'arrête à 4 mais 5 sces par semaine vraiment pour des gars qui ont un niveau en musculation qui s'entraînent de manière régulière Adu intense vous pouvez avoir des tops physiques avec ça des physiques de fou furieux des physiques de de statut grec et ce qui est bien en plus quand vous entraînez 5in fois par semaine c'est qu'il y a plusieurs divisions qui peuvent être intéressantes donc à vous aussi de tester de toute manière tout ce que je vous dis c'est basé encore une fois sur la science sur mon expérience mais vous devez aussi prendre en compte vous-même vos ressentis vos préférences ce qui marche sur vous donc c séances par semaine d'accord physique normalement d'accord si vous vous entraînez bien et depuis longtemps vous avez un physique de fou furieux d'accord si c'est pas le cas et que vous entraînez depuis plusieurs années 5 séances par semaine que vous mettez de l'intensité et cetera vous voyez vite la façon dont vous vous entraînez il y a quelque chose qui cloche venez faire un tour dans la barre d'info il y a le programme Apollon si toi aussi tu veux te transformer en 3 mois comme les gars que tu vois là et avoir un programme d'entraînement sur mesure la diète sur mesure et bien sûr les recettes qui vont avec avec le suivi des coachs nous-mêm sur WhatsApp tu as le lien en barre d'info c'est le programme qui a transformé le plus d'hommes en France alors pourquoi pas toi un autre point positif quand vous y allez 5 séance par semaine vous êtes quelqu'un à la salle vous êtes quelqu'un c'estàdire que quand vous arrivez on vous app par votre prénom il y a pas de carte qui passe pas tout le monde vous connaît vous dites bonjour à tout le monde et cetera vous savez quand il y a un nouveau bref vous faites partie des machines pas des meubles des machines et bien sûr on en a parlé juste avant quand tu t'entraînes cinq fois par semaine tu sais t'imposer une autodiscipline et ça c'est quelque chose qui vraiment va te servir dans la vie de tous les jours parce que tu sais être résilient d'accord quand tu y vas CIN fois par semaine c'est que tu y vas peu importeon ton niveau de motivation donc tu as le mindset j'ai fait trois traits d'accord je sais pas pourquoi maintenant il faut que je trouve la troisième raison mais bref quand tu es autodiscipliné tu es tout simplement confortable ah là vous croyez que j'allais pas trouver tu es confortable parce que quoi qu'il arrive peu importe le confort l'inconfort tu y vas tu es autodiscipliné oui ça se répète et alors on va voir maintenant quelle est la meilleure répartition quand on s'entraîne 5 fois par semaine la moins bonne des divisions vous l'avez compris ça va avec ce que j'ai dit juste avant mais c'est le full body parce que il y a trop de stimuli CIN fois par semaine c'est trop ensuite vous avez le split et oui pour tous les grands fans de Split qui étaient en transpiration depuis tout à l'heure et qui attendaient que j'annonce que c'était la meilleure méthode quand on s'entraîne 5in fois par semaine et ben non c'est toujours pas le split pourquoi parce que la plupart des zones ne vont être stimulées encore une fois qu'une fois dans la semaine donc c'est la deuxième moins bonne ensuite à égalité vous avez le push pull legs et puis le body le pushpol leg ce qui est bien c'est que la plupart du temps les zones vont être stimulées deux fois sauf une des zones dans la semaine et le half body le problème c'est que il y en a une qui va être stimulée trois fois ce qui est peut-être un petit peu beaucoup vaut mieux augmenter peut-être le volume d'entraînement bref ça se discutait un petit peu sur les deux mais par contre le top du top comme division si vous entraînez CIN fois par semaine c'est de faire un mix justement entre PPL et half body et c'est exactement de cette manière que moi je structure mes entraînements et vous allez comprendre pour pourquoi si séances par semaine j'ai pas effacé ça parce que si séances par semaine si tu as pas un physique de fou furieux là ça devient très grave si séances par semaine l'autodiscipline c'est même plus une question si séances par semaine tu es pas quelqu'un à la salle tu es un actionnaire d'accord tu tu contribues vraiment à l'économie du club donc bravo à toi et si séances par semaine c'est quelque chose pour les passionnés si tu es pas un passionné si tu prends pas plaisir à aller à la salle si tu trouves pas en tout cas les bénéfices et au bout de un moment tu vas lâcher parce que si Séan par semaine c'est c'est du temps je sais pas si vous vous rendez compte c'est peut-être une journée dans toute ta semaine pratiquement que tu as passer à la salle parce que on connaît les les mecs qui vont six fois par semaine qui discutent pendant 2 Hees et cetera bref si séances par semaine tu es obligé d'être une machine de guerre et quelle est la meilleure manière de s'entraîner déjà la pire en 6 s par semaine c'est le full body toujours pour la même raison juste au-dessus le half body parce que tu vas faire trois fois chaque zone par semaine c'est beaucoup trop et là les gars sont là il se disent bon c'est bon maintenant il va nous dire que c'est le split ou pas et ben non le split il arrive maintenant c'est pas toujours pas la meilleure pourquoi parce que tu vas encore une fois stimuler certaines zones que une fois dans la semaine donc non le split n'est pas la meilleure méthode même si tu t'entraînes six fois dans la semaine mais vous inquiétez pas c'est pas déconnant je veux dire si vraiment ton kiff c'est de faire du split et tu vas à la salle six fois par semaine fais du split tu auras des très bons résultats juste au-dessus vous avez la division hybride que j'adore al body PPL mais qui n'est pas non plus la meilleure parce que la meilleure si vous y allez six fois par semaine c'est de vous entraîner en pushpol legs x 2 et je vous conseille de faire des séances différentes c'estàdire d'avoir deux séances push de séances pool et de séances legs différentes si vous y allez six fois par semaine et on enchaîne avec 7 séances par semaine quand tu vas à la salle SEP fois par semaine tu te dois d'avoir un physique de Alpha d'accord ça commence comme ça MGA giga ultra Chad je sais pas ce que ça veut dire Chad mais vous avez compris et tu es plus actionnaire du club tu fais la bise au patron là si tu fais pas la bise il y a quelque chose qui va pas tu vas cette fois à la salle tu habites là-bas mon gars tu dois faire la bise au patron tu dois lui quand il part il sort de la salle tu dois lui mettre une petite fessée il y a quelque chose tu vois l'autodiscipline tu la bois l'autodiscipline c'est une blague pour toi quand tu vas cette fois à la salle par semaine maintenant c'est quoi la meilleure planification quand tu vas cette fois la salle par semaine allez-y allez-y c'est bon vous êtes contents la pire de toutes le full body juste au-dessus le body encore au-dessus l'hybride al plus PPL juste au-dessus ou là là attention le suspect est-ce qu'il a mis avant est-ce qu'il a mis après juste au-dessus nous avons le PPL parce que oui il va y avoir une zone qui va être stimulée trois fois ce qui peut faire beaucoup surtout quand on prend pas de jours de repos donc le top du top finalement quand on s'entraîne 7 jours sur 7 c'est de faire du split et je vais même vous l'écrire en gros ils sont contentsok ok maintenant qu'on a fait ce tableau on va voir quelle est la planification gagnante donc déjà la perdante la toute première des perdantes et c'est pas un secret on vous le dit depuis des années c'est le split malheureusement le split est efficace et intéressant uniquement selon moi si vous entraînez plus de 5 fois par semaine sinon il y a mieux je dis pas que c'est nul mais sinon il y a mieux donc le split une note de 2,14/ 5 ensuite vous avez le full body tant qui est une technique que j'apprécie et je pousse beaucoup de person person à faire du full body notamment quand il s'entraîne moins de quatre fois par semaine mais le full body voilà a eu la note de 3,14/ 5 parce que oui à partir du moment où on veut vraiment un bon niveau et aller à la salle au moins quatre fois par semaine ça devient beaucoup trop ensuite vous avez le PPL donc push pool legs qui est je pense actuellement la méthode de musculation la plus suivie en salle de sport et c'est pas une mauvaise chose le PPL c'est très bien c'est juste que ça manque un petit peu de stimuli si vous y allez pas six fois dans la semaine et on sait très bien que même ceux qui doivent y aller six fois mais il y a souvent des jours qui sautent donc le PPL 3,42/ 5 ensuite à égalité vous avez le al body et la division hybride entre half body et PPL qui monte à 3,57/ 5 maintenant pourquoi j'ai fait ce classement parce que c'est super intéressant dans le sens où en fait tu t'organises en fonction du nombre de séances que tu sais que tu vas pouvoir faire et il faut réussir à s'organiser à anticiper ce que vous avez à faire dans la semaine pour justement avoir une planification qui sera la plus efficace maintenant si vous êtes pas certain de toujours pouvoir faire le même nombre de séances alors faites comme moi et c'est exactement ce que j'ai fait en faisant cette division hybride al body PPL parce que si vous entraînez que trois fois et ben vous allez faire du al body si vous savez que vous entraînez que trois fois vous faites du al body si vous savez que vous allez vous entraîner quatre fois dans la semaine pareil vous faites les deux séances half body vous les répétez si vous savez que vous allez y aller cinq fois et ben vous faites votre division half body PPL et si vous savez que vous y allez six fois vous faites le PPL deux fois j'espère que vous avez compris ma logique pour moi c'est de loin la division la plus adaptable et la plus efficace et celle qui correspond à mon lifestyle à mon changement d'organisation de planning et cetera maintenant vous vous demandez peut-être c'est quoi le plus rentable de tout quel est le type d'entraînement où je vais passer le moins de temps possible et qui va me fournir le plus de résultats alors si vous vous posez cette question les gars quelle est la division qui va vous donner le plus de croissance muscul en passant un minimum de temps à la salle par semaine la réponse c'est le al body en quatre séances et d'ailleurs vous avez un ebook avec un programme qu'on vous offre et je peux vous assurer que si vous savez pas comment vous entraîner et diviser vos entraînements ou si alors vous vous êtes rendu compte que ce que j'ai présenté mais ça correspondait pas à ce que vous aviez mis en place essayez ça et vous allez nous en dire des nouvelles les gars j'espère en tout cas que la vidéo était précise que vous l'avez bien comprise que vous êtes d'accord avec nous si c'est pas le cas vous pouvez très bien bien débattre dans les commentaires et c'est avec plaisir pour vous lire c'est basé bien sûr sur notre expérience en tant que coach en tant que pratiquant mais aussi sur les études scientifiques et les études que nous on a pu faire de notre côté je ferai d'autres classements si ça vous intéresse de ce style dites-moi en commentaire ce que vous voulez que je classe mais bien sûr à chaque fois je faire en sorte que ce soit pertinent comme là c'est pas pertinent si on n'associe pas le nombre de jours d'entraînement qu'on place dans la semaine donc oui faire un classement par groupe musculaire d'exercices les plus efficaces si on prend pas tous les facteurs en compte ça n'a pas d'intérêt donc si je la fais je le ferai en fonction de certains facteurs pensez à télécharger le programme gratuit si vous voulez une grosse transformation en 3 mois vous savez où ça se passe c'est en barre d'info j'espère en tout cas que vous avez aimé la vidéo si c'est le cas pensez à liker si c'est pas le cas vous êtes quand même des gros teb d'être arrivé jusqu'ici c'était alex je vous dis à très vite et surtout d'ici là gardez la pêche

src/gradio/data/corpus_car_FULL_2.txt

@@ -0,0 +1 @@
+début 2025 explosion des ventes d'abonnements dans les salles de fitness c'est là où ils font leurs plus gros chiffres et les salles sont blindées en se début janvier et dans un mois ce sera vide donc dans cette vidéo on va voir comment obtenir son meilleur physique et surtout comment tenir sur la durée ses engagements pour réussir sa transformation bon avant de commencer on va voir toutes les erreurs qui vous font tout simplement abandonner vos bonnes résolutions et qui sont très communes à toutes les personnes qui abandonne la première c'est d'aller à la salle sans plan d'entraînement d'y aller au hasard en vous disant bah je verrai bien sur place ce que je vais faire non quand vous allez à la salle vous devez avoir un programme structuré savoir exactement ce que vous allez faire combien de temps ça va vous prendre on laisse pas de place à l'inconnu plus vous planifiez plus vous organisez plus vous allez tenir deuxème erreur très commune commencez en mettant trop d'intensité trop d'exercices trop de séances dans la semaine des séances trop longue n'oubliez pas une chose vous commencez vous êtes au début vous allez pas avoir le même programme d'entraînement que quelqu'un qui s'entraîne depuis 10 ans donc allez-y progressivement sinon vous allez vous en dégoûter vous allez avoir des courbatures incroyables bref c'est la meilleure manière pour abandonner vite rappelez-vous une chose votre but c'est d'avoir un bon physique et de l'avoir sur la durée de continuer à progresser de continuer à l'avoir et d'avoir ce physique tout au long de l'année si vous partez trop fort vous allez abandonner erreur numéro 3 et là ça concerne la nutrition deux grosses erreurs souvent les personnes qui sont trop minces et qui veulent prendre du poids vont partir vers le Dirty bulking ce qu'on va dire c'est manger un maximum de calories pour prendre du poids et au contraire il va y avoir tous ceux qui sont en surpoids qui ont trop de masse grasse qui vont vouloir perdre du poids et se mettre en gros déficit calorique ce sont deux erreurs communes qu'il ne faut pas que vous fassiez d'une pourquoi parce que si vous êtes en trop gros déficite calorique vous allez avoir un métabolisme qui va être ralenti et du coup vous allez consommer moins de gras et c'est donc contreproductif et pour le Dirty bulking c'est-à-dire ceux qui vont manger un maximum de calories pour prendre du poids c'est comme faire CIN pas en arrière pour faire un pas en avant vous ce que vous voulez c'est du muscle c'est pas spécialement de la masse grasse donc avoir un léger surplu calorique ok mais le Dirty bulking ne vous servira à rien vous allez juste B faire du gras que vous allez galérer à enlever après 4è erreur et là malheureusement vous ne pouvez rien y faire sauf y faire abstraction c'est les conseils de tout le monde et surtout de n'importe qui à la salle tout le monde veut donner des conseils tout le monde est un expert on entend des versions sur tel et tel sujet à dormir debout dans tous les cas focalisez-vous sur quelqu'un qui a des compétences comme par exemple Alex de bodytime je dis ça comme ça d'accord des professionnel et suivez votre entraînement votre planification allez jusqu'au bout ne posez pas des questions essayez pas de tout tester en même temps dernière erreur et qui est aussi très commune c'est de donner trop d'importance au compléments alimentaires ce sont des compléments alimentaires on appelle ça aussi suppléments alimentaires c'est en complément c'est en supplément c'est-à-dire que c'est en plus de l'entraînement l'alimentation le le sommeil le lifestyle tout ça c'est plus important que la prise de compléments alimentaire donc encore une fois si vous en avez pas vous voulez pas en prendre dès le début pas de souci vous pouvez très bien réussir votre transformation physique et si vous en prenez dites-vous que c'est juste un plus on va voir maintenant le point de départ j'aurais très bien pu faire une vidéo en vous disant ben ok fais ça mange comme ça entraîne-toi comme ça va à la salle tant de fois par semaine sauf que ben ça serait au mettre votre niveau de départ et la situation dans laquelle vous êtes alors que c'est primordial de faire justement un état des lieux de votre physique tout en étant honnête mettez votre ég de côté regardez-vous dans le miroir et soyez honnête est-ce que je suis gras d'accord c'està dire en surpoid est-ce que j'ai de la masse graisseuse entreut voilà fat entre guillemets est-ce que je suis plutôt skinny c'est-à-dire que je suis fin j'ai pas beaucoup de masse musculaire je suis pas bien épais et c'est ce qui me gêne ou alors est-ce que je suis un mix des deux c'est-à-dire fin avec pas beaucoup de masse musculaire mais par contre de la masse graiss ce qu'on appelle les skinny fat ça c'est le point de départ vous devez déterminer le physique que vous voyez dans la glace pour justement adapter ce que vous allez mettre en place on enchaîne maintenant avec les trainings et pourquoi on enchaîne avec les training parce qu'en fait que vous soyez fat skinny ou skinny fat c'est la même chose vous allez devoir vous entraîner et les conseils que je vis vous donner pardon que je vont vous donner que je vais vous donner s'applique à tout le monde sur les réseaux et d'une manière générale sur Internet et même à la salle vous vous voyez des dizaines des centaines des milliers d'exercices plus farfelus les uns que les autres il y en a pour tous les goûts et ça peut encore paraître bizarre parce que moi c'est vrai que j'aime bien faire des exercices qui sortent de l'ordinaire mais je suis un pratiquant de longue date et j'ai besoin d'amener régulièrement bah de la nouveauté du fun de Me challenger et d'être le plus complet possible donc oui je vais faire plein d'exercices qui sortent de l'ordinaire mais si vous êtes un débutant si vous êtes au début de votre transformation physique restez sur les exercces classiques les exercices polyarticulaires ceux qui vont vous faire consommer un maximum de calories travailler le plus de muscles à la fois ce qu' faut entrer plusieurs articulations en compte donc comme le développer couché le rowing les tractions les squat le soulever de terre les épaules et jetées les développer épules développer militaire des fentes et cetera ce sont des exercices que vous devez privilégier et surtout bien travailler votre technique bien travailler le mouvement avant de de passer à des exercices plus complexes bon peut-être que j'ai dit beaucoup d'exercices et que ça vous a perdu mais vous inquiétez pas vous n'avez pas besoin de retenir tous ces noms d'exercice on vous a préparé un programme débutant qui est gratuit le lien il est en barre d'info vous avez juste à le télécharger et à vous laisser guider à votre niveau la chose la plus importante c'est d'être maintenant régulier c'est pas de faire des séances de fou de rester 2hes à la salle d'y aller SEP fois par semaine non c'est de commencer avec un petit engageement que vous savez que vous allez tenir comme par exemple trois séances par semaine vous restez à la salle maximum une heure pour commencer c'est déjà très bien et vous allez avoir des courbatures vous allez avoir des résultats en commençant comme ça on dit il vaut mieux s'entraîner bien régulièrement que très bien de temps en temps un autre point qui est très important c'est pas directement relié à votre muscle mais ça va avoir un impact sur votre progression musculaire c'est l'environnement dans lequel vous vous entraînez il faut que vous soyez à au début les premiers jours c'est possible que vous soyez mal à l'aise mais si ça dure alors il faut trouver un autre environnement où vous allez être à l'aise si la salle ne vous convient pas changez de salle si vous entraînez en salle ça vous convient pas entraînez-vous chez vous entraînez-vous à l'extérieur changez de pratique bref trouver un environnement où vous allez vous sentir bien trouver des amis avec qui alleer partager vos entraînements des groupes peut-être sur les réseaux sociaux rejoignez-nous aussi pour vous aider à vous motiver bref soyez dans un environnement propice à la progression quelques petits conseils aussi il y en a certains pour qui ça peut avoir un gros impact moi je sais que c'est pas spécialement mon cas mais pour beaucoup d'autres personnes ça aide achetez-vous une tenue dans laquelle vous êtes à l'aise vous avez envie de la mettre ça vous fait plaisir quelques petits accessoires pour aller à la salle qui vous font plaisir une belle gourde une serviette une nouvelle tenue une nouvelle paire de basket bref ne vous focalisez pas là-dessus c'est pas ça qui va faire votre transformation mais si ça peut rajouter du plaisir ça vous permettra d'être plus régulier et surt surtout de pas lâcher moi par exemple avant de mettre des débardeurs bodyt je faisais 20 kg de moins à partir du moment où j'ai eu ce débardeur bodyt là j'avais envie d'aller à la salle tous les jours et pour récapituler rapidement sur la partie training ce qu'il faut c'est faire des exercices simples du polyarticulaire rester dans des fourchettes de répétition aussi qui vous correspondent quand vous êtes débutant c'est plutôt entre 10 et 15 répétitions on peut descendre quand on est plus avancé et dernier point important si possible pour une progression optimale stimuler deux fois chaque groupe musculaire par semaine mais encore une fois vous avez le programme gratuit en barre d'info ok maintenant on va voir la nutrition et c'est à ce moment-là où c'est important de prendre en compte le fait que soit vous êtes fat soit vous êtes skinny soit vous êtes skinny fat pour commencer si vous êtes gros bon si vous êtes fat ça passe mux en anglais on a le droit de le dire en anglais en français à ce qu' paraît pas trop c'est méchant la première chose à faire c'est pas de tout traquer de compter votre gramme de riz grain par grain à moins que vous rentriez dans un programme de transformation physique et vra vous vous mettiez à fond dedans et cetera mais sinon il faut juste regarder ce que vous êtes en train de manger prendre conscience chaque jour de ce que vous mangez ce que vous buvez et le contrôler en essayant d'éliminer la junk food d'éliminer les boissons gazeuses les boissons sucrées et tout en fait ces calories vides qui nous apportent rien pas d'effet de saciété ça vous apporte aucun bénéfice d'un point de vue santé d'un point de vue performance d'un point de vue musculation tout simplement donc privilégie bien sûr tous les aliments non transformés le moins possible manger des aliments en fait tout simplement brutes que vous allez cuisiner vous-même pourquoi je vous dis ça parce que dans les aliments transformés et ultra transformés il y a énormément d'additifs et de sucre et de gras que ce soit pour la conservation pour le goût et bien sûr pour vous rendre accro et vous faire continuer à consommer ces merdes vous allez voir que tout simplement en faisant ça vous allez voir votre poids descendre sur la balance et votre masse grasse diminuer et dans tous les cas si vous avez 20 % de masse grasse ou plus que ça en changeant seulement ça vous allez voir de gros Chang c'est sûr que si vous êtes plus à 15 % de masse grasse que vous êtes un peu gras vous avez pas les abdos mais vous êtes pas en gros surpoids il va falloir fournir sûrement plus d'effort on va voir maintenant les skinny les maigres maigres j'ai le droit de le dire c'est pas c'est pas une insulte c'est gros qu'on a pas le droit maig pour vous ce qu'il faut prioriser c'est le fait de vous entraîner plus dur à chaque fois je disais tout à l'heure pas trop intense mais vous vous avez quand même besoin de mettre une certaine intensité pour créer du muscle maintenant au niveau de la nutrition il faut prioriser les prot proté vous devez manger assez de protéines et jusqu'à 2 g par poids de corps pour faire du muscle quand vous vous entraînez vous cassez des fibres musculaires et grâce à ces protéin pour faire simple vous reconstruisez ses fibres musculaires un petit peu plus fortes donc c'est pour ça que vous devez vous entraîner un peu plus dur à chaque fois et avoir un bon apport en protéin jusqu'à 2 g par poids de corps maintenant le souci c'est que quand vous mangez beaucoup de protéines vous pouvez peut-être ne pas arriver au ratio calorique dont vous avez besoin c'est-à-dire ne pas manger assez de calories au total et du coup vous allez pas prendre de poids donc l'astuce pour manger manger assez de calories c'est de manger beaucoup de smoothie des purées et tous ces aliments là que vous avez pas besoin de mastiquer pourquoi parce que la mastication va envoyer un effet de saciété au cerveau plus rapidement donc si vous mangez des purées et des soupes vous mâchez moins vous envoyez cet effet de saciété plus tard donc vous mangez plus tout ça en fait c'est le principe de densité calorique vous devez manger des aliments qui en peu de volume vous apporte beaucoup de calories en plus de ça bien sûr privilégiez toujours les aliments organiques les aliments réel et pas transformé donc dans mon smoothie je vais mettre des bananes des amandes du beurre de cacahuète tout ça ce sont des aliments très caloriques qui vont vous permettre d'atteindre votre quota calorique en vous donnant bah des nutriments de bonne qualité et bah sans vous détruire la santé tout simplement maintenant si vous êtes skiny fat il y a deux options soit vous partez dans l'option prendre du poids pour faire du muscle parce que c'est vraiment ça qui vous gêne le plus dans votre physique mais moi je préfère l'option de sécher de commencer avec un lait g déficit calorique parce que vous allez tout de suite avoir l'impression d'avoir plus de muscles parce que la définition vous donne cette impression là quand vous perdez du gras vous voyez mieux vos muscles et parfois peut-être que vous vous trouviez maigre mais en perdant cette petite couche de masse grasse mais en fait vous avez une masse musculaire qui va se dévoiler et vous allez vous trouver bien mieux esthétiquement parlant alors oui peut-être que dans les vêtements vous allez pas bien plus les remplir mais c'est déjà une première étape qui va vous pousser à être motivé et à tenir sur la durée donc moi si vous êtes un skin fat je vous conseille de virer ce gras dans tous les cas il va pas vous servir vous avez pas besoin d'avoir un gros surplus calorique pour prendre de la masse musculaire et vous de toute façon vous avez cette ce petit excédent de gras qui vous donne de l'énergie pour vous entraîner et créer du muscle conclusion maintenant s'il y a juste quelques points à retenir de la vidéo pour vraiment tenir sur la durée et avoir vraiment ce bon physique que vous allez tenir en 2025 c'est ne commencez pas trop dur ne vous fixez pas des objectif irréalisable ne passez pas du tout au tout c'est-à-dire que si vous ne faites aucun entraînement et que vous mangez n'importe quoi ben ne vous mettez pas vous entraîer SEP fois par semaine avec une diète ultra restrictive n'allez pas à la salle sans savoir quoi faire organisez vos training organiser les temps et les jours où vous allez vous entraîner faites un vrai bilan objectif de votre physique pour pouvoir avoir une nutrition adaptée faites des choses simples et efficaces et pour terminer n'attendez pas que toutes les étoiles soient aligné pour commencer ce qui est très important c'est que ceux qui réussissent c'est ceux qui se lancent pas ceux qui attendent que ce soit parfait pour se lancer vous allez faire quelques erreurs c'est pas grave vous savez il y a un proverbe chinois qui dit le meilleur moment pour planter un arbre c'était il y a 20 ans et le deuxième meilleur moment c'est maintenant au final si tu te cherches encore des excuses c'est que peut-être tu as pas vraiment décidé de réussir on dit que il vaut mieux faire plein d'effort répété que de mettre un grand coup d'épée alors fais les choses maintenant et surtout surtout d'ici là cararde la pêche.

src/gradio/data/corpus_car_FULL_3.txt

@@ -0,0 +1 @@
+le nombre de séries à faire par exercice dans une séance de musculation ça reste quand même un point d'interrogation pour beaucoup de pratiquants est-ce qu'il faut faire 2 3 4 5 séries par exercice est-ce qu'il faut adapter le nombre de séries à l'objectif ou à l'exercice en question aujourd'hui je vais répondre à toutes ces interrogations bienvenue sur la chaîne fitmas je m'appelle nassim saili je suis le créateur des programmes fitmas des programmes qui sont faits pour vous quel que soit votre objectif que vous vouliez prendre du muscle perdre du gras constituer votre propre programme ou même avoir un accompagnement personnalisé avec l'un des coachs fitmas sur fitmas.fr vous retrouverez plein de programmes basés sur la science et qui sont évidemment conçus et testés par mes soins le lien du site fitmas.fr fr est dans la description et voyons ensemble quel est le nombre de séances parfait par exercice lorsqu'on cherche à déterminer le nombre de séries à effectuer par exercice il faut d'abord se poser la question suivante : combien de séries je vais effectuer par semaine et par groupe musculaire c'est un peu la base quand on va constituer un programme de musculation si on ne sait pas combien de séries on effectue par semaine et par groupe musculaire et bien c'est très difficile de pouvoir les répartir sur chacune de vos séances et sur chacun de vos exercices pourquoi est-ce qu'on prend ce référentiel là parce que toutes les études scientifiques sur le sujet ont été faites sur le nombre de séries hebdomadaires et par groupe musculaire petit exemple vous décidez pour les pectoraux de faire 20 séries dans la semaine et vous ne faites qu'une seule séance pectorau par semaine et bien ces 20 séries devront être réparti sur 3 4 5 exercices que vous allez effectuer dans votre séance pectorau et du coup si vous faites quatre exercices et que vous devez comptabiliser 20 séries vous en arrivez à 5 séries par exercice c'est juste un exemple sur le terrain le nombre de séries hebdomadaires doit être minutieusement choisi en fonction de votre objectif de votre expérience et des points forts points faibles que vous pourriez avoir mais lorsque vous avez compris que le plus important n'était pas nécessairement le nombre de séries par exercice mais plutôt le nombre total de séries par groupe musculaire et par semaine on a déjà fait un gros pas en avant le deuxième point important lorsque vous choisissez le nombre de séries à faire par exercice c'est la gestion de la fatigue j'ose espérer que dans votre programme de musculation vous avez sûrement déjà testé de faire trois séries quatre séries cin séries par exercice et je suis presque certain que vous avez remarqué que lorsque vous faites 4 5 voire même peut-être six séries et bien vos performances ont tendance à chuter assez rapidement c'est ça qu'on appelle la gestion de la fatigue vous n'êtes pas sans savoir que pour prendre du muscle il faut quand même soulever des charges de travail importantes soulever des charges de travail importantes vous permettra de provoquer une tension mécanique importante qui se traduira par de l'hypertrophie donc vos fibres musculaires qui vont grossir mais si au fur et à mesure de votre exercice vos performances ont tendance à chuter trop rapidement et bien forcément ça aura une répercussion sur l'intensité de travail et à terme sur votre progression tout ça veut dire que vous allez devoir faire un minimum d'expérimentation je vous recommande de tester plusieurs nombres de séries par exercice 3 4 5 voire même 6 et de vérifier à quel point vos performances descendent au fur et à mesure de ces séries si par exemple sur du développer couché vous êtes fixé des séries de 10 que vous arrivez à utiliser 100 kg sur la première série 100 kg sur la 2è série 90 kg sur la 3e série mais qu'à partir de la 4e série on descend à 70 60 la réduction est bien trop importante et dans ce cas-là il aurait fallu s'arrêter à la 3è série pourquoi je dis qu'il faut expérimenter parce que ça dépend de l'exercice du groupe musculaire de votre expérience à la salle de votre tolérance à la douleur donc malheureusement impossible de vous donner un chiffre qui fonctionnera pour tous les cas de figure mais ça tombe bien l'expérimentation vous permettra d'en apprendre beaucoup plus sur votre corps et pour compléter le point précédent en réalité il n'y a pas de minimum ni de maximum je me rappelle d'une anecdote super intéressante d'arnold schwarzenegger qui s'entraînait au gold gym pendant l'âge d'or du bodybuilding c'est-à-dire à peu près dans les années 70 il racontait à quel point lui-même expérimentait différents formats d'entraînement et différents nombres de séries par exercice allant jusqu'à faire des séances d'entraînement où il n'effectuaient qu'une seule série par exercice et donc multipliait le nombre d'exercices ou au contraire des séances d'entraînement où il n'y avait qu'un seul exercice et un nombre de séries assez délirant on part de 15 20 25 séries sur un seul exercice alors bien sûr ça c'est des pratiques extrêmes qui sont là juste pour expérimenter mais ils avaient pas d'autres choix à l'époque étant donné qu'il y avait pas autant d'études scientifiques qu'aujourd'hui mais ça nous permet de réaliser qu'il n'y a pas de minimum ni de maximum si vous arrivez à choisir un exercice et qu'il ne vous faut qu'une seule série pour atteindre l'intensité maximale la charge maximale atteindre l'échec musculaire sans aucun problème et que ça s'imbrique bien dans le reste de votre programmation d'entraînement c'est nickel et puis au contraire si vous êtes dans une phase d'entraînement où l'accumulation de volume va être importante il n'y a aucune contre-indication à faire 6 7 8 séries ou même du 10 x 10 par exemple qui a un format d'entraînement très populaire dans la musculation et d'ailleurs j'aurais même tendance à dire que varier le nombre de séries par exercice bah ça apporte un peu de variété un peu de nouveauté ça permet d'explorer différents types d'effort et à condition que vous soyez bien attentif à vos performances que vous notiez vos séances pour être sûr de suivre ce que vous avez fait bah je trouve que c'est une excellente idée d'explorer différents types d'entraînement pour voir comment votre corps répond je suis hyper fan du 6 x 6 du 8 x 8 ou du 10 x 10 que j'intègre très souvent dans mes propres séances d'entraînement et que j'intègre aussi dans les programmes fitmass en fonction de l'objectif ça peut permettre une stimulation musculaire hyper intéressante une dépense énergétique hyper intéressante ça apporte de la variété ça permet de voir où sont ses limites il y a que du positif derrière ça donc ne vous formalisez pas sur les séances classiques avec quatre séries de 10 explorer d'autres horizons et je suis sûr que ça rajoutera pas mal de choses à vos séances de musculation mais alors on peut se demander pourquoi la plupart des programmes de musculation on se retrouve avec un format très classique de quatre séries et parfois même de 10 à 12 répétitions en fait c'est un peu basé sur les études scientifiques qui ont été faites il y a un moment maintenant plusieurs décennies et qui recommandaient de faire entre 16 et 20 séries par semaine et par groupe musculaire et si on part du principe que chaque groupe musculaire était entraîné une fois par semaine avec quatre ou cinq exercices différents et bien on se retrouve 20 séries qui sont réparti en quatre ou cinq exercices donc environ quatre séries de travail dans une prochaine vidéo je pourrais vous expliquer pourquoi la plupart des programmes de musculation comportent des séries de 10 ou 12 répétitions mais pour le coup c'est un peu le même principe pour le nombre de séries il y a pas vraiment de justification et comme je l'ai précisé dans les points précédents rien ne nous empêche à faire un petit peu moins ou même beaucoup plus à condition de savoir pourquoi on fait ce choix dans mes propres programmes de musculation et ceux que je propose sur le site fitmas.fr je pars toujours du nombre de séries hebdomadaires par groupe musculaire et c'est avec cette variable qui est la plus importante de toutes que je vais faire ma petite répartition c'est exactement comme ça que je vous recommande de faire pour éviter de vous entraîner au hasard à l'instinct et de choisir le nombre de séries en fonction de votre humeur du jour mais sans vraie cohérence par rapport à votre programmation d'entraînement vous savez que s'entraîner à l'instinct c'est pas quelque chose que je recommande parce que c'est très très difficile de suivre ces performances et de les faire évoluer petit à petit et le nombre de séries par exercice ça reste une variable très importante qu'il faut traquer pour pouvoir la faire évoluer donc c'est jamais une mauvaise idée de faire quatre séries par exercice mais n'oubliez pas qu'on a beaucoup d'autres possibilités qui s'ouvrent à nous pour essayer de progresser le plus rapidement possible avec toutes ces informations lorsque vous commencerez l'un des programmes fitmas pas être surpris si vous voyez certains exercices où il n'y a que deux séries et d'autres exercices on peut monter très haut 8 10 séries de travail que ce soit d'ailleurs dans vrt mon programme spécial prise de muscle ou dans superet mon programme spécial perte de gras j'utilise plein de fourchettes de répétition différentes plein de formats différents et des nombres de séries par exercice qui peuvent varier en fonction de l'objectif du cycle en question et de ce qu'on aimerait provoquer sur le corps et d'ailleurs tout ça je l'explique bien plus en détail dans fitmas builder qui vous permet de construire votre propre programme en fonction de vos spécificités votre emploi du temps vos points forts vos points faibles c'est hyper complet donc si jamais vous voulez jeter un œil vous cliquez sur le premier lien dans la description je suis sûr que sur fitmas.fr vous trouverez le programme qui vous correspond que vous soyez un homme ou une femme quel que soit votre objectif quelle que soit votre fréquence d'entraînement donc allez y faire un tour et bon courage lorsque vous commencerez votre programme.

src/gradio/data/goal_map.json

@@ -0,0 +1,9 @@
+[
+    "Athletics",
+    "Bodybuilding",
+    "Bodyweight Fitness",
+    "Muscle & Sculpting",
+    "Olympic Weightlifting",
+    "Powerbuilding",
+    "Powerlifting"
+]

src/gradio/generators/execution_generator.py

@@ -0,0 +1,345 @@
+import json
+from pathlib import Path
+from functools import lru_cache
+from typing import Mapping, Union, List
+
+import re
+import pandas as pd
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+# ---------------------------------------------------------------------
+# Paths + device
+# ---------------------------------------------------------------------
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+MODEL_DIR = PROJECT_ROOT / "models" / "v1"
+
+# Dossier de ton modèle finetuné d'exécution
+# EXEC_MODEL_DIR = MODEL_DIR / "transformer_execution_generator_v3"
+# Chargement du modèle HF (tokenizer + modèle)
+MODEL_REPO = "AIppyDev/transformer_execution_generator_v3"
+MODEL_SUBFOLDER = "transformer_execution_generator_v3"  # le nom du dossier dans le repo
+REPORT_PATH = MODEL_DIR / "execution_generator_model_report.json"
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Nombre max de tokens générés (équivalent MAX_LENGTH du notebook)
+EXEC_MAX_NEW_TOKENS = 180
+
+# ---------------------------------------------------------------------
+# Construction du prompt pour un programme
+# ---------------------------------------------------------------------
+
+def build_execution_prompt(row: Union[pd.Series, Mapping, None]) -> str:
+    """
+    Construit le prompt d'exécution à partir d'une ligne de programme.
+
+    Format :
+    The {exercise_name} exercise for "{target_muscles}" with "{equipment}" on "{difficulty}" level:
+    """
+    if row is None:
+        return ""
+
+    def get_val(key: str, default: str = "") -> str:
+        if isinstance(row, pd.Series):
+            val = row.get(key, default)
+        else:
+            val = row.get(key, default) if hasattr(row, "get") else default
+
+        if pd.isna(val):
+            return default
+        return str(val).strip()
+
+    name = get_val("exercise_name", "this exercise")
+    muscle = get_val("target_muscles", "the target muscles")
+    equipment = get_val("equipment", "bodyweight")
+    difficulty = get_val("difficulty", "General")
+
+    prompt = (
+        f'The {name} exercise for '
+        f'"{muscle}" with '
+        f'"{equipment}" on '
+        f'"{difficulty}" level:'
+    )
+    return prompt
+
+
+# ---------------------------------------------------------------------
+# Utils de post-traitement
+# ---------------------------------------------------------------------
+
+def strip_prompt_from_generations(prompts: List[str], generated_outputs: List[str]) -> List[str]:
+    """
+    Supprime le prompt au début de chaque génération si le modèle l'a recopié.
+    """
+    cleaned = []
+
+    for prompt, gen in zip(prompts, generated_outputs):
+        gen_strip = gen.strip()
+
+        if gen_strip.startswith(prompt):
+            cleaned.append(gen_strip[len(prompt):].strip())
+        else:
+            cleaned.append(gen_strip)
+
+    return cleaned
+
+
+def trim_to_last_full_sentence(text: str) -> str:
+    """
+    Coupe le texte à la dernière phrase complète.
+    On garde tout jusqu'au dernier '.', '!' ou '?'.
+    Si aucun n'est trouvé, on renvoie le texte brut stripé.
+    """
+    text = text.strip()
+
+    last_dot = text.rfind(".")
+    last_excl = text.rfind("!")
+    last_q = text.rfind("?")
+
+    last_punct = max(last_dot, last_excl, last_q)
+
+    if last_punct != -1:
+        return text[: last_punct + 1].strip()
+    return text
+
+
+def keep_first_n_sentences(text: str, n: int = 2) -> str:
+    """
+    Garde seulement les n premières phrases (séparation grossière sur . ! ?).
+    """
+    sentences = re.split(r'([.!?])', text)
+    chunks = []
+    count = 0
+
+    for i in range(0, len(sentences) - 1, 2):
+        sentence = sentences[i].strip()
+        punct = sentences[i + 1].strip()
+        if sentence:
+            chunks.append(sentence + punct)
+            count += 1
+        if count >= n:
+            break
+
+    return " ".join(chunks).strip() if chunks else text.strip()
+
+
+def dedupe_muscle_list(text: str) -> str:
+    """
+    Détecte les listes du type 'glutes, hamstrings, and hamstrings'
+    dans la phrase, les déduplique et les reformate proprement.
+    """
+
+    # Regex qui capture une liste séparée par virgules ou 'and'
+    # Exemple capturé : "glutes, hamstrings, and hamstrings"
+    pattern = r"([A-Za-z ]+(?:,\s*[A-Za-z ]+)*(?:\s+and\s+[A-Za-z ]+)?)"
+
+    def process_match(match):
+        segment = match.group(0)
+
+        # Split sur virgules et 'and'
+        parts = re.split(r",|\band\b", segment)
+        parts = [p.strip() for p in parts if p.strip()]
+
+        # Déduplique tout en gardant l’ordre
+        seen = set()
+        unique = []
+        for p in parts:
+            if p.lower() not in seen:
+                seen.add(p.lower())
+                unique.append(p)
+
+        # Reconstruction naturelle
+        if len(unique) == 1:
+            return unique[0]
+
+        if len(unique) == 2:
+            return f"{unique[0]} and {unique[1]}"
+
+        return ", ".join(unique[:-1]) + f", and {unique[-1]}"
+
+    # Applique la fonction sur toutes les occurrences
+    cleaned = re.sub(pattern, process_match, text)
+    return cleaned
+
+
+def clean_execution_text(text: str) -> str:
+    """
+    Nettoyage final : espaces, 'reps', etc.
+    """
+    if not isinstance(text, str):
+        return text
+
+    cleaned = text
+
+    # 1) Ajouter un espace après un point si collé à une majuscule
+    cleaned = re.sub(r'(\.)([A-Z])', r'\1 \2', cleaned)
+
+    # 2) Ajouter un espace après "such as" si collé à un chiffre
+    cleaned = re.sub(r"(such as)(\d)", r"\1 \2", cleaned)
+
+    # 3) Ajouter un espace avant "reps" si collé au chiffre
+    cleaned = re.sub(r"(\d)(reps)", r"\1 reps", cleaned)
+
+    # 4) Normaliser les doubles espaces
+    cleaned = re.sub(r"\s{2,}", " ", cleaned).strip()
+
+    return cleaned
+
+
+# ---------------------------------------------------------------------
+# Chargement du modèle HF (tokenizer + modèle)
+# ---------------------------------------------------------------------
+
+@lru_cache()
+def _load_exec_model():
+    """
+    Charge une seule fois tokenizer + modèle pour l'execution generator.
+    Utilise un cache pour éviter les rechargements coûteux.
+    """
+
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO,
+            subfolder=MODEL_SUBFOLDER,)
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_REPO,
+            subfolder=MODEL_SUBFOLDER,
+        torch_dtype=torch.float32,   # CPU friendly
+    )
+    model.to(DEVICE)
+    model.eval()
+
+    return tokenizer, model
+
+
+# ---------------------------------------------------------------------
+# Génération de texte pour l'exécution (1 prompt, pipeline complet)
+# ---------------------------------------------------------------------
+
+def generate_execution_text(
+    prompt: str,
+    max_new_tokens: int = EXEC_MAX_NEW_TOKENS,
+    temperature: float = 0.8,
+    top_k: int = 250,
+    top_p: float = 0.92,
+) -> str:
+    """
+    Génère une description d'exécution à partir d'un prompt unique,
+    avec le même pipeline que dans le notebook d'entraînement.
+    """
+    prompt = (prompt or "").strip()
+    if not prompt:
+        return "No prompt available to generate execution."
+
+    tokenizer, model = _load_exec_model()
+
+    sample_prompts = [prompt]
+
+    encodings = tokenizer(
+        sample_prompts,
+        return_tensors="pt",
+        padding=True,
+        truncation=True,
+    )
+    encodings = {k: v.to(DEVICE) for k, v in encodings.items()}
+
+    # 1. Génération
+    outputs = model.generate(
+        **encodings,
+        max_new_tokens=max_new_tokens,   # nombre maximum de tokens générés
+        min_new_tokens=50,               # longueur minimale
+        do_sample=True,                  # sampling activé (obligatoire pour top-k / top-p)
+        temperature=temperature,         # légère "chauffe" pour plus de variété
+        top_k=top_k,                     # top-K sampling large
+        top_p=top_p,                     # nucleus sampling
+        no_repeat_ngram_size=3,          # évite les répétitions de 3-grams
+        num_beams=5,                     # beam search pour améliorer la cohérence
+        num_return_sequences=1,          # une seule génération par prompt
+        pad_token_id=tokenizer.eos_token_id,
+        early_stopping=True,            # arrêt anticipé si EOS atteint partout
+    )
+
+    generated_outputs = tokenizer.batch_decode(
+        outputs,
+        skip_special_tokens=True,
+    )
+
+    # 2. On enlève le prompt au début de chaque génération
+    cleaned_generations = strip_prompt_from_generations(
+        prompts=sample_prompts,
+        generated_outputs=generated_outputs,
+    )
+
+    # 3. Post-traitement élément par élément
+    trimmed = [trim_to_last_full_sentence(txt) for txt in cleaned_generations]
+    limited = [keep_first_n_sentences(t, n=2) for t in trimmed]
+    deduped = [dedupe_muscle_list(t) for t in limited]
+    final = [clean_execution_text(t) for t in deduped]
+
+    return final[0] if final else ""
+
+
+def get_dl_execution_model_report_components():
+    """
+    Retourne 4 DataFrames Gradio-ready :
+    - Summary
+    - Model
+    - Training
+    - Metrics
+
+    Si pas de rapport → retourne les DF vides.
+    """
+
+    report_path = REPORT_PATH
+    if not report_path or not report_path.exists():
+        return _empty_dl_dfs()
+
+    try:
+        data = json.loads(report_path.read_text(encoding="utf-8"))
+    except Exception as e:
+        print(f"[DL REPORT] Error while reading {report_path}: {e}")
+        return _empty_dl_dfs()
+
+    # ===== Summary =====
+    dataset = data.get("dataset", {})
+
+    summary_rows = [
+        ("created_at",        data.get("created_at", "")),
+        ("task",              data.get("task", "")),
+        ("target",            data.get("target", "")),
+        ("framework",         data.get("framework", "")),
+        ("dataset.file",      dataset.get("file", "")),
+        ("dataset.size_bytes", dataset.get("size_bytes", "")),
+        ("dataset.tokens",    dataset.get("tokens", "")),
+    ]
+
+    df_summary = pd.DataFrame(summary_rows, columns=["Key", "Value"])
+
+    # ===== Model config =====
+    model_cfg = data.get("model", {}) or {}
+    df_model = pd.DataFrame(
+        [(k, v) for k, v in model_cfg.items()],
+        columns=["Key", "Value"],
+    )
+
+    # ===== Training =====
+    training_cfg = data.get("training", {}) or {}
+    df_training = pd.DataFrame(
+        [(k, v) for k, v in training_cfg.items()],
+        columns=["Key", "Value"],
+    )
+
+    # ===== Metrics =====
+    metrics_cfg = data.get("metrics", {}) or {}
+    df_metrics = pd.DataFrame(
+        [(k, v) for k, v in metrics_cfg.items()],
+        columns=["Metric", "Value"],
+    )
+
+    return df_summary, df_model, df_training, df_metrics
+
+def _empty_dl_dfs():
+    df_summary = pd.DataFrame({"Key": [], "Value": []})
+    df_model = pd.DataFrame({"Key": [], "Value": []})
+    df_training = pd.DataFrame({"Key": [], "Value": []})
+    df_metrics = pd.DataFrame({"Metric": [], "Value": []})
+    return df_summary, df_model, df_training, df_metrics

src/gradio/generators/gpt2_distillation_text_generator.py

@@ -0,0 +1,227 @@
+import textwrap
+import torch
+import re
+
+class GPT2_DistilledTextGenerator:
+    """
+    Wrapper pour le modèle GPT-2 distillé de TrAIn.me.
+    Gère :
+    - génération auto-régressive
+    - temperature / top_p
+    - max_new_tokens
+    """
+
+    def __init__(self, model, tokenizer, max_new_tokens: int = 256):
+        self.model = model
+        self.tokenizer = tokenizer
+        self.max_new_tokens = max_new_tokens
+
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model.to(self.device)
+        self.model.eval()
+
+    # ------------------------------------------------------------------
+    # Génération simple
+    # ------------------------------------------------------------------
+    def generate_text(
+        self,
+        prompt: str,
+        temperature: float = 0.8,
+        top_p: float = 0.9,
+        strip_prompt: bool = True,
+    ) -> str:
+
+        prompt = prompt.strip()
+        if not prompt:
+            return "Please enter a prompt before generating."
+
+        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
+
+        with torch.no_grad():
+            output_ids = self.model.generate(
+                **inputs,
+                max_new_tokens=self.max_new_tokens,
+                do_sample=True,
+                temperature=temperature,
+                top_p=top_p,
+                pad_token_id=self.tokenizer.eos_token_id,
+                eos_token_id=self.tokenizer.eos_token_id,
+            )
+
+        text = self.tokenizer.decode(output_ids[0], skip_special_tokens=True)
+
+        if strip_prompt and text.startswith(prompt):
+            text = text[len(prompt):].lstrip()
+
+        return text
+
+    # ------------------------------------------------------------------
+    # Ancienne fonction interactive (simple)
+    # ------------------------------------------------------------------
+    def generer_exercice_interactif(
+        self,
+        workout_type: str = "strength",
+        debut: str = "",
+        num_samples: int = 3,
+        max_length: int = 120,
+        temperature: float = 1.0,
+    ):
+        device = torch.device("cpu")
+
+        if debut:
+            prompt = f"Workout [{workout_type}]: {debut}"
+        else:
+            prompt = f"Workout [{workout_type}]:"
+
+        print(f"\nGénération de {num_samples} exemples ({workout_type.upper()})")
+        print(f"Prompt : '{prompt}'\n")
+        print("=" * 80)
+
+        self.model.to(device)
+        self.model.eval()
+
+        for i in range(num_samples):
+            inputs = self.tokenizer(prompt, return_tensors="pt").to(device)
+
+            with torch.no_grad():
+                output_ids = self.model.generate(
+                    **inputs,
+                    max_length=max_length,
+                    do_sample=True,
+                    temperature=temperature,
+                    top_k=50,
+                    top_p=0.95,
+                    eos_token_id=self.tokenizer.eos_token_id,
+                    pad_token_id=self.tokenizer.eos_token_id,
+                )
+
+            generated_text = self.tokenizer.decode(
+                output_ids[0],
+                skip_special_tokens=True
+            )
+
+            return textwrap.fill(
+                generated_text,
+                width=75,
+                initial_indent="   ",
+                subsequent_indent="   ",
+            )
+
+
+    # ------------------------------------------------------------------
+    # Filtre amélioré
+    # ------------------------------------------------------------------
+    def generate_with_filter(
+        self,
+        model,
+        tokenizer,
+        prompt: str,
+        goal: str,
+        n_candidates: int = 3,
+        max_new_tokens: int = 160,
+        temperature: float = 0.7,
+        top_k: int = 40,
+        top_p: float = 0.9,
+        max_attempts: int = 3,
+    ):
+        device = torch.device("cpu")
+        model.to(device)
+        model.eval()
+
+        self.model.to(device)
+        self.model.eval()
+
+        for i in range(1):
+            inputs = self.tokenizer(prompt, return_tensors="pt").to(device)
+
+            with torch.no_grad():
+                output_ids = self.model.generate(
+                    **inputs,
+                    max_length=160,
+                    do_sample=True,
+                    temperature=temperature,
+                    top_k=50,
+                    top_p=0.95,
+                    eos_token_id=self.tokenizer.eos_token_id,
+                    pad_token_id=self.tokenizer.eos_token_id,
+                )
+
+            generated_text = self.tokenizer.decode(
+                output_ids[0],
+                skip_special_tokens=True
+            )
+
+            return textwrap.fill(
+                generated_text,
+                width=75,
+                initial_indent="   ",
+                subsequent_indent="   ",
+            )
+
+    # ------------------------------------------------------------------
+    # Version V2 pour l'IHM
+    # ------------------------------------------------------------------
+
+
+
+    def generer_exercice_interactif_V2(
+        self,
+        level: str,
+        goal: str,
+        num_samples: int = 3,
+        max_length: int = 150,
+        temperature: float = 1.0,
+        candidates_per_sample: int = 3,
+    ):
+
+        prompt = f"{level} level ({goal})\n\n"
+
+        texts = []
+
+        for i in range(num_samples):
+            # ⬇️ ICI : appel via self, plus via la classe
+            generated_text = self.generate_with_filter(
+                model=self.model,
+                tokenizer=self.tokenizer,
+                prompt=prompt,
+                goal=goal,
+                n_candidates=candidates_per_sample,
+                max_new_tokens=160,
+                temperature=0.7,
+                top_k=40,
+                top_p=0.9,
+            )
+
+
+            
+             # Suppression des artefacts de liste Python
+            cleaned = generated_text.replace("['", "")
+            cleaned = cleaned.replace("']", "")
+            cleaned = cleaned.replace('", "', ' ')  # parfois utilisé dans les listes
+
+            # Supprimer les retours à la ligne trop nombreux
+            cleaned = cleaned.replace("\n", " ")
+
+            # Retirer le prompt si le modèle l'a recopié
+            prompt_strip = prompt.strip()
+            if prompt_strip and cleaned.startswith(prompt_strip):
+                cleaned = cleaned[len(prompt_strip):].lstrip()
+
+            # Suppression des doubles espaces
+            cleaned = re.sub(r"\s{2,}", " ", cleaned)
+
+            # Trim final
+            cleaned = cleaned.strip()
+
+
+            texts.append(
+                textwrap.fill(
+                    cleaned,
+                    width=75,
+                    initial_indent="   ",
+                    subsequent_indent="   ",
+                )
+            )
+
+        return texts
+

src/gradio/generators/gpt2_fine_tuning_text_generator.py

@@ -0,0 +1,54 @@
+import torch
+
+GPT2_FINE_TUNING_GENERATOR: "GPT2_FineTuningTextGenerator | None" = None
+
+
+class GPT2_FineTuningTextGenerator:
+    """
+    Wrapper simple autour du modèle GPT-2 fine-tuné de TrAIn.me.
+    Gère :
+    - la génération autoregressive
+    - temperature / top_p
+    - max_new_tokens
+    """
+
+    def __init__(self, model, tokenizer, max_new_tokens: int = 256):
+        self.model = model
+        self.tokenizer = tokenizer
+        self.max_new_tokens = max_new_tokens
+
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model.to(self.device)
+        self.model.eval()
+
+    def generate_text(
+        self,
+        prompt: str,
+        temperature: float = 0.9,
+        top_p: float = 0.95,
+        strip_prompt: bool = True,
+    ) -> str:
+        """Génère du texte à partir du prompt."""
+        prompt = prompt.strip()
+        if not prompt:
+            return "Please enter a prompt before generating."
+
+        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
+
+        with torch.no_grad():
+            output_ids = self.model.generate(
+                **inputs,
+                max_new_tokens=self.max_new_tokens,
+                do_sample=True,
+                temperature=temperature,
+                top_p=top_p,
+                pad_token_id=self.tokenizer.eos_token_id,
+                eos_token_id=self.tokenizer.eos_token_id,
+            )
+
+        text = self.tokenizer.decode(output_ids[0], skip_special_tokens=True)
+
+        if strip_prompt and text.startswith(prompt):
+            text = text[len(prompt):].lstrip()
+
+        return text

src/gradio/generators/lstm_text_generator.py

@@ -0,0 +1,273 @@
+import re
+from pathlib import Path
+from collections import OrderedDict
+
+import numpy as np
+import torch
+import torch.nn as nn
+import pandas as pd  # <-- NEW
+
+from tensorflow.keras.preprocessing.text import Tokenizer
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+
+
+class LSTMTextGenerator:
+    """
+    Gestionnaire dédié pour le LSTM :
+    - reçoit un modèle déjà chargé (PyTorch ou Keras) depuis on_model_change
+    - OU un state_dict PyTorch (OrderedDict) → reconstruit alors un nn.Module
+    - charge + nettoie le corpus texte
+    - recrée le tokenizer (identique au notebook LSTM v3)
+    - génère du texte à partir d'un seed.
+    """
+
+    # Racine du projet + chemin vers le corpus CSV
+    PROJECT_ROOT = Path(__file__).resolve().parents[2]
+    CORPUS_CSV_PATH = PROJECT_ROOT / "gradio" / "data" / "program_summary.csv"
+
+    # Colonnes textuelles utilisées dans le notebook LSTM v3
+    TEXT_COLUMNS = [
+        "program_title",
+        "description",
+        "goal",
+        "target_muscles",
+        "equipment",
+        "instructions",
+    ]
+
+    # Longueur de séquence par défaut (cf. LSTM_model_report.json)
+    DEFAULT_SEQUENCE_LENGTH = 15
+
+    # Singleton interne
+    _instance: "LSTMTextGenerator | None" = None
+
+    # ----------------------------------------------------------------------
+    # Constructeur
+    # ----------------------------------------------------------------------
+    def __init__(self, model, tokenizer, max_length: int | None = None):
+
+        # Si on reçoit un state_dict PyTorch → reconstruire un nn.Module
+        if isinstance(model, OrderedDict):
+            model = self._build_torch_model_from_state_dict(model)
+
+        self.model = model
+        self.tokenizer = tokenizer
+        self.max_length = max_length or self.DEFAULT_SEQUENCE_LENGTH
+
+        # Backend PyTorch ou Keras
+        self._is_torch = isinstance(self.model, torch.nn.Module)
+        if self._is_torch:
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+            self.model.to(self.device)
+            self.model.eval()
+        else:
+            self.device = None
+
+    # ----------------------------------------------------------------------
+    # Reconstruction d'un modèle PyTorch à partir d'un state_dict
+    # ----------------------------------------------------------------------
+    @staticmethod
+    def _build_torch_model_from_state_dict(state: OrderedDict) -> torch.nn.Module:
+        """
+        Reconstruit dynamiquement un LSTM language model standard à partir d'un state_dict
+        de la forme :
+
+            embedding.weight  -> (vocab_size, embedding_dim)
+            lstm.weight_ih_l0 -> (4*hidden_dim, embedding_dim)
+            fc.weight         -> (vocab_size, hidden_dim)
+        """
+
+        emb_weight = state.get("embedding.weight", None)
+        fc_weight = state.get("fc.weight", None)
+        lstm_weight_ih_l0 = state.get("lstm.weight_ih_l0", None)
+
+        if emb_weight is None or fc_weight is None or lstm_weight_ih_l0 is None:
+            raise TypeError(
+                "Impossible de reconstruire le LSTM PyTorch : "
+                "les clés attendues 'embedding.weight', 'lstm.weight_ih_l0', "
+                "'fc.weight' sont absentes du state_dict. "
+            )
+
+        vocab_size, embedding_dim = emb_weight.shape
+        out_features, hidden_dim = fc_weight.shape
+
+        if out_features != vocab_size:
+            print(
+                f"[LSTMTextGenerator] Avertissement : fc.weight shape={fc_weight.shape} "
+                f"→ out_features != vocab_size ({out_features} != {vocab_size})."
+            )
+
+        num_layers = 1
+        for n in range(1, 10):
+            if f"lstm.weight_ih_l{n}" in state:
+                num_layers = n + 1
+            else:
+                break
+
+        class TorchLSTMLanguageModel(nn.Module):
+            def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers):
+                super().__init__()
+                self.embedding = nn.Embedding(vocab_size, embedding_dim)
+                self.lstm = nn.LSTM(
+                    input_size=embedding_dim,
+                    hidden_size=hidden_dim,
+                    num_layers=num_layers,
+                    batch_first=True,
+                )
+                self.fc = nn.Linear(hidden_dim, vocab_size)
+
+            def forward(self, x):
+                emb = self.embedding(x)          # (batch, seq_len, embed_dim)
+                out, _ = self.lstm(emb)          # (batch, seq_len, hidden_dim)
+                logits = self.fc(out)            # (batch, seq_len, vocab_size)
+                return logits
+
+        model = TorchLSTMLanguageModel(
+            vocab_size=vocab_size,
+            embedding_dim=embedding_dim,
+            hidden_dim=hidden_dim,
+            num_layers=num_layers,
+        )
+        model.load_state_dict(state)
+        return model
+
+    # ----------------------------------------------------------------------
+    # Méthodes de classe : singleton
+    # ----------------------------------------------------------------------
+    @classmethod
+    def get_instance(cls, model) -> "LSTMTextGenerator":
+        """
+        Retourne une unique instance de LSTMTextGenerator, initialisée à partir :
+        - d'un modèle LSTM déjà chargé (Keras ou PyTorch)
+        - ou d'un state_dict PyTorch (OrderedDict)
+        - du corpus texte dans data/programs/program_summary.csv
+        """
+        if cls._instance is not None:
+            return cls._instance
+
+        # Charger + nettoyer le corpus (version CSV anglaise)
+        full_text_clean = cls._load_full_clean_corpus()
+
+        # Recréer le tokenizer EXACT comme dans le notebook
+        tokenizer = cls.build_tokenizer_from_corpus(full_text_clean)
+
+        max_length = cls.DEFAULT_SEQUENCE_LENGTH
+        if hasattr(model, "input_shape") and getattr(model, "input_shape") is not None:
+            try:
+                max_length = int(model.input_shape[1]) + 1
+            except Exception:
+                pass
+
+        cls._instance = cls(
+            model=model,
+            tokenizer=tokenizer,
+            max_length=max_length,
+        )
+        return cls._instance
+
+    # ----------------------------------------------------------------------
+    # Helpers internes : corpus + nettoyage + tokenizer
+    # ----------------------------------------------------------------------
+    @classmethod
+    def _load_full_clean_corpus(cls) -> str:
+        """
+        Version LSTM v3 :
+        - charge `program_summary.csv`
+        - concatène plusieurs colonnes textuelles
+        - applique clean_text(...)
+        """
+        csv_path = cls.CORPUS_CSV_PATH
+        if not csv_path.exists():
+            raise FileNotFoundError(f"Corpus CSV not found: {csv_path}")
+
+        df = pd.read_csv(csv_path)
+
+        # On garde seulement les colonnes réellement présentes
+        text_cols = [c for c in cls.TEXT_COLUMNS if c in df.columns]
+        if not text_cols:
+            raise ValueError(
+                f"Aucune des colonnes textuelles attendues {cls.TEXT_COLUMNS} "
+                f"n'a été trouvée dans {csv_path.name}."
+            )
+
+        df[text_cols] = df[text_cols].fillna("")
+
+        # Concaténation ligne par ligne (comme dans le notebook)
+        lines = []
+        for _, row in df[text_cols].iterrows():
+            line = " ".join(str(row[c]) for c in text_cols).strip()
+            if line:
+                lines.append(line)
+
+        full_text = "\n".join(lines)
+        return cls.clean_text(full_text)
+
+    @staticmethod
+    def clean_text(texte: str) -> str:
+        """Nettoie et normalise le texte (version notebook)."""
+        texte = texte.lower()
+        texte = texte.replace("'", "")
+        texte = re.sub(r"([.,!?])", r" \1 ", texte)
+        texte = re.sub(r"\s+", " ", texte)
+        return texte.strip()
+
+    @staticmethod
+    def build_tokenizer_from_corpus(full_text_clean: str) -> Tokenizer:
+        tok = Tokenizer(filters="", lower=False, oov_token="<UNK>")
+        tok.fit_on_texts([full_text_clean])
+        return tok
+
+    # ----------------------------------------------------------------------
+    # Prédiction : unification Keras / PyTorch
+    # ----------------------------------------------------------------------
+    def _predict_proba(self, token_list: np.ndarray) -> np.ndarray:
+        if self._is_torch:
+            x = torch.from_numpy(token_list).long().to(self.device)
+            with torch.no_grad():
+                logits = self.model(x)
+                if logits.dim() == 3:
+                    logits = logits[:, -1, :]
+                logits = logits[0]
+                probs = torch.softmax(logits, dim=-1).cpu().numpy()
+            return probs
+        else:
+            preds = self.model.predict(token_list, verbose=0)
+            return preds[0]
+
+    # ----------------------------------------------------------------------
+    # Génération auto-régressive
+    # ----------------------------------------------------------------------
+    def generate_text(
+        self,
+        seed_text: str,
+        num_words: int = 40,
+        temperature: float = 0.8,
+        seed: int | None = None,
+    ) -> str:
+        rng = np.random.default_rng(seed) if seed is not None else np.random
+        generated_text = seed_text
+
+        for _ in range(num_words):
+            token_list = self.tokenizer.texts_to_sequences([generated_text])[0]
+            token_list = pad_sequences(
+                [token_list],
+                maxlen=self.max_length - 1,
+                padding="pre",
+            )
+
+            predictions = self._predict_proba(token_list)
+            predictions = np.log(predictions + 1e-7) / temperature
+            predictions = np.exp(predictions) / np.sum(np.exp(predictions))
+
+            predicted_id = rng.choice(len(predictions), p=predictions)
+
+            predicted_word = ""
+            for word, index in self.tokenizer.word_index.items():
+                if index == predicted_id:
+                    predicted_word = word
+                    break
+
+            if predicted_word:
+                generated_text += " " + predicted_word
+
+        return generated_text

src/gradio/generators/transformer_text_generator.py

@@ -0,0 +1,552 @@
+import re
+from pathlib import Path
+from collections import OrderedDict
+from typing import Optional, Union, Mapping
+
+import numpy as np
+import torch
+import torch.nn as nn
+from tensorflow.keras.preprocessing.text import Tokenizer
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+
+
+# ======================================================================
+#  BLOCS PYTORCH : doivent matcher ceux du notebook transformer_trainme_v2
+# ======================================================================
+
+
+class PositionalEmbedding(nn.Module):
+    """
+    Embedding de tokens + encodage positionnel (version légère).
+
+    Dans le notebook v2, la seule partie entraînable côté embedding est
+    `token_emb : Embedding(vocab_size, embed_dim)`.
+    La partie positionnelle peut rester non-paramétrique.
+    """
+
+    def __init__(self, vocab_size: int, embed_dim: int, max_length: int):
+        super().__init__()
+        self.token_emb = nn.Embedding(vocab_size, embed_dim)
+        self.max_length = max_length
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        x : (batch, seq_len)  →  retourne (batch, seq_len, embed_dim)
+        On se contente ici d'un token embedding + encodage positionnel implicite
+        (comme dans le notebook, aucun poids supplémentaire n'était enregistré
+        dans le state_dict).
+        """
+        # (batch, seq_len, embed_dim)
+        token_embeddings = self.token_emb(x)
+        return token_embeddings
+
+
+class MultiHeadSelfAttention(nn.Module):
+    """
+    Multi-Head Self-Attention maison, comme dans le notebook v2.
+
+    - query, key, value : Linear(embed_dim → embed_dim)
+    - out : Linear(embed_dim → embed_dim)
+    """
+
+    def __init__(self, embed_dim: int, num_heads: int, dropout_rate: float = 0.1):
+        super().__init__()
+        assert embed_dim % num_heads == 0, "embed_dim doit être divisible par num_heads"
+
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.head_dim = embed_dim // num_heads
+
+        self.query = nn.Linear(embed_dim, embed_dim)
+        self.key = nn.Linear(embed_dim, embed_dim)
+        self.value = nn.Linear(embed_dim, embed_dim)
+        self.out = nn.Linear(embed_dim, embed_dim)
+
+        self.dropout = nn.Dropout(dropout_rate)
+
+    def _scaled_dot_product_attention(
+        self,
+        q: torch.Tensor,
+        k: torch.Tensor,
+        v: torch.Tensor,
+        mask: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        """
+        q, k, v : (batch, num_heads, seq_len, head_dim)
+        mask    : (seq_len, seq_len) ou (batch, 1, seq_len, seq_len)
+        """
+        dk = q.size(-1)
+        scores = torch.matmul(q, k.transpose(-2, -1)) / np.sqrt(dk)  # (b, h, L, L)
+
+        if mask is not None:
+            # mask == 0 → -inf
+            scores = scores.masked_fill(mask == 0, float("-inf"))
+
+        attn_weights = torch.softmax(scores, dim=-1)
+        attn_weights = self.dropout(attn_weights)
+        output = torch.matmul(attn_weights, v)  # (b, h, L, head_dim)
+        return output
+
+    def forward(self, x: torch.Tensor, mask: Optional[torch.Tensor] = None) -> torch.Tensor:
+        """
+        x : (batch, seq_len, embed_dim)
+        """
+        batch_size, seq_len, _ = x.size()
+
+        # Projections linéaires
+        q = self.query(x)  # (b, L, d)
+        k = self.key(x)
+        v = self.value(x)
+
+        # Split en têtes : (b, L, h, d_h) → (b, h, L, d_h)
+        def split_heads(t):
+            return t.view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)
+
+        q = split_heads(q)
+        k = split_heads(k)
+        v = split_heads(v)
+
+        # Attention avec masque causal éventuel
+        attn_output = self._scaled_dot_product_attention(q, k, v, mask=mask)
+
+        # Merge heads : (b, h, L, d_h) → (b, L, d)
+        attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, seq_len, self.embed_dim)
+
+        # Projection finale
+        out = self.out(attn_output)  # (b, L, d)
+        return out
+
+
+class TransformerBlock(nn.Module):
+    """
+    Bloc Transformer standard :
+    - MultiHeadSelfAttention
+    - Add & Norm
+    - FFN (Linear → ReLU → Linear)
+    - Add & Norm
+    """
+
+    def __init__(
+        self,
+        embed_dim: int,
+        num_heads: int,
+        ff_dim: int,
+        dropout_rate: float = 0.1,
+    ):
+        super().__init__()
+        self.att = MultiHeadSelfAttention(embed_dim, num_heads, dropout_rate=dropout_rate)
+        self.ffn = nn.Sequential(
+            nn.Linear(embed_dim, ff_dim),
+            nn.ReLU(),
+            nn.Linear(ff_dim, embed_dim),
+        )
+
+        self.layernorm1 = nn.LayerNorm(embed_dim)
+        self.layernorm2 = nn.LayerNorm(embed_dim)
+        self.dropout_att = nn.Dropout(dropout_rate)
+        self.dropout_ffn = nn.Dropout(dropout_rate)
+
+    def _causal_mask(self, seq_len: int, device: torch.device) -> torch.Tensor:
+        """
+        Masque triangulaire inférieur (causal) de taille (1, 1, seq_len, seq_len)
+        compatible avec la forme (batch, num_heads, L, L).
+        """
+        mask = torch.tril(torch.ones((seq_len, seq_len), device=device)).unsqueeze(0).unsqueeze(0)
+        return mask  # (1, 1, L, L)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        x : (batch, seq_len, embed_dim)
+        """
+        seq_len = x.size(1)
+        device = x.device
+
+        # Masque causal L x L
+        mask = self._causal_mask(seq_len, device)
+
+        # Self-attention + residual
+        attn_output = self.att(x, mask=mask)
+        x = self.layernorm1(x + self.dropout_att(attn_output))
+
+        # FFN + residual
+        ffn_output = self.ffn(x)
+        x = self.layernorm2(x + self.dropout_ffn(ffn_output))
+
+        return x
+
+
+class TransformerLanguageModel(nn.Module):
+    """
+    Modèle PyTorch complet pour la génération de texte (version du notebook v2).
+
+    Architecture :
+    Input (tokens ids) →
+        PositionalEmbedding →
+        [TransformerBlock] × N →
+        Dropout →
+        Linear(embed_dim → vocab_size) sur la DERNIÈRE position
+    """
+
+    def __init__(
+        self,
+        vocab_size: int,
+        max_length: int,
+        embed_dim: int,
+        num_heads: int,
+        ff_dim: int,
+        num_blocks: int,
+        dropout_rate: float = 0.1,
+    ):
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.max_length = max_length
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.ff_dim = ff_dim
+        self.num_blocks = num_blocks
+        self.dropout_rate = dropout_rate
+
+        self.embedding = PositionalEmbedding(vocab_size, embed_dim, max_length)
+        self.blocks = nn.ModuleList(
+            [
+                TransformerBlock(
+                    embed_dim=embed_dim,
+                    num_heads=num_heads,
+                    ff_dim=ff_dim,
+                    dropout_rate=dropout_rate,
+                )
+                for _ in range(num_blocks)
+            ]
+        )
+        self.dropout = nn.Dropout(dropout_rate)
+        self.fc_out = nn.Linear(embed_dim, vocab_size)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        x : (batch, seq_len)  →  logits : (batch, vocab_size) sur la dernière position.
+        """
+        # Embedding (batch, seq_len, embed_dim)
+        x = self.embedding(x)
+
+        # Empilement des blocs Transformer
+        for block in self.blocks:
+            x = block(x)
+
+        # Dropout global
+        x = self.dropout(x)
+
+        # On ne garde que la dernière position
+        last_token = x[:, -1, :]  # (batch, embed_dim)
+
+        # Logits vocabulaire
+        logits = self.fc_out(last_token)  # (batch, vocab_size)
+        return logits
+
+
+# ======================================================================
+#  GÉNÉRATEUR DE TEXTE : TransformerTextGenerator
+# ======================================================================
+
+
+class TransformerTextGenerator:
+    """
+    Générateur de texte pour le modèle Transformer (PyTorch, checkpoint v2).
+
+    - Charge le corpus texte depuis PROJECT_ROOT / data/raw/nlp
+    - Nettoie le texte comme dans le notebook
+    - Reconstruit le tokenizer (word-level) identique
+    - Reconstruit le modèle PyTorch si on reçoit un state_dict (OrderedDict)
+    - Génère du texte en mode auto-régressif à partir d'un seed.
+    """
+
+    # Singleton interne
+    _instance: "TransformerTextGenerator | None" = None
+
+    # Références au projet / corpus
+    PROJECT_ROOT = Path(__file__).resolve().parents[2]
+    CORPUS_DIR = PROJECT_ROOT / "gradio" / "data"
+    CORPUS_LENGTH_PARAM = "_car_FULL_"  # même filtre que dans le notebook FULL_50
+
+    # Longueur de séquence par défaut (notebook FULL_50)
+    DEFAULT_MAX_LENGTH = 50
+
+    def __init__(self, model, tokenizer: Tokenizer, max_length: int):
+        # Ici, on veut un nn.Module, pas un state_dict
+        if isinstance(model, (dict, OrderedDict)):
+            raise TypeError(
+                "TransformerTextGenerator a reçu un 'state_dict' (OrderedDict) au lieu d'un modèle. "
+                "Reconstruction du modèle attendue AVANT l'instanciation."
+            )
+
+        self.model = model
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+
+        # Backend: PyTorch ou Keras (théorique, mais ici on est en PyTorch)
+        self._is_torch = isinstance(self.model, nn.Module)
+        if self._is_torch:
+            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            self.model.to(self.device)
+            self.model.eval()
+        else:
+            self.device = None
+
+    # ------------------------------------------------------------------
+    # Méthodes de classe : singleton / factory
+    # ------------------------------------------------------------------
+    @classmethod
+    def get_instance(cls, model_or_state) -> "TransformerTextGenerator":
+        """
+        Retourne une unique instance, basée sur :
+        - un modèle Transformer PyTorch déjà construit (nn.Module)
+        - OU un state_dict (OrderedDict) provenant du .pt sauvegardé.
+        """
+
+        if cls._instance is not None:
+            return cls._instance
+
+        # 1) Reconstruire le modèle PyTorch si on reçoit un state_dict
+        if isinstance(model_or_state, (dict, OrderedDict)):
+            torch_model = cls._build_torch_model_from_state_dict(model_or_state)
+        else:
+            # On suppose ici un nn.Module déjà prêt (PyTorch)
+            torch_model = model_or_state
+
+        # 2) Charger + nettoyer le corpus, rebuild du tokenizer
+        full_text_clean = cls._load_full_clean_corpus()
+        tokenizer = cls._build_tokenizer_from_corpus(full_text_clean)
+
+        # 3) max_length : si le modèle l'expose, on le récupère, sinon fallback
+        max_length = getattr(torch_model, "max_length", cls.DEFAULT_MAX_LENGTH)
+
+        cls._instance = cls(
+            model=torch_model,
+            tokenizer=tokenizer,
+            max_length=max_length,
+        )
+        return cls._instance
+
+    # ------------------------------------------------------------------
+    # Reconstruction du modèle PyTorch depuis le state_dict
+    # ------------------------------------------------------------------
+    @classmethod
+    def _build_torch_model_from_state_dict(
+        cls,
+        state: Mapping[str, torch.Tensor],
+    ) -> TransformerLanguageModel:
+        """
+        Reconstruit un `TransformerLanguageModel` à partir d’un state_dict
+        tel que sauvegardé dans le notebook transformer_trainme_v2.
+
+        On infère les hyperparamètres structurants à partir des shapes :
+        - vocab_size        : dim 0 de embedding.token_emb.weight
+        - embed_dim         : dim 1 de embedding.token_emb.weight
+        - ff_dim            : dim 0 de blocks.0.ffn.0.weight
+        - num_blocks        : nombre de blocs présents dans `blocks.{i}.att.query.weight`
+        - num_heads         : on reprend la valeur du notebook (4)
+        - max_length        : on utilise DEFAULT_MAX_LENGTH (50) utilisée lors du training.
+        """
+
+        # Vérifications de base
+        if "embedding.token_emb.weight" not in state:
+            raise KeyError(
+                "Le state_dict fourni ne contient pas la clé 'embedding.token_emb.weight'. "
+                "Vérifie que tu utilises bien le checkpoint du TransformerLanguageModel v2."
+            )
+
+        # vocab_size, embed_dim
+        token_emb_weight = state["embedding.token_emb.weight"]
+        vocab_size = token_emb_weight.shape[0]
+        embed_dim = token_emb_weight.shape[1]
+
+        # ff_dim
+        ffn0_key = "blocks.0.ffn.0.weight"
+        if ffn0_key not in state:
+            raise KeyError(
+                f"Clé '{ffn0_key}' absente du state_dict. "
+                "La structure attendue est blocks.{i}.ffn.0.weight."
+            )
+        ff_dim = state[ffn0_key].shape[0]
+
+        # Nombre de blocs
+        num_blocks = 0
+        while f"blocks.{num_blocks}.att.query.weight" in state:
+            num_blocks += 1
+        if num_blocks == 0:
+            raise ValueError(
+                "Impossible de déterminer le nombre de blocs Transformer "
+                "(aucune clé 'blocks.{i}.att.query.weight' trouvée)."
+            )
+
+        # Dans le notebook v2, num_heads = 4
+        num_heads = 4
+
+        # max_length : utilisé pour le positional encoding, non paramétrique
+        max_length = cls.DEFAULT_MAX_LENGTH
+
+        # Dropout rate standard du notebook
+        dropout_rate = 0.1
+
+        # Construction du modèle
+        model = TransformerLanguageModel(
+            vocab_size=vocab_size,
+            max_length=max_length,
+            embed_dim=embed_dim,
+            num_heads=num_heads,
+            ff_dim=ff_dim,
+            num_blocks=num_blocks,
+            dropout_rate=dropout_rate,
+        )
+
+        # Chargement des poids
+        model.load_state_dict(state)
+        return model
+
+    # ------------------------------------------------------------------
+    # Chargement du corpus & nettoyage
+    # ------------------------------------------------------------------
+    @classmethod
+    def _load_full_clean_corpus(cls) -> str:
+        """
+        Reproduit la logique du notebook :
+
+        - charge les .txt dans CORPUS_DIR
+        - filtre avec CORPUS_LENGTH_PARAM
+        - concatène
+        - applique clean_text(...)
+        """
+        corpus_dir = cls.CORPUS_DIR
+        if not corpus_dir.exists():
+            raise FileNotFoundError(f"Corpus directory not found: {corpus_dir}")
+
+        corpus_paths = sorted(
+            p
+            for p in corpus_dir.glob("*.txt")
+            if (not cls.CORPUS_LENGTH_PARAM or cls.CORPUS_LENGTH_PARAM in p.name)
+        )
+
+        if not corpus_paths:
+            raise FileNotFoundError(
+                f"No corpus .txt files found in {corpus_dir} "
+                f"(filter='{cls.CORPUS_LENGTH_PARAM}')"
+            )
+
+        corpus_texts = []
+        for path in corpus_paths:
+            with open(path, encoding="utf-8") as f:
+                corpus_texts.append(f.read())
+
+        full_text = "\n".join(text.strip() for text in corpus_texts)
+        full_text_clean = cls.clean_text(full_text)
+        return full_text_clean
+
+    @staticmethod
+    def clean_text(texte: str) -> str:
+        """Nettoie et normalise le texte (version notebook)."""
+        texte = texte.lower()
+        texte = texte.replace("'", "")
+        texte = re.sub(r"([.,!?])", r" \1 ", texte)
+        texte = re.sub(r"\s+", " ", texte)
+        return texte.strip()
+
+    # ------------------------------------------------------------------
+    # Tokenizer
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _build_tokenizer_from_corpus(full_text_clean: str) -> Tokenizer:
+        """
+        Recrée le tokenizer EXACTEMENT comme dans le notebook :
+
+            tokenizer = Tokenizer(filters='', lower=False, oov_token='<UNK>')
+            tokenizer.fit_on_texts([full_text_clean])
+        """
+        tok = Tokenizer(filters="", lower=False, oov_token="<UNK>")
+        tok.fit_on_texts([full_text_clean])
+        return tok
+
+    def _encode_prompt(self, prompt: str) -> list[int]:
+        """Nettoie le prompt et le convertit en liste d’IDs tokens."""
+        prompt_clean = self.clean_text(prompt)
+        token_list = self.tokenizer.texts_to_sequences([prompt_clean])[0]
+        return token_list
+
+    # ------------------------------------------------------------------
+    # Backend-unified prediction
+    # ------------------------------------------------------------------
+    def _predict_proba(self, sequence: np.ndarray) -> np.ndarray:
+        """
+        Unifie la prédiction entre Keras (.predict) et PyTorch (.forward).
+        Retourne un vecteur de probabilités sur le vocabulaire.
+        """
+        if self._is_torch:
+            x = torch.from_numpy(sequence).long().to(self.device)
+            with torch.no_grad():
+                logits = self.model(x)
+                # Ici, logit final : (batch, vocab_size)
+                if logits.dim() == 2:
+                    logits = logits[0]  # (vocab_size,)
+                else:
+                    # fallback très défensif
+                    logits = logits.view(-1)
+                probs = torch.softmax(logits, dim=-1).cpu().numpy()
+            return probs
+        else:
+            # Chemin Keras théorique (non utilisé dans v2)
+            return self.model.predict(sequence, verbose=0)[0]
+
+    # ------------------------------------------------------------------
+    # Génération
+    # ------------------------------------------------------------------
+    def generate_text(
+        self,
+        seed_text: str,
+        num_words: int = 60,
+        temperature: float = 1.0,
+        seed: Optional[int] = None,
+    ) -> str:
+        """
+        Génère du texte à partir d’un prompt initial, en mode auto-régressif.
+
+        - temperature contrôle la créativité
+        - num_words = nombre de tokens supplémentaires à générer
+        """
+        seed_text = seed_text.strip()
+        if not seed_text:
+            return ""
+
+        rng = np.random.default_rng(seed) if seed is not None else np.random
+
+        generated_text = seed_text
+        token_list = self._encode_prompt(seed_text)
+
+        for _ in range(num_words):
+            if not token_list:
+                break
+
+            # Padding / tronquage à max_length-1 comme au training
+            sequence = pad_sequences(
+                [token_list],
+                maxlen=self.max_length - 1,
+                padding="pre",
+            )
+
+            # Prédiction du prochain token (probas)
+            preds = self._predict_proba(sequence.astype("int64"))
+
+            # Température
+            preds = np.log(preds + 1e-7) / temperature
+            preds = np.exp(preds) / np.sum(np.exp(preds))
+
+            # Échantillonnage
+            next_id = rng.choice(len(preds), p=preds)
+
+            # Décodage ID -> mot
+            word = self.tokenizer.index_word.get(next_id, "")
+
+            if not word:
+                continue
+
+            generated_text += " " + word
+            token_list.append(next_id)
+
+        return generated_text

src/gradio/helpers/custom_layers.py

@@ -0,0 +1,200 @@
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+
+# Pour la sérialisation propre des couches custom
+try:
+    from keras.saving import register_keras_serializable
+except ImportError:
+    from tensorflow.keras.utils import register_keras_serializable
+
+
+def get_positional_encoding(seq_len, d_model):
+    """
+    Crée le positional encoding pour le Transformer (sinus/cosinus).
+    """
+    positions = np.arange(seq_len)[:, np.newaxis]
+    dimensions = np.arange(d_model)[np.newaxis, :]
+    angle_rates = 1 / np.power(10000, (2 * (dimensions // 2)) / np.float32(d_model))
+    angle_rads = positions * angle_rates
+
+    pos_encoding = np.zeros((seq_len, d_model))
+    pos_encoding[:, 0::2] = np.sin(angle_rads[:, 0::2])
+    pos_encoding[:, 1::2] = np.cos(angle_rads[:, 1::2])
+    return tf.cast(pos_encoding[np.newaxis, ...], dtype=tf.float32)
+
+
+@register_keras_serializable(package="trainme")
+class MultiHeadSelfAttention(layers.Layer):
+    """
+    Implémentation du Multi-Head Self-Attention (causal).
+    Même logique que dans le notebook d'entraînement.
+    """
+    def __init__(self, embed_dim, num_heads, **kwargs):
+        super(MultiHeadSelfAttention, self).__init__(**kwargs)
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+
+        assert embed_dim % num_heads == 0, "embed_dim doit être divisible par num_heads"
+
+        self.projection_dim = embed_dim // num_heads
+
+        # Projections linéaires pour Q, K, V
+        self.query_dense = layers.Dense(embed_dim, name="query")
+        self.key_dense = layers.Dense(embed_dim, name="key")
+        self.value_dense = layers.Dense(embed_dim, name="value")
+
+        # Projection finale
+        self.combine_heads = layers.Dense(embed_dim, name="output")
+
+    def attention(self, query, key, value):
+        """Calcule l'attention scaled dot-product avec masque de causalité."""
+        score = tf.matmul(query, key, transpose_b=True)
+        dim_key = tf.cast(tf.shape(key)[-1], tf.float32)
+        scaled_score = score / tf.math.sqrt(dim_key)
+
+        # Masque de causalité (look-ahead mask)
+        seq_len = tf.shape(scaled_score)[-1]
+        mask = 1 - tf.linalg.band_part(tf.ones((seq_len, seq_len)), -1, 0)
+        mask = mask * -1e9  # -inf sur les positions futures
+
+        scaled_score += mask
+
+        weights = tf.nn.softmax(scaled_score, axis=-1)
+        output = tf.matmul(weights, value)
+        return output, weights
+
+    def separate_heads(self, x, batch_size):
+        """Sépare la dernière dimension en (num_heads, projection_dim)."""
+        x = tf.reshape(x, (batch_size, -1, self.num_heads, self.projection_dim))
+        return tf.transpose(x, perm=[0, 2, 1, 3])
+
+    def call(self, inputs):
+        batch_size = tf.shape(inputs)[0]
+
+        # Projections linéaires
+        query = self.query_dense(inputs)
+        key = self.key_dense(inputs)
+        value = self.value_dense(inputs)
+
+        # Séparer en multiple heads
+        query = self.separate_heads(query, batch_size)
+        key = self.separate_heads(key, batch_size)
+        value = self.separate_heads(value, batch_size)
+
+        # Attention avec masque de causalité
+        attention, weights = self.attention(query, key, value)
+
+        # Recombiner les heads
+        attention = tf.transpose(attention, perm=[0, 2, 1, 3])
+        concat_attention = tf.reshape(attention, (batch_size, -1, self.embed_dim))
+
+        # Projection finale
+        output = self.combine_heads(concat_attention)
+        return output
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "embed_dim": self.embed_dim,
+                "num_heads": self.num_heads,
+            }
+        )
+        return config
+
+
+@register_keras_serializable(package="trainme")
+class TransformerBlock(layers.Layer):
+    """
+    Un bloc Transformer complet, identique au notebook :
+    - Multi-Head Self-Attention (custom)
+    - Feed-Forward Network
+    - Layer Normalization
+    - Residual Connections
+    """
+    def __init__(self, embed_dim, num_heads, ff_dim, dropout_rate=0.1, **kwargs):
+        super(TransformerBlock, self).__init__(**kwargs)
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.ff_dim = ff_dim
+        self.dropout_rate = dropout_rate
+
+        # Multi-Head Attention (ta classe custom)
+        self.att = MultiHeadSelfAttention(embed_dim, num_heads)
+
+        # Feed-Forward Network
+        self.ffn = keras.Sequential(
+            [
+                layers.Dense(ff_dim, activation="relu"),
+                layers.Dense(embed_dim),
+            ]
+        )
+
+        # Layer Normalization
+        self.layernorm1 = layers.LayerNormalization(epsilon=1e-6)
+        self.layernorm2 = layers.LayerNormalization(epsilon=1e-6)
+
+        # Dropout
+        self.dropout1 = layers.Dropout(dropout_rate)
+        self.dropout2 = layers.Dropout(dropout_rate)
+
+    def call(self, inputs, training=False):
+        # Multi-Head Attention avec residual connection
+        attn_output = self.att(inputs)
+        attn_output = self.dropout1(attn_output, training=training)
+        out1 = self.layernorm1(inputs + attn_output)
+
+        # Feed-Forward Network avec residual connection
+        ffn_output = self.ffn(out1)
+        ffn_output = self.dropout2(ffn_output, training=training)
+        out2 = self.layernorm2(out1 + ffn_output)
+
+        return out2
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "embed_dim": self.embed_dim,
+                "num_heads": self.num_heads,
+                "ff_dim": self.ff_dim,
+                "dropout_rate": self.dropout_rate,
+            }
+        )
+        return config
+
+
+@register_keras_serializable(package="trainme")
+class PositionalEmbedding(layers.Layer):
+    """
+    Combine l'embedding des tokens avec le positional encoding.
+    Identique au notebook, avec compat sérialisation.
+    """
+    def __init__(self, vocab_size, embed_dim, max_len, **kwargs):
+        super(PositionalEmbedding, self).__init__(**kwargs)
+        self.vocab_size = vocab_size
+        self.embed_dim = embed_dim
+        self.max_len = max_len
+
+        self.token_emb = layers.Embedding(input_dim=vocab_size, output_dim=embed_dim)
+        self.pos_encoding = get_positional_encoding(max_len, embed_dim)
+
+    def call(self, x):
+        seq_len = tf.shape(x)[1]
+        x = self.token_emb(x)
+        # Ajouter le positional encoding
+        x = x + self.pos_encoding[:, :seq_len, :]
+        return x
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "vocab_size": self.vocab_size,
+                "embed_dim": self.embed_dim,
+                "max_len": self.max_len,
+            }
+        )
+        return config

src/gradio/helpers/exercices_tab_utilis.py

@@ -0,0 +1,84 @@
+import json
+from pathlib import Path
+import os
+import pandas as pd
+from typing import Union
+
+
+
+# Le fichier s’exécute depuis son répertoire → on peut repartir du cwd
+current_dir = Path.cwd()
+json_path = current_dir / "src" / "gradio" / "data"
+
+# Chemin par défaut vers ton JSON fusionné
+DEFAULT_EXERCICES_PATH = Path(
+    os.getenv(
+        "DATASET_EXERCICES_FUSION",
+        json_path / "dataset_exercices_fusion_20251127_2004.json",
+    )
+)
+
+def _load_exercices(path: Union[str, Path]) -> pd.DataFrame:
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Dataset exercices introuvable : {path}")
+
+    df = pd.read_json(path)
+    df = df.reset_index(drop=True)
+    return df
+
+
+# DEFAULT_GOAL_PATH = Path(
+#     os.getenv(
+#         "GOAL_MAP_PATH",
+#         json_path / "goal_map.json",
+#     )
+# )
+
+# def _load_goals(path: Union[str, Path]) -> list[str]:
+#     """
+#     Charge la liste des goals depuis goal_map.json.
+#     On suppose un JSON de type: ["General Fitness", "Strength", ...]
+#     """
+#     path = Path(path)
+#     if not path.exists():
+#         raise FileNotFoundError(f"Goal map introuvable : {path}")
+
+#     with path.open("r", encoding="utf-8") as f:
+#         data = json.load(f)
+
+#     if isinstance(data, list):
+#         # On garde les chaînes, on nettoie le doublons, on trie
+#         goals = [str(x) for x in data if x not in (None, "")]
+#         return sorted(set(goals))
+
+#     # fallback simple si jamais c’est un dict: on prend les clés
+#     if isinstance(data, dict):
+#         return sorted(map(str, data.keys()))
+
+#     raise ValueError(f"Format inattendu pour goal_map.json : {type(data)}")
+
+
+# def _sync_level(level_val: str) -> str:
+#     # Recopie la valeur du champ 'level_out' du ML tab
+#     return level_val or ""
+
+# def _filter_by_level(df: pd.DataFrame, level: str) -> pd.DataFrame:
+#     """Filtre automatiquement selon difficulty en fonction du niveau ML."""
+#     if "difficulty" not in df.columns:
+#         return df  # sécurité
+
+#     level = (level or "").strip().lower()
+
+#     if level == "beginner":
+#         allowed = ["beginner"]
+#     elif level == "intermediate":
+#         allowed = ["intermediate"]
+#     elif level == "advanced":
+#         allowed = ["advanced"]
+#     elif level == "expert":
+#         allowed = ["expert"]
+#     else:  # vide
+#         return df
+
+#     return df[df["difficulty"].str.lower().isin(allowed)]

src/gradio/helpers/log_utils.py

@@ -0,0 +1,42 @@
+import csv
+import pandas as pd
+from pathlib import Path
+
+def log_prediction(
+    log_dir: Path,
+    row_in: dict,
+    y_hat: float,
+    latency_ms: int,
+    model_filename: str,
+    model_version: str,
+    target_name: str,
+):
+    """
+    Enregistre une prédiction dans un fichier CSV de logs.
+
+    Args:
+        log_dir: dossier où écrire le fichier "predictions.csv"
+        row_in: dictionnaire des features d'entrée
+        y_hat: prédiction numérique
+        latency_ms: durée d'inférence en millisecondes
+        model_filename: nom du fichier modèle (ex: "model.joblib")
+        model_version: version du modèle (issue du schéma)
+        target_name: nom de la variable cible
+    """
+    log_file = log_dir / "predictions.csv"
+    write_header = not log_file.exists()
+
+    new_row = {
+        "ts": pd.Timestamp.utcnow().isoformat(),
+        **row_in,
+        target_name: y_hat,
+        "latency_ms": latency_ms,
+        "model_file": model_filename,
+        "model_version": model_version,
+    }
+
+    with log_file.open("a", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=list(new_row.keys()))
+        if write_header:
+            writer.writeheader()
+        writer.writerow(new_row)

src/gradio/helpers/model_manager.py

@@ -0,0 +1,245 @@
+# from pathlib import Path
+# import pandas as pd
+# import json
+# import gpt_2_simple as gpt2
+# import tensorflow.compat.v1 as tf
+
+# tf.disable_v2_behavior()
+
+# from ..generators.gpt2_distillation_text_generator import GPT2_DistilledTextGenerator
+# from ..generators.gpt2_fine_tuning_text_generator import GPT2_FineTuningTextGenerator
+# from ..generators.transformer_text_generator import TransformerTextGenerator
+# from ..generators.lstm_text_generator import LSTMTextGenerator
+
+# # ---------------------------------------------------------------------
+# # Définition des chemins principaux
+# # ---------------------------------------------------------------------
+
+# PROJECT_ROOT = Path(__file__).resolve().parents[2]
+# MODEL_DIR = PROJECT_ROOT / "models" / "v1"
+
+# # ---------------------------------------------------------------------
+# # Registre des modèles DL
+# # ---------------------------------------------------------------------
+
+# MODEL_REGISTRY = {
+#     "xMas - GPT2 Fine-tuning": {
+#         "type": "gpt2",
+#         # "path": MODEL_DIR / "gpt2_trainme_distillation_gpt2_v5",
+#         "path": MODEL_DIR / "gpt2-xmas-finetuning_run3",
+#         "report_path": MODEL_DIR / "GPT2_Fine_Tuning_model_report_gpt_2_simple.json",
+#     },
+# }
+
+# # Cache interne pour éviter de recharger plusieurs fois
+# LOADED_MODELS = {}
+# LOADED_TOKENIZERS = {}
+
+
+# # ---------------------------------------------------------------------
+# # Fonction appelée par ton événement Gradio lors du changement de modèle
+# # ---------------------------------------------------------------------
+# def on_model_change(model_name: str) -> str:
+#     """
+#     Charge le modèle NLP correspondant au nom sélectionné.
+#     Retourne simplement le chemin du modèle chargé (affiché dans l'UI).
+#     """
+
+#     info = MODEL_REGISTRY[model_name]
+#     model_path = info["path"]
+#     if isinstance(model_path, str):
+#         model_path = Path(model_path)
+
+#     checkpoint_dir = str(model_path.parent)
+#     run_name = model_path.name
+
+#     # Déjà chargé ? On renvoie direct.
+#     if model_name in LOADED_MODELS:
+#         return f"Model loaded from cache: {model_path}"
+
+#     tf.reset_default_graph()
+#     sess = gpt2.start_tf_sess()
+#     gpt2.load_gpt2(
+#         sess,
+#         checkpoint_dir=checkpoint_dir,
+#         run_name=run_name,
+#     )
+
+#     # On pourrait stocker la session si besoin plus tard
+#     LOADED_MODELS[model_name] = {
+#         "sess": sess,
+#         "checkpoint_dir": checkpoint_dir,
+#         "run_name": run_name,
+#     }
+
+#     return f"Model loaded: {model_path}"
+
+
+# def clean_special_tokens(text: str) -> str:
+#     return (
+#         text.replace("<|startoftext|>", "")
+#         .replace("<|endoftext|>", "")
+#         .strip()
+#     )
+
+
+# def cut_to_last_sentence(text: str, min_chars: int = 60) -> str:
+#     """
+#     Coupe le texte au dernier '.', '!' ou '?' pour éviter
+#     les phrases tronquées. min_chars évite de couper trop tôt.
+#     """
+#     last_dot = text.rfind(".")
+#     last_exc = text.rfind("!")
+#     last_q = text.rfind("?")
+#     end_idx = max(last_dot, last_exc, last_q)
+
+#     if end_idx != -1 and end_idx >= min_chars:
+#         return text[: end_idx + 1].strip()
+#     return text.strip()
+
+
+# def generate_clean_program(
+#     sess,
+#     prompt: str,
+#     max_length: int = 200,
+#     temperature: float = 0.8,
+#     checkpoint_dir: str | None = None,
+#     run_name: str | None = None,
+# ) -> str:
+#     """
+#     Génère un texte brut avec gpt_2_simple en forçant checkpoint_dir / run_name,
+#     puis applique le nettoyage spécifique TrAIn.me.
+#     """
+#     gen_kwargs = dict(
+#         sess=sess,
+#         prefix=prompt,
+#         length=max_length,
+#         temperature=temperature,
+#         top_k=40,
+#         nsamples=1,
+#         batch_size=1,
+#         return_as_list=True,
+#         truncate="<|endoftext|>",  # s'arrête si le token apparaît
+#     )
+
+#     # IMPORTANT : on force les chemins si fournis
+#     if checkpoint_dir is not None:
+#         gen_kwargs["checkpoint_dir"] = checkpoint_dir
+#     if run_name is not None:
+#         gen_kwargs["run_name"] = run_name
+
+#     raw_list = gpt2.generate(**gen_kwargs)
+#     raw = raw_list[0] if isinstance(raw_list, list) else raw_list
+
+#     txt = clean_special_tokens(raw)
+#     txt = cut_to_last_sentence(txt)
+#     return txt
+
+
+# def generate_text_with_model(model_name: str, prompt: str) -> str:
+#     """Génère du texte avec le modèle sélectionné à partir du prompt."""
+#     prompt = prompt.strip()
+#     if not prompt:
+#         return "Please enter a prompt before generating."
+
+#     info = MODEL_REGISTRY[model_name]
+#     model_path = info["path"]  # Path vers le dossier qui contient encoder.json / model-xxx
+#     if isinstance(model_path, str):
+#         model_path = Path(model_path)
+
+#     checkpoint_dir = str(model_path.parent)   # ex: .../src/models/v1
+#     run_name = model_path.name                # ex: "gpt2-xmas-finetuning_run3"
+
+#     print(f"[GPT-2] Using checkpoint_dir={checkpoint_dir} run_name={run_name}")
+
+#     # Reset du graphe TF + session
+#     tf.reset_default_graph()
+#     sess = gpt2.start_tf_sess()
+
+#     # On indique explicitement où est le modèle
+#     gpt2.load_gpt2(
+#         sess,
+#         checkpoint_dir=checkpoint_dir,
+#         run_name=run_name,
+#     )
+
+#     text = generate_clean_program(
+#         sess,
+#         prompt=prompt,
+#         max_length=220,
+#         temperature=0.7,
+#         checkpoint_dir=checkpoint_dir,
+#         run_name=run_name,
+#     )
+#     return text
+
+
+# def get_dl_model_report_components(model_name: str):
+#     """
+#     Retourne 4 DataFrames Gradio-ready :
+#     - Summary
+#     - Model
+#     - Training
+#     - Metrics
+
+#     Si pas de rapport → retourne les DF vides.
+#     """
+#     info = MODEL_REGISTRY.get(model_name)
+#     if not info:
+#         return _empty_dl_dfs()
+
+#     report_path = info.get("report_path")
+#     if not report_path or not report_path.exists():
+#         return _empty_dl_dfs()
+
+#     try:
+#         data = json.loads(report_path.read_text(encoding="utf-8"))
+#     except Exception as e:
+#         print(f"[DL REPORT] Error while reading {report_path}: {e}")
+#         return _empty_dl_dfs()
+
+#     # ===== Summary =====
+#     dataset = data.get("dataset", {})
+
+#     summary_rows = [
+#         ("created_at",        data.get("created_at", "")),
+#         ("task",              data.get("task", "")),
+#         ("target",            data.get("target", "")),
+#         ("framework",         data.get("framework", "")),
+#         ("dataset.file",      dataset.get("file", "")),
+#         ("dataset.size_bytes", dataset.get("size_bytes", "")),
+#         ("dataset.tokens",    dataset.get("tokens", "")),
+#     ]
+
+#     df_summary = pd.DataFrame(summary_rows, columns=["Key", "Value"])
+
+#     # ===== Model config =====
+#     model_cfg = data.get("model", {}) or {}
+#     df_model = pd.DataFrame(
+#         [(k, v) for k, v in model_cfg.items()],
+#         columns=["Key", "Value"],
+#     )
+
+#     # ===== Training =====
+#     training_cfg = data.get("training", {}) or {}
+#     df_training = pd.DataFrame(
+#         [(k, v) for k, v in training_cfg.items()],
+#         columns=["Key", "Value"],
+#     )
+
+#     # ===== Metrics =====
+#     metrics_cfg = data.get("metrics", {}) or {}
+#     df_metrics = pd.DataFrame(
+#         [(k, v) for k, v in metrics_cfg.items()],
+#         columns=["Metric", "Value"],
+#     )
+
+#     return df_summary, df_model, df_training, df_metrics
+
+
+
+# def _empty_dl_dfs():
+#     """Retourne 4 DataFrames vides pour éviter les erreurs."""
+#     empty = pd.DataFrame({"Key": [], "Value": []})
+#     empty_metrics = pd.DataFrame({"Metric": [], "Value": []})
+#     return empty, empty, empty, empty_metrics

src/gradio/helpers/predict_utils.py

@@ -0,0 +1,130 @@
+import time
+import pandas as pd
+from pathlib import Path
+
+from .log_utils import log_prediction
+from .preprocess_utils import maybe_apply_feature_scaler, maybe_inverse_target
+from ..model_loader import pipeline_has_scaler
+from typing import Dict, List, Tuple
+import numpy as np
+
+
+def ui_to_internal_row(
+    ui_dict: Dict[str, object],
+    expected_cols: List[str],
+    encoder,
+) -> pd.DataFrame:
+
+    row = {}
+
+    # === A) GENDER_1.0 ==========================================
+    if "Gender_1.0" in expected_cols:
+        g_str = ui_dict["Gender"]
+        g_df = pd.DataFrame([[g_str]], columns=["Gender"])
+        g_encoded = float(encoder.transform(g_df)[0, 0])
+        row["Gender_1.0"] = 1.0 if g_encoded == 1.0 else 0.0
+
+    # === B) WORKOUT_TYPE_* (HIIT / Strength / Yoga / Cardio) ===
+    workout_types = ["Cardio", "Strength", "HIIT", "Yoga"]
+    selected_wt = ui_dict["Workout_Type"]
+
+    for wt in workout_types:
+        col = f"Workout_Type_{wt}"
+        if col in expected_cols:
+            row[col] = 1.0 if selected_wt == wt else 0.0
+
+    # # === C) BODY_PART_* (One-Hot) ===============================
+    # body_parts = ["Abs", "Arms", "Back", "Chest", "Forearms", "Legs", "Shoulders"]
+    # selected_bp = ui_dict["Body Part"]
+
+    # for bp in body_parts:
+    #     col = f"Body Part_{bp}"
+    #     if col in expected_cols:
+    #         row[col] = 1.0 if selected_bp == bp else 0.0
+
+
+    # === E) COPIE DIRECTE DES AUTRES COLONNES ===================
+    for col in expected_cols:
+        if col in row:
+            continue
+        if col in ui_dict:
+            row[col] = ui_dict[col]
+
+    return pd.DataFrame([row], columns=expected_cols)
+
+
+def predict_single(
+    payload: Dict[str, object],
+    internal_expected: List[str],
+    model,
+    feature_scaler,
+    target_scaler,
+    log_dir: Path,
+    model_path: Path,
+    schema: dict,
+    target_name: str,
+    encoder,
+) -> Tuple[float, str]:
+    """
+    Implémentation officielle :
+    UI → encodage Gender → scaling features → prédiction → inverse_transform cible.
+    """
+
+    # 0) Règle métier : si Workout_Type == "None" → prédiction forcée à 1 XP
+    workout_type_raw = payload.get("Workout_Type")
+    if isinstance(workout_type_raw, str) and workout_type_raw.strip().lower() == "none":
+        y_xp = 1.0
+        # Logging même si règle métier
+        log_prediction(
+            log_dir=log_dir,
+            row_in=payload,
+            y_hat=y_xp,
+            latency_ms=0,
+            model_filename=model_path.name,
+            model_version=schema.get("model_version", "unknown"),
+            target_name=target_name,
+        )
+
+        meta = (
+            f"Model: {model_path.name} | "
+            f"Version: {schema.get('model_version','?')} | "
+            f"Features: {', '.join(internal_expected)} | "
+            f"Rule applied: Workout_Type=None → y_xp=1"
+        )
+        return y_xp, meta
+
+    # 1) Construire le DF interne
+    X_raw = ui_to_internal_row(payload, internal_expected, encoder)
+
+    # 2) Scaling des features
+    X_scaled = pd.DataFrame(
+        feature_scaler.transform(X_raw),
+        columns=internal_expected,
+        index=X_raw.index,
+    )
+
+    # 3) Prédiction standardisée
+    y_std = float(model.predict(X_scaled)[0])
+
+    # 4) Remise en unités réelles
+    y_xp = float(target_scaler.inverse_transform(np.array([[y_std]]))[0, 0])
+    y_xp = round(y_xp, 2)
+
+    # 5) Logging
+    log_prediction(
+        log_dir=log_dir,
+        row_in=payload,
+        y_hat=y_xp,
+        latency_ms=0,
+        model_filename=model_path.name,
+        model_version=schema.get("model_version", "unknown"),
+        target_name=target_name,
+    )
+
+    meta = (
+        f"Model: {model_path.name} | "
+        f"Version: {schema.get('model_version','?')} | "
+        f"Features: {', '.join(internal_expected)}"
+    )
+    return y_xp, meta
+

src/gradio/helpers/preprocess_utils.py

@@ -0,0 +1,22 @@
+import numpy as np
+import pandas as pd
+
+def maybe_apply_feature_scaler(X: pd.DataFrame, scaler):
+    """Applique scaler.transform(X) si présent, sinon renvoie X."""
+    if scaler is None:
+        return X
+    Xs = scaler.transform(X)
+    return pd.DataFrame(Xs, columns=X.columns, index=X.index)
+
+def maybe_inverse_target(y_pred_float: float, y_scaler):
+    """
+    Si un y_scaler est fourni, applique inverse_transform.
+    Renvoie (y_pred_final: float, applied: bool).
+    """
+    if y_scaler is None:
+        return y_pred_float, False
+    try:
+        y_final = float(y_scaler.inverse_transform(np.array([[y_pred_float]])).ravel()[0])
+        return y_final, True
+    except Exception:
+        return y_pred_float, False

src/gradio/helpers/report_utils.py

@@ -0,0 +1,59 @@
+import json
+import pandas as pd
+from pathlib import Path
+
+
+def read_model_report(path: Path) -> dict:
+    """
+    Lit le fichier JSON du rapport de modèle.
+    Retourne un dictionnaire vide en cas d'erreur.
+    """
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def report_summary_df(rep: dict) -> pd.DataFrame:
+    """
+    Construit un tableau récapitulatif des informations principales du rapport.
+    """
+    if not rep:
+        return pd.DataFrame({
+            "Info": [
+                "created_at", "target", "n_features", "n_test_samples",
+                "selected_model.type", "selected_model.class"
+            ],
+            "Valeur": ["-", "-", "-", "-", "-", "-"]
+        })
+
+    sel = rep.get("selected_model", {})
+    rows = [
+        ("created_at", rep.get("created_at", "-")),
+        ("target", rep.get("target", "-")),
+        ("n_features", rep.get("n_features", "-")),
+        ("n_test_samples", rep.get("n_test_samples", "-")),
+        ("selected_model.type", sel.get("model_type", "-")),
+        ("selected_model.class", sel.get("model_class", "-")),
+    ]
+    return pd.DataFrame(rows, columns=["Informations", "Value"])
+
+
+def report_metrics_df(rep: dict) -> pd.DataFrame:
+    """
+    Construit un tableau des métriques de performance par modèle.
+    Colonnes : Modèle, MAE, RMSE, R2.
+    """
+    mets = rep.get("metrics_by_model", {})
+    if not mets:
+        return pd.DataFrame(columns=["Model", "MAE", "RMSE", "R2"])
+
+    df = pd.DataFrame(mets).T.reset_index().rename(columns={"index": "Model"})
+
+    # Conversion et arrondis
+    for c in ("MAE", "RMSE", "R2"):
+        if c in df.columns:
+            df[c] = pd.to_numeric(df[c], errors="coerce").round(3)
+
+    return df[["Model", "MAE", "RMSE", "R2"]]

src/gradio/helpers/schema_utils.py

@@ -0,0 +1,42 @@
+from typing import Tuple, Any
+from ..config import UI_DEFAULTS  # si tu as ajouté le dict ci-dessus
+
+def _coerce_num(x, is_int: bool):
+    try:
+        v = float(x)
+        return int(v) if is_int else float(v)
+    except Exception:
+        return None
+
+def get_bounds(spec: dict, schema: dict) -> Tuple[float, float, Any, float]:
+    """
+    Calcule (min, max, default, step) pour un champ.
+    Si l'exemple du schéma est manquant/hors bornes, on tombe sur le milieu [min,max].
+    On autorise un override via UI_DEFAULTS.
+    """
+    is_int = spec.get("type", "number") in ("integer", "int")
+
+    # bornes
+    vmin = int(spec.get("min", 0)) if is_int else float(spec.get("min", 0.0))
+    vmax = int(spec.get("max", 100)) if is_int else float(spec.get("max", 100.0))
+
+    # fallback = milieu propre
+    fallback = (vmin + vmax) // 2 if is_int else (vmin + vmax) / 2
+
+    # 1) tentative depuis UI_DEFAULTS
+    dflt = UI_DEFAULTS.get(spec["name"])
+    dflt = _coerce_num(dflt, is_int)
+
+    # 2) sinon, tentative depuis example_payload
+    if dflt is None:
+        ex = schema.get("example_payload", {}).get(spec["name"])
+        dflt = _coerce_num(ex, is_int)
+
+    # 3) clamp/validate
+    if dflt is None or not (vmin <= dflt <= vmax):
+        dflt = fallback
+
+    # step
+    step = 1 if is_int else (0.1 if (vmax - vmin) <= 20 else 0.5)
+
+    return vmin, vmax, dflt, step

src/gradio/helpers/sqlite_utils.py

@@ -0,0 +1,80 @@
+import sqlite3
+import pandas as pd
+from pathlib import Path
+from typing import List
+
+
+def list_tables(conn: sqlite3.Connection) -> List[str]:
+    """
+    Retourne la liste des tables non système présentes dans la base SQLite.
+    """
+    cur = conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+    )
+    return [r[0] for r in cur.fetchall()]
+
+
+def table_has_all_columns(conn: sqlite3.Connection, table: str, wanted: list[str]) -> bool:
+    """
+    Vérifie qu'une table contient toutes les colonnes demandées.
+    """
+    cur = conn.execute(f"PRAGMA table_info('{table}')")
+    cols = {row[1] for row in cur.fetchall()}  # row[1] = nom de la colonne
+    return set(wanted).issubset(cols)
+
+
+def load_val_subset(
+    db_path: Path,
+    wanted_cols: list[str],
+    target_name: str,
+    limit: int = 500,
+) -> pd.DataFrame:
+    """
+    Charge un sous-ensemble de données de validation depuis une base SQLite.
+    La cible (target_name) est toujours affichée en première colonne.
+    Si certaines colonnes manquent dans la table, elles sont ajoutées vides.
+
+    Args:
+        db_path: chemin vers la base SQLite.
+        wanted_cols: liste des colonnes de features attendues.
+        target_name: nom de la variable cible.
+        limit: nombre maximum de lignes à charger.
+
+    Returns:
+        DataFrame contenant les colonnes [target_name] + features.
+    """
+    display_cols = [target_name] + [c for c in wanted_cols if c != target_name]
+
+    if not db_path.exists():
+        return pd.DataFrame(columns=display_cols)
+
+    with sqlite3.connect(db_path) as conn:
+        # 1) Table contenant toutes les colonnes demandées
+        for tbl in list_tables(conn):
+            if table_has_all_columns(conn, tbl, display_cols):
+                cols_str = ", ".join([f'"{c}"' for c in display_cols])
+                query = f'SELECT {cols_str} FROM "{tbl}" LIMIT {limit}'
+                return pd.read_sql_query(query, conn)
+
+        # 2) Table partielle la plus proche (max d’intersection)
+        best_tbl, best_cols = None, []
+        for tbl in list_tables(conn):
+            cur = conn.execute(f"PRAGMA table_info('{tbl}')")
+            cols = {row[1] for row in cur.fetchall()}
+            inter = [c for c in display_cols if c in cols]
+            if len(inter) > len(best_cols):
+                best_tbl, best_cols = tbl, inter
+
+        if best_tbl:
+            cols_str = ", ".join([f'"{c}"' for c in best_cols])
+            query = f'SELECT {cols_str} FROM "{best_tbl}" LIMIT {limit}'
+            df = pd.read_sql_query(query, conn)
+
+            # Complète les colonnes manquantes (target/features) et garde l'ordre
+            for c in display_cols:
+                if c not in df.columns:
+                    df[c] = pd.NA
+            return df[display_cols]
+
+    # 3) Aucun tableau exploitable
+    return pd.DataFrame(columns=display_cols)

src/gradio/model_loader.py

@@ -0,0 +1,46 @@
+import json
+import joblib
+from pathlib import Path
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
+
+def load_model_and_schema(model_path: Path, schema_path: Path):
+    """
+    Charge le modèle .joblib et le schéma JSON associé.
+    Retourne (model, schema, target_name, features, expected_order).
+    """
+    # --- Chargement du modèle ---
+    model = joblib.load(model_path)
+
+    # --- Chargement du schéma ---
+    with open(schema_path, "r", encoding="utf-8") as f:
+        schema = json.load(f)
+
+    # --- Extraction des infos principales ---
+    target_name = schema.get("target", "Experience_level")
+    features = schema.get("features", [])
+
+    # --- Ordre des colonnes attendu par le modèle ---
+    if hasattr(model, "feature_names_in_"):
+        expected_order = list(model.feature_names_in_)
+    else:
+        expected_order = [f["name"] for f in features]
+
+    return model, schema, target_name, features, expected_order
+
+def load_optional_joblib(path: Path):
+    try:
+        if path and Path(path).exists():
+            return joblib.load(path)
+    except Exception:
+        pass
+    return None
+
+def pipeline_has_scaler(p) -> bool:
+    """
+    True si 'p' est un Pipeline sklearn qui contient un scaler connu.
+    """
+    if not isinstance(p, Pipeline):
+        return False
+    scaler_types = (StandardScaler, MinMaxScaler, RobustScaler)
+    return any(isinstance(step, scaler_types) for _, step in p.named_steps.items())

src/gradio/pages/dl_execution_tab.py

@@ -0,0 +1,190 @@
+from typing import Union
+from pathlib import Path
+
+import gradio as gr
+import pandas as pd
+
+from ..helpers.exercices_tab_utilis import (
+    DEFAULT_EXERCICES_PATH,
+    _load_exercices,
+)
+from ..generators.execution_generator import (
+    build_execution_prompt,
+    generate_execution_text,
+    get_dl_execution_model_report_components,
+)
+
+
+def render_dl_execution_tab(
+    app_desc_dl_exec: str,
+    dataset_path: Union[str, Path] = DEFAULT_EXERCICES_PATH,
+):
+    """
+    Onglet 'Deep Learning - Execution generator' :
+    sélection d'un programme SANS execution pour générer son texte d'exécution.
+    """
+
+    df = _load_exercices(dataset_path)
+
+    # ---- Filtrer uniquement les programmes sans execution ----
+    if "execution" in df.columns:
+        mask_no_exec = df["execution"].isna() | (df["execution"].astype(str).str.strip() == "")
+        df_no_exec = df[mask_no_exec].copy()
+    else:
+        df_no_exec = df.copy()
+
+    has_name_col = "exercise_name" in df_no_exec.columns
+    exercice_choices = (
+        sorted(df_no_exec["exercise_name"].dropna().unique().tolist())
+        if has_name_col
+        else []
+    )
+
+    # Colonnes affichées dans le tableau, y compris execution pour vérification
+    base_cols = ["exercise_name", "target_muscles", "equipment", "difficulty", "execution"]
+    selected_cols = [c for c in base_cols if c in df_no_exec.columns]
+
+    with gr.Tab("Deep Learning - Execution generator") as tab_dl_exec:
+        gr.Markdown(f"## {app_desc_dl_exec} - V3")
+
+        gr.Markdown("### Program details")
+
+        with gr.Row():
+            exercice_selector = gr.Dropdown(
+                label="Select a program without execution",
+                choices=exercice_choices,
+                value=exercice_choices[0] if exercice_choices else None,
+            )
+
+        details_md = gr.Markdown(
+            value=(
+                "Select a program **without execution description** "
+                "to see its details."
+            ),
+        )
+
+        # Tableau : programme sélectionné (avec colonne execution pour contrôle)
+        selected_program_exec_df = gr.Dataframe(
+            value=pd.DataFrame(columns=selected_cols),
+            interactive=False,
+            wrap=True,
+            label="Selected program",
+            row_count=(0, "dynamic"),
+            col_count=(0, "dynamic"),
+        )
+
+        # Prompt auto-généré
+        prompt_box = gr.Textbox(
+            label="Execution prompt (auto-generated)",
+            interactive=False,
+            lines=3,
+            max_lines=5,
+        )
+
+        # Bouton + sortie génération
+        generate_btn = gr.Button("Generate execution")
+
+        generated_exec = gr.Textbox(
+            label="Generated execution",
+            lines=10,
+            max_lines=20,
+        )
+
+        gr.Markdown("### Execution generator – Model report")
+
+        dl_summary = gr.Dataframe(
+            value=pd.DataFrame({"Key": [], "Value": []}),
+            interactive=False,
+            wrap=True,
+            label="Summary",
+        )
+
+        dl_model = gr.Dataframe(
+            value=pd.DataFrame({"Key": [], "Value": []}),
+            interactive=False,
+            wrap=True,
+            label="Model",
+        )
+
+        dl_training = gr.Dataframe(
+            value=pd.DataFrame({"Key": [], "Value": []}),
+            interactive=False,
+            wrap=True,
+            label="Training",
+        )
+
+        dl_metrics = gr.Dataframe(
+            value=pd.DataFrame({"Metric": [], "Value": []}),
+            interactive=False,
+            wrap=True,
+            label="Metrics",
+        )
+
+        # Callback de mise à jour details + tableau + prompt
+        def _format_details_exec(ex_name: str):
+            empty_df = pd.DataFrame(columns=selected_cols)
+            empty_prompt = ""
+
+            if not ex_name:
+                return (
+                    "Select a program **without execution description** "
+                    "to see its details.",
+                    empty_df,
+                    empty_prompt,
+                )
+
+            subset = df_no_exec[df_no_exec["exercise_name"] == ex_name]
+            if subset.empty:
+                return "No details found for this program.", empty_df, empty_prompt
+
+            row = subset.iloc[0]
+
+            def get(col, default="—"):
+                return row[col] if col in row and pd.notna(row[col]) else default
+
+            parts = [
+                f"**Name** : {get('exercise_name')}",
+                f"**Target muscles** : {get('target_muscles')}",
+                f"**Equipment** : {get('equipment')}",
+                f"**Difficulty** : {get('difficulty')}",
+                "",
+                "This program currently has **no execution description**.",
+                "You can generate a detailed execution using the Deep Learning model.",
+            ]
+            details_text = "\n".join(parts)
+
+            sel_row = {c: get(c, "") for c in selected_cols}
+            sel_df = pd.DataFrame([sel_row])
+
+            # Prompt pour ce programme
+            prompt = build_execution_prompt(row)
+
+            return details_text, sel_df, prompt
+
+        def _update_exec_report():
+            df_summary, df_model_df, df_training_df, df_metrics_df = get_dl_execution_model_report_components()
+            return df_summary, df_model_df, df_training_df, df_metrics_df
+
+
+
+        exercice_selector.change(
+            _format_details_exec,
+            inputs=exercice_selector,
+            outputs=[details_md, selected_program_exec_df, prompt_box],
+        )
+
+        # Génération à partir du prompt construit
+        generate_btn.click(
+            fn=generate_execution_text,
+            inputs=prompt_box,
+            outputs=generated_exec,
+        )
+
+        tab_dl_exec.select(
+            _update_exec_report,
+            inputs=None,  # ou [] mais None évite le warning
+            outputs=[dl_summary, dl_model, dl_training, dl_metrics],
+        )
+
+    # On retourne le DF sélectionné pour l’execution generator
+    return selected_program_exec_df

src/gradio/pages/dl_tab.py

@@ -0,0 +1,278 @@
+# import gradio as gr
+# import pandas as pd
+
+# # Import du helper
+# from ..helpers.model_manager import (
+#     on_model_change,
+#     generate_text_with_model,
+#     get_dl_model_report_components,
+# )
+
+
+# def render_dl_tab(
+#     app_desc_dl: str,
+#     level_out: gr.Textbox,
+#     wf_comp: gr.Component,
+#     wt_comp: gr.Component,
+#     selected_program_df: gr.State,
+#     goal_state: gr.State,
+# ) -> dict:
+#     """Onglet Deep Learning (sélection du modèle + prompt + sortie texte)."""
+
+#     with gr.Tab(f"Deep Learning - {app_desc_dl}") as tab_dl:
+
+#         # ===== Rappel du profil utilisateur (venant du tab ML) =====
+#         gr.Markdown("### Your profile (from Machine Learning tab)")
+
+#         with gr.Row():
+#             level_display = gr.Textbox(
+#                 label="Physical level",
+#                 interactive=False,
+#                 lines=1,
+#                 max_lines=1,
+#             )
+#             wf_display = gr.Textbox(
+#                 label="Workout frequency (days/week)",
+#                 interactive=False,
+#                 lines=1,
+#                 max_lines=1,
+#             )
+#             wt_display = gr.Textbox(
+#                 label="Workout type",
+#                 interactive=False,
+#                 lines=1,
+#                 max_lines=1,
+#             )
+
+#         gr.Markdown("### Selected program (from List of programs)")
+
+#         goal_display = gr.Textbox(
+#             label="Training goal",
+#             interactive=False,
+#             lines=1,
+#             max_lines=1,
+#         )
+
+#         program_display = gr.Dataframe(
+#             value=pd.DataFrame(),
+#             interactive=False,
+#             wrap=True,
+#             label="Selected program",
+#             row_count=(0, "dynamic"),
+#             col_count=(0, "dynamic"),
+#         )
+
+#         gr.Markdown(
+#             "These values are synchronized with your Machine Learning profile "
+#             "and are used to build the Deep Learning prompt automatically."
+#         )
+
+#         gr.Markdown(
+#             "## Generate your personalized exercise\n"
+#             "Prediction based on your information and the program selected from the list"
+#         )
+
+#         # Champ Prompt (auto-généré)
+#         prompt_box = gr.Textbox(
+#             label="Prompt sent to the Deep Learning model",
+#             interactive=True,
+#             lines=4,
+#         )
+
+#         # Sélecteur du modèle DL
+#         model_selector = gr.Dropdown(
+#             label="Deep Learning model",
+#             choices=[
+#                 "xMas - GPT2 Fine-tuning",
+#             ],
+#             value="xMas - GPT2 Fine-tuning",
+#         )
+
+#         # Zone d'info sur le modèle chargé
+#         model_status = gr.Markdown(
+#             "No model loaded yet. Select one from the list above.",
+#         )
+
+#         gr.Markdown("---")
+
+#         # Bouton "Générer" centré
+#         with gr.Row():
+#             gr.Column(scale=1)
+#             with gr.Column(scale=1):
+#                 generate_btn = gr.Button("Générer")
+#             gr.Column(scale=1)
+
+#         # Zone d’affichage du texte généré (programme)
+#         generated_text = gr.Textbox(
+#             label="Generated program",
+#             lines=20,
+#             max_lines=40,
+#         )
+
+#         # Wiring : clic sur "Générer"
+#         generate_btn.click(
+#             fn=generate_text_with_model,
+#             inputs=[model_selector, prompt_box],
+#             outputs=generated_text,
+#         )
+
+#         # Tableaux du rapport DL
+#         gr.Markdown("### Deep Learning model evaluation report")
+
+#         dl_sum = gr.Dataframe(
+#             value=pd.DataFrame({"Key": [], "Value": []}),
+#             interactive=False,
+#             wrap=True,
+#             label="Summary",
+#         )
+
+#         dl_model = gr.Dataframe(
+#             value=pd.DataFrame({"Key": [], "Value": []}),
+#             interactive=False,
+#             wrap=True,
+#             label="Model",
+#         )
+
+#         dl_training = gr.Dataframe(
+#             value=pd.DataFrame({"Key": [], "Value": []}),
+#             interactive=False,
+#             wrap=True,
+#             label="Training",
+#         )
+
+#         dl_metrics = gr.Dataframe(
+#             value=pd.DataFrame({"Metric": [], "Value": []}),
+#             interactive=False,
+#             wrap=True,
+#             label="Metrics",
+#         )
+
+#         # --- Helpers internes ---
+
+#         def _build_prompt(
+#             level_text: str,
+#             wf_text: str,
+#             wt_text: str,
+#             program_row,
+#             goal_text: str,
+#         ) -> str:
+#             """
+#             Construit le prompt à partir du profil + programme sélectionné.
+#             """
+#             level = level_text or "Unknown"
+#             wf = wf_text or "N/A"
+#             wt = wt_text or "Olympic Weightlifting"
+#             goal = goal_text or "Olympic Weightlifting"
+
+#             if not program_row:
+#                 return (
+#                     "Generate a workout program based on the user's physical level "
+#                     "and training goal. No specific exercise has been selected yet."
+#                 )
+
+#             ex_name = program_row.get("exercise_name") or "the selected exercise"
+#             target = program_row.get("target_muscles") or "the target muscles"
+#             equip = program_row.get("equipment") or "bodyweight only"
+
+#             prompt = (
+#                 f"Generate a workout program at [{level}] level. "
+#                 f"I am currently training for [{wt}] and my training frequency "
+#                 f"is [{wf}] days per week. "
+#                 f"My main goal is [{goal}]. "
+#                 f"The exercise to generate is titled [{ex_name}], "
+#                 f"it targets the [{target}] and uses the following equipment: "
+#                 f"[{equip}]."
+#             )
+#             return prompt
+
+#         # --- Callbacks ---
+
+#         def _on_dl_model_select(name: str):
+#             status = on_model_change(name)
+#             df_sum, df_model, df_training, df_metrics = get_dl_model_report_components(
+#                 name
+#             )
+#             return status, df_sum, df_model, df_training, df_metrics
+
+#         # Quand on change de modèle manuellement
+#         model_selector.change(
+#             fn=_on_dl_model_select,
+#             inputs=model_selector,
+#             outputs=[model_status, dl_sum, dl_model, dl_training, dl_metrics],
+#         )
+
+#         # Synchronisation du profil + programme + prompt + rapport à l'ouverture du tab DL
+#         def _sync_profile(level_val, wf_val, wt_val, program_row, goal_val, model_name):
+#             level_text = level_val or ""
+#             wf_text = "" if wf_val in (None, "") else str(wf_val)
+#             wt_text = wt_val or ""
+#             goal_text = goal_val or "Olympic Weightlifting"
+
+#             if not program_row:
+#                 program_df = pd.DataFrame()
+#             else:
+#                 program_df = pd.DataFrame([program_row])
+
+#             prompt = _build_prompt(level_text, wf_text, wt_text, program_row, goal_text)
+
+#             # Chargement du modèle + rapport dès ouverture du tab
+#             status = on_model_change(model_name)
+#             df_sum, df_model, df_training, df_metrics = get_dl_model_report_components(
+#                 model_name
+#             )
+
+#             return (
+#                 level_text,
+#                 wf_text,
+#                 wt_text,
+#                 goal_text,
+#                 program_df,
+#                 prompt,
+#                 status,
+#                 df_sum,
+#                 df_model,
+#                 df_training,
+#                 df_metrics,
+#             )
+
+#         tab_dl.select(
+#             _sync_profile,
+#             inputs=[
+#                 level_out,
+#                 wf_comp,
+#                 wt_comp,
+#                 selected_program_df,
+#                 goal_state,
+#                 model_selector,
+#             ],
+#             outputs=[
+#                 level_display,
+#                 wf_display,
+#                 wt_display,
+#                 goal_display,
+#                 program_display,
+#                 prompt_box,
+#                 model_status,
+#                 dl_sum,
+#                 dl_model,
+#                 dl_training,
+#                 dl_metrics,
+#             ],
+#         )
+
+#     # Retour des composants si besoin
+#     return {
+#         "model_selector": model_selector,
+#         "model_status": model_status,
+#         "prompt_box": prompt_box,
+#         "generated_text": generated_text,
+#         "level_display": level_display,
+#         "wf_display": wf_display,
+#         "wt_display": wt_display,
+#         "goal_display": goal_display,
+#         "program_display": program_display,
+#         "dl_sum": dl_sum,
+#         "dl_model": dl_model,
+#         "dl_training": dl_training,
+#         "dl_metrics": dl_metrics,
+#     }

src/gradio/pages/exercices_tab.py

@@ -0,0 +1,308 @@
+# from typing import Union
+# from pathlib import Path
+
+# import gradio as gr
+# import pandas as pd
+
+# from ..helpers.exercices_tab_utilis import (
+#     DEFAULT_EXERCICES_PATH,
+#     DEFAULT_GOAL_PATH,
+#     _filter_by_level,
+#     _load_exercices,
+#     _load_goals,
+# )
+
+
+# def render_list_of_exercices(
+#     app_desc_ex: str,
+#     level_out: gr.Textbox,  # textbox du ML tab
+#     dataset_path: Union[str, Path] = DEFAULT_EXERCICES_PATH,
+#     goal_path: Union[str, Path] = DEFAULT_GOAL_PATH,
+# ):
+#     """
+#     Onglet 'Exercices proposés' : tableau + panneau de détails.
+#     """
+
+#     df = _load_exercices(dataset_path)
+
+#     # --- Vue "compacte" pour le tableau ---
+#     df_view = df.copy()
+#     if "execution" in df_view.columns:
+#         df_view["Execution (preview)"] = (
+#             df_view["execution"].astype(str).str.slice(0, 80).fillna("") + "..."
+#         )
+
+#         base_cols = [
+#             "exercise_name",
+#             "target_muscles",
+#             "equipment",
+#             "difficulty",
+#         ]
+
+#         cols = [c for c in base_cols if c in df_view.columns]
+#         cols.append("Execution (preview)")
+#         df_view = df_view[cols]
+
+#         # Colonnes à transférer vers le tab DL
+#         selected_cols = [
+#             c
+#             for c in [
+#                 "exercise_name",
+#                 "target_muscles",
+#                 "equipment",
+#                 "difficulty",
+#                 "execution",
+#             ]
+#             if c in df.columns
+#         ]
+#     else:
+#         selected_cols = []
+
+#     # Liste pour le panneau de détails
+#     has_name_col = "exercise_name" in df.columns
+#     exercice_choices = (
+#         sorted(df["exercise_name"].dropna().unique().tolist())
+#         if has_name_col
+#         else []
+#     )
+
+#      # --- Chargement des goals ---
+#     try:
+#         goals = _load_goals(goal_path)
+#     except Exception:
+#         goals = []
+
+#     if not goals:
+#         goals = ["General Fitness"]
+
+#     default_goal = "General Fitness" if "General Fitness" in goals else goals[0]
+
+
+#     with gr.Tab("List of programs") as tab_ex:
+#         # Sélection du goal
+#         gr.Markdown("## Select your goal")
+
+#         goal_dropdown = gr.Dropdown(
+#             label="List of goals",
+#             choices=goals,
+#             value=default_goal,
+#             interactive=True,
+#         )
+#         goal_state = gr.State(value=None)
+
+#         gr.Markdown(f"## {app_desc_ex}")
+
+#         # Niveau ML
+#         with gr.Row():
+#             level_display = gr.Textbox(
+#                 label="Physical level",
+#                 interactive=False,
+#                 lines=1,
+#                 max_lines=1,
+#             )
+
+#         # Recherche
+#         search_box = gr.Textbox(
+#             label="Search in table",
+#             placeholder="Name, muscles, equipment, difficulty…",
+#         )
+
+#         # Dropdown muscles — rempli dynamiquement
+#         muscle_filter = gr.Dropdown(
+#             label="Filter by target muscles",
+#             choices=["All"],
+#             value="All",
+#         )
+
+#         # Dropdown equipment — rempli dynamiquement
+#         equipment_filter = gr.Dropdown(
+#             label="Filter by equipment",
+#             choices=["All"],
+#             value="All",
+#         )
+
+#         gr.Markdown(
+#             "The table below shows an overview of each exercise.\n\n"
+#             "- ML level filters difficulty\n"
+#             "- Use search, target muscles and equipment filters to refine\n"
+#             "- Select a program below to see full execution details\n"
+#         )
+
+#         # --- Tableau ---
+#         table = gr.Dataframe(
+#             value=df_view,
+#             interactive=False,
+#             wrap=True,
+#             row_count=(0, "dynamic"),
+#             col_count=(0, "dynamic"),
+#         )
+
+#         # --- Panneau de détails + sélection ---
+#         selected_program_state = gr.State(value=None)  # 👈 pour le tab DL
+
+#         if has_name_col:
+#             gr.Markdown("### Program details")
+
+#             with gr.Row():
+#                 exercice_selector = gr.Dropdown(
+#                     label="Select a program",
+#                     choices=exercice_choices,
+#                     value=exercice_choices[0] if exercice_choices else None,
+#                 )
+
+#             details_md = gr.Markdown(
+#                 value="Select a program to see full description.",
+#             )
+
+#             # Tableau 1 ligne : programme sélectionné (affiché ici)
+#             selected_program_df = gr.Dataframe(
+#                 value=pd.DataFrame(columns=selected_cols),
+#                 interactive=False,
+#                 wrap=True,
+#                 label="Selected program (for DL tab)",
+#                 row_count=(0, "dynamic"),
+#                 col_count=(0, "dynamic"),
+#             )
+
+#             def _format_details(ex_name: str):
+#                 # DF vide par défaut
+#                 empty_df = pd.DataFrame(columns=selected_cols)
+
+#                 if not ex_name:
+#                     return (
+#                         "Select a program to see full description.",
+#                         empty_df,
+#                         None,
+#                     )
+
+#                 subset = df[df["exercise_name"] == ex_name]
+#                 if subset.empty:
+#                     return "No details found for this program.", empty_df, None
+
+#                 row = subset.iloc[0]
+
+#                 def get(col, default="—"):
+#                     return row[col] if col in row and pd.notna(row[col]) else default
+
+#                 parts = [
+#                     f"**Name** : {get('exercise_name')}",
+#                     f"**Target muscles** : {get('target_muscles')}",
+#                     f"**Equipment** : {get('equipment')}",
+#                     f"**Difficulty** : {get('difficulty')}",
+#                     "",
+#                 ]
+
+#                 exec_text = get("execution", "")
+#                 if exec_text and exec_text != "—":
+#                     parts.append("**Execution** :")
+#                     parts.append("")
+#                     parts.append(exec_text)
+
+#                 details_text = "\n".join(parts)
+
+#                 # DF 1 ligne pour affichage
+#                 sel_row = {c: get(c, "") for c in selected_cols}
+#                 sel_df = pd.DataFrame([sel_row])
+
+#                 # Dict pour le tab DL
+#                 sel_dict = {c: get(c, "") for c in selected_cols}
+
+#                 return details_text, sel_df, sel_dict
+
+#             exercice_selector.change(
+#                 _format_details,
+#                 inputs=exercice_selector,
+#                 outputs=[details_md, selected_program_df, selected_program_state],
+#             )
+
+#         # ===== Callbacks =====
+
+#         # Synchronisation + filtrage niveau à l'ouverture de l'onglet
+#         def _sync_on_tab_open(level_val: str):
+#             level_text = level_val or ""
+#             filtered = _filter_by_level(df_view, level_text)
+
+#             # Muscles dynamiques selon niveau ML
+#             if "target_muscles" in filtered.columns:
+#                 muscles = sorted(set(filtered["target_muscles"].dropna()))
+#             else:
+#                 muscles = []
+
+#             # Equipment dynamique selon niveau ML
+#             if "equipment" in filtered.columns:
+#                 equipments = sorted(set(filtered["equipment"].dropna()))
+#             else:
+#                 equipments = []
+
+#             return (
+#                 level_text,
+#                 filtered,
+#                 gr.update(choices=["All"] + muscles, value="All"),
+#                 gr.update(choices=["All"] + equipments, value="All"),
+#             )
+
+#         tab_ex.select(
+#             _sync_on_tab_open,
+#             inputs=[level_out],
+#             outputs=[level_display, table, muscle_filter, equipment_filter],
+#         )
+
+#         # Recherche texte + filtres muscle & equipment
+#         def _search_table(
+#             query: str,
+#             level_val: str,
+#             muscle_choice: str,
+#             equipment_choice: str,
+#         ):
+#             # Filtre niveau ML
+#             base = _filter_by_level(df_view, level_val or "")
+
+#             # Filtre muscles
+#             if muscle_choice != "All" and "target_muscles" in base.columns:
+#                 base = base[base["target_muscles"] == muscle_choice]
+
+#             # Filtre equipment
+#             if equipment_choice != "All" and "equipment" in base.columns:
+#                 base = base[base["equipment"] == equipment_choice]
+
+#             # Recherche
+#             if query:
+#                 df_str = base.astype(str)
+#                 mask = df_str.apply(
+#                     lambda row: row.str.contains(query, case=False, na=False).any(),
+#                     axis=1,
+#                 )
+#                 base = base[mask]
+
+#             return base
+
+#         def _on_goal_change(goal_val):
+#             return goal_val
+
+#         goal_dropdown.change(
+#             _on_goal_change,
+#             inputs=goal_dropdown,
+#             outputs=goal_state,
+#         )
+
+#         search_box.change(
+#             _search_table,
+#             inputs=[search_box, level_out, muscle_filter, equipment_filter],
+#             outputs=table,
+#         )
+
+#         muscle_filter.change(
+#             _search_table,
+#             inputs=[search_box, level_out, muscle_filter, equipment_filter],
+#             outputs=table,
+#         )
+
+#         equipment_filter.change(
+#             _search_table,
+#             inputs=[search_box, level_out, muscle_filter, equipment_filter],
+#             outputs=table,
+#         )
+
+#         # On retourne l'état (dict) du programme sélectionné
+#         return selected_program_state, goal_state
+

src/gradio/pages/ml_tab.py

@@ -0,0 +1,261 @@
+from pathlib import Path
+import gradio as gr
+import pandas as pd
+
+from ..helpers.schema_utils import get_bounds
+from ..helpers.sqlite_utils import load_val_subset
+from ..helpers.predict_utils import predict_single
+from ..helpers.report_utils import (
+    read_model_report, report_summary_df, report_metrics_df
+)
+from typing import Dict, List
+
+
+def render_ml_tab(
+    app_desc_ml: str,
+    feature_specs: List[dict],
+    ui_feature_names: List[str],
+    internal_expected: List[str],
+    target_name: str,
+    schema: dict,
+    ui_examples: List[Dict],
+    db_path: Path,
+    model,
+    logs_dir: Path,
+    model_path: Path,
+    feature_scaler,
+    target_scaler,
+    encoder,
+    report_path: Path,
+    on_load=None,
+) -> None:
+    display_headers = [target_name] + [c for c in ui_feature_names if c != target_name]
+
+    with gr.Tab(f"Machine Learning - {app_desc_ml} ({schema.get('model_name','model')})"):
+        # ====== Ligne principale (inputs/pred) ======
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### Assess your physical level")
+                comps, names = [], []
+
+                wf_comp = None  # Workout_Frequency (days/week)
+                wt_comp = None  # Workout_Type
+
+                for spec in feature_specs:
+                    name = spec["name"]
+                    if name == "Experience_Level":
+                        comp = gr.Slider(0, 3, value=0, step=0, label=name, visible=False)
+
+                        comps.append(comp)
+                        names.append(name)
+                        continue
+
+                    if name == "Gender":
+                        # UI = Radio pour Male / Female
+                        choices = spec.get("enum", ["Male", "Female"])
+                        comp = gr.Radio(
+                            choices=choices,
+                            value=choices[0],
+                            label="Gender",
+                        )
+
+                    elif name == "Workout_Type":
+                        # UI = Liste déroulante pour le type de séance
+                        choices = spec.get("enum", ["Cardio", "Strength", "HIIT", "Yoga"])
+                        comp = gr.Dropdown(
+                            choices=choices,
+                            value=choices[0],
+                            label="Workout_Type",
+                        )
+                        wt_comp = comp  # on garde une référence
+
+                    else:
+                        vmin, vmax, default, step = get_bounds(spec, schema)
+                        comp = gr.Slider(
+                            vmin,
+                            vmax,
+                            value=default,
+                            step=step,
+                            label=name,
+                        )
+
+                        if name == "Workout_Frequency (days/week)":
+                            wf_comp = comp  # on garde une référence
+
+                    comps.append(comp)
+                    names.append(name)
+
+                btn = gr.Button("Predict", variant="primary")
+
+            with gr.Column():
+                gr.Markdown("### Calculs")
+
+                bmi_out = gr.Number(
+                    label="BMI (Body Mass Index)",
+                    interactive=False,
+                    precision=2,
+                )
+                fat_out = gr.Number(
+                    label="Body fat percentage (%)",
+                    interactive=False,
+                    precision=2,
+                )
+
+                gr.Markdown("---")
+
+                gr.Markdown("### Prédiction")
+
+                y_out = gr.Number(
+                    label="Physical experience level notation",
+                    interactive=False,
+                    precision=2,
+                )
+
+                # Nouveau champ texte interprétation du niveau
+                level_out = gr.Textbox(
+                    label="Physical level (text)",
+                    interactive=False,
+                    lines=1,
+                    max_lines=1,
+                )
+
+                meta_out = gr.Textbox(
+                    label="Informations",
+                    interactive=False,
+                    lines=4,
+                    max_lines=8,
+                )
+
+        # ====== Exemples ======
+        examples_dicts = ui_examples or [schema.get("example_payload", {})]
+
+        # --- Tableau complet (pour l'affichage) ---
+        df_examples_full = pd.DataFrame(examples_dicts)
+
+        # On impose Experience_Level en première colonne si elle existe
+        if "Experience_Level" in df_examples_full.columns:
+            ordered_cols = (
+                ["Experience_Level"] +
+                [c for c in df_examples_full.columns if c != "Experience_Level"]
+            )
+            df_examples_full = df_examples_full[ordered_cols]
+
+        # --- Exemples envoyés au modèle (uniquement les features d’entrée) ---
+        df_examples_for_gradio = df_examples_full[names]  # on garde seulement les features utiles
+        rows = df_examples_for_gradio.values.tolist()
+
+        gr.Examples(
+            examples=rows,
+            inputs=comps,
+            label="Exemples (sélection rapide)"
+        )
+
+        gr.Markdown("---")
+
+        # ====== Prédiction ======
+
+        def _interpret_level(y_val) -> str:
+            """Map numeric prediction to textual level."""
+            try:
+                if y_val is None:
+                    return ""
+                v = float(y_val)
+            except Exception:
+                return ""
+
+            if 0 <= v < 1:
+                return "Beginner"
+            elif 1 <= v < 2:
+                return "Intermediate"
+            elif 2 <= v < 2.5:
+                return "Advanced"
+            elif 2.5 <= v <= 3:
+                return "Expert"
+            return ""
+
+        def _fn(*vals):
+            payload = {k: v for k, v in zip(names, vals)}
+
+            # Gradio peut renvoyer les valeurs numériques en str → on force
+            if "Age" in payload:
+                payload["Age"] = float(payload["Age"])
+            if "Weight (kg)" in payload:
+                payload["Weight (kg)"] = float(payload["Weight (kg)"])
+            if "Height (m)" in payload:
+                payload["Height (m)"] = float(payload["Height (m)"])
+            if "Workout_Frequency (days/week)" in payload:
+                payload["Workout_Frequency (days/week)"] = float(
+                    payload["Workout_Frequency (days/week)"]
+                )
+
+            # 1) prédiction XP via le pipeline existant
+            y_xp, meta = predict_single(
+                payload=payload,
+                internal_expected=internal_expected,
+                model=model,
+                feature_scaler=feature_scaler,
+                target_scaler=target_scaler,
+                log_dir=logs_dir,
+                model_path=model_path,
+                schema=schema,
+                target_name=target_name,
+                encoder=encoder,
+            )
+
+            # 2) Calcul BMI & Body Fat %
+            bmi = None
+            fat_pct = None
+            try:
+                w = float(payload.get("Weight (kg)", 0) or 0)
+                h = float(payload.get("Height (m)", 0) or 0)
+                if h > 0:
+                    bmi = round(w / (h ** 2), 2)
+
+                age_val = payload.get("Age")
+                gender_raw = str(payload.get("Gender", "")).lower()
+
+                if bmi is not None and age_val not in (None, ""):
+                    age_f = float(age_val)
+                    # 1 = homme, 0 = femme (IMG formule classique)
+                    sex_flag = 1.0 if gender_raw.startswith("m") else 0.0
+
+                    fat_pct = 1.20 * bmi + 0.23 * age_f - 10.8 * sex_flag - 5.4
+                    fat_pct = round(fat_pct, 2)
+            except Exception:
+                bmi = None
+                fat_pct = None
+
+            # 3) Interprétation textuelle du niveau
+            level_text = _interpret_level(y_xp)
+
+            # 4) Retourner les 5 sorties Gradio
+            return y_xp, level_text, bmi, fat_pct, meta
+
+        btn.click(_fn, comps, [y_out, level_out, bmi_out, fat_out, meta_out])
+
+        gr.Markdown("---")
+
+        # ====== Rapport modèle ======
+        rep = read_model_report(report_path)
+        df_sum = report_summary_df(rep)
+        df_mets = report_metrics_df(rep)
+
+        gr.Markdown("### Machine Learning model evaluation report")
+        gr.Dataframe(
+            value=df_sum,
+            interactive=False,
+            wrap=True,
+            label="Summary",
+            row_count=(0, "dynamic"),
+            col_count=df_sum.shape[1],
+        )
+        gr.Dataframe(
+            value=df_mets,
+            interactive=False,
+            wrap=True,
+            label="Metrics by model",
+            row_count=(0, "dynamic"),
+            col_count=df_mets.shape[1],
+        )
+        # On renvoie le composant pour que les autres onglets puissent l'utiliser
+        return level_out, wf_comp, wt_comp