adding the hugging face deployment pipeline

.gitattributes

@@ -0,0 +1 @@
+*.keras filter=lfs diff=lfs merge=lfs -text

.github/workflows/deployement.yml

@@ -0,0 +1,26 @@
+name: CI
+
+# Controls when the workflow will run
+on:
+  push:
+    branches: [main]
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - name: Add remote
+        env:
+          HF: ${{ secrets.HG }}
+        run: git remote add space https://huggingface.co/spaces/Ghaithhmz/aging_score_autoencoder_agent
+      - name: Push to hub
+        env:
+          HF: ${{ secrets.HG }}
+        run: |  
+          git push --force https://Ghaithhmz:${HF}@huggingface.co/spaces/Ghaithhmz/aging_score_autoencoder_agent main

.gitignore

@@ -0,0 +1,2 @@
+venv/
+

Makefile

@@ -0,0 +1,31 @@
+# Variables
+VENV = venv
+ifeq ($(OS),Windows_NT)
+    BIN = $(VENV)/Scripts
+else
+    BIN = $(VENV)/bin
+endif
+
+PYTHON = $(BIN)/python
+PIP = $(BIN)/pip
+
+.PHONY: install run clean help venv
+
+help:
+	@echo "Available commands:"
+	@echo "  install : Create virtual environment and install dependencies"
+	@echo "  run     : Run the Gradio application via virtual environment"
+	@echo "  clean   : Remove temporary files and virtual environment"
+
+$(VENV):
+	python -m venv $(VENV)
+
+install: $(VENV)
+	$(PIP) install -r requirements.txt
+
+run:
+	$(PYTHON) app.py
+
+clean:
+	rm -rf __pycache__ .pytest_cache
+	rm -rf $(VENV)

app.py

@@ -0,0 +1,110 @@
+import gradio as gr
+import tensorflow as tf
+import numpy as np
+import pandas as pd
+import os
+import matplotlib.pyplot as plt
+
+# Load the model
+MODEL_PATH = "models/aging_score_autoencoder.keras"
+
+# Global variables
+model = None
+encoder_model = None
+
+def load_resources():
+    global model, encoder_model
+    if os.path.exists(MODEL_PATH):
+        try:
+            # Load the full multi-output model
+            model = tf.keras.models.load_model(MODEL_PATH)
+            # Create a sub-model to extract the latent space (Aging Score)
+            # We assume the layer is named 'latent' as per the notebook
+            try:
+                latent_layer = model.get_layer("latent")
+                encoder_model = tf.keras.Model(inputs=model.input, outputs=latent_layer.output)
+                print("Model and Encoder extracted successfully.")
+            except:
+                print("Warning: 'latent' layer not found. Only age prediction will be available.")
+        except Exception as e:
+            print(f"Error loading model: {e}")
+
+# Initial load
+load_resources()
+
+def predict_aging(input_file, chron_age):
+    if model is None:
+        return "Error: Model not found.", None, None
+    
+    try:
+        # Load data
+        if input_file.name.endswith('.csv'):
+            df = pd.read_csv(input_file.name)
+        else:
+            df = pd.read_parquet(input_file.name)
+
+        # Feature selection (Genes only)
+        META_COLS = ["sample_id", "subject_id", "tissue", "sex", "age", "death_time", "estimated_age"]
+        gene_cols = [c for c in df.columns if c not in META_COLS]
+        X = df[gene_cols].values
+        
+        # Preprocessing: log1p + standard normalization
+        X_scaled = np.log1p(X)
+        X_scaled = (X_scaled - np.mean(X_scaled)) / (np.std(X_scaled) + 1e-8)
+        
+        # Inference
+        # model.predict returns [reconstruction, age_prediction]
+        _, age_pred = model.predict(X_scaled)
+        biological_age = float(age_pred[0][0])
+        
+        # Latent Aging Score
+        aging_score = "N/A"
+        if encoder_model:
+            latent_vector = encoder_model.predict(X_scaled)
+            # Using the mean of the latent vector as a proxy for the 'Aging Score' intensity
+            aging_score = float(np.mean(latent_vector[0]))
+
+        # Interpretation
+        rhythm = biological_age - chron_age
+        status = "Vieillissement Accéléré ⚠️" if rhythm > 2 else "Vieillissement Ralenti ✅" if rhythm < -2 else "Vieillissement Normal 🆗"
+        
+        # Summary
+        res_text = f"""
+        ### Résultats d'Analyse
+        - **Âge Chronologique :** {chron_age} ans
+        - **Âge Biologique (Estimé) :** {biological_age:.2f} ans
+        - **Score de Vieillissement (Latent) :** {aging_score:.4f}
+        - **Statut :** {status}
+        """
+        
+        # Plot
+        fig, ax = plt.subplots(figsize=(6, 2))
+        colors = ['#2ecc71', '#f1c40f', '#e74c3c']
+        ax.barh(['Rythme'], [rhythm], color='#3498db')
+        ax.axvline(0, color='black', linestyle='--')
+        ax.set_title("Différentiel de Vieillissement (Bio - Chrono)")
+        ax.set_xlim(-15, 15)
+        
+        return res_text, fig
+        
+    except Exception as e:
+        return f"Erreur : {str(e)}", None
+
+# Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🧠 Aging Score Bio-Predictor")
+    gr.Markdown("Analyse du rythme de vieillissement biologique via Autoencoder supervisé.")
+    
+    with gr.Row():
+        with gr.Column():
+            input_file = gr.File(label="Données Transcriptomiques (18k gènes)")
+            chron_age = gr.Number(label="Âge Chronologique Réel", value=40)
+            btn = gr.Button("Calculer l'Aging Score", variant="primary")
+            
+        with gr.Column():
+            output_text = gr.Markdown()
+            output_plot = gr.Plot()
+
+    btn.click(fn=predict_aging, inputs=[input_file, chron_age], outputs=[output_text, output_plot])
+
+demo.launch()

models/aging_score_autoencoder.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f07d03ec82d2cf747469caf948784e874143230edca4e201009872134f0e68e0
+size 226125378

readme.md

@@ -0,0 +1,32 @@
+---
+title: Aging Score Prediction
+emoji: 🧠
+colorFrom: blue
+colorTo: green
+sdk: gradio
+app_file: app.py
+pinned: false
+---
+
+# Aging Score Biologique via Autoencoder Supervisé
+
+## 🎯 Formulation Officielle
+L’objectif de ce projet est de développer un modèle de deep learning basé sur un autoencoder supervisé afin d’apprendre une représentation latente de l’expression génique humaine et de définir un score de vieillissement biologique (**“Aging Score”**), permettant de caractériser le rythme de vieillissement d’un individu à partir de données transcriptomiques multi-tissus.
+
+## 🧬 Concept Central
+Au lieu de prédire directement la durée de vie d’une personne, on apprend un score de vieillissement biologique à partir de l’expression des gènes. L'expression génique est l'empreinte moléculaire de l'état biologique d'un individu.
+
+## 🏗️ Architecture du Modèle
+- **Encoder** : Compresse les 18 000 gènes vers un espace latent.
+- **Latent Space** : Représentation réduite de l'information biologique (32 dimensions).
+- **Decoder** : Assure que l'espace latent contient assez d'informations pour reconstruire les gènes originaux.
+- **Tête de Régression** : Aligne l'espace latent avec l'âge chronologique.
+
+## 📊 Interprétation
+- **Âge Biologique < Âge Chronologique** : Vieillissement ralenti (profil protecteur).
+- **Âge Biologique > Âge Chronologique** : Vieillissement accéléré (potentiels facteurs de risques).
+
+## 🛠️ Installation locale
+```bash
+make install
+make run

requirements.txt

@@ -0,0 +1,9 @@
+gradio
+tensorflow
+pandas
+numpy
+scikit-learn
+joblib
+matplotlib
+huggingface_hub
+pyarrow