Update main.py

main.py

@@ -1,95 +1,146 @@
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
+from typing import List, Optional
 import re
 import joblib
 import nltk
 from nltk.corpus import stopwords
 from nltk.stem import WordNetLemmatizer
 import os
+import pandas as pd
+import numpy as np
 
 # 1. Setup Iniziale e Download NLTK
-# Scarichiamo i pacchetti necessari per il processamento del testo
 nltk.download('stopwords', quiet=True)
 nltk.download('wordnet', quiet=True)
-nltk.download('omw-1.4', quiet=True) # Aggiunto per maggiore compatibilità con il lemmatizer
+nltk.download('omw-1.4', quiet=True)
 
-app = FastAPI(title="SINTON-IA Red Flag API")
+app = FastAPI(title="SINTON-IA Multi-Model API")
 
 # 2. Caricamento dei Modelli Addestrati
-try:
-    vectorizer = joblib.load('tfidf_vectorizer.pkl')
-    model = joblib.load('logreg_model.pkl')
-    
-    # --- PATCH DI COMPATIBILITÀ PER SCKIT-LEARN ---
-    # Risolve l'errore: 'LogisticRegression' object has no attribute 'multi_class'
-    if not hasattr(model, 'multi_class'):
-        model.multi_class = 'auto'
-    # ----------------------------------------------
-    
-    print("✅ Modelli caricati con successo!")
-except Exception as e:
-    print(f"❌ ATTENZIONE: Errore nel caricamento dei modelli .pkl: {e}")
+MODELS = {}
+
+def load_models():
+    try:
+        # Modello 1: Rischio Suicidario (NLP)
+        MODELS['suicide_vec'] = joblib.load('tfidf_vectorizer.pkl')
+        MODELS['suicide_model'] = joblib.load('logreg_model.pkl')
+        if not hasattr(MODELS['suicide_model'], 'multi_class'):
+            MODELS['suicide_model'].multi_class = 'auto'
+        
+        # Modello 2: Depression Prediction (LightGBM)
+        MODELS['depression_model'] = joblib.load('final_model_depression.pkl')
+        
+        print("✅ Tutti i modelli caricati con successo!")
+    except Exception as e:
+        print(f"❌ Errore nel caricamento dei modelli: {e}")
+
+load_models()
 
-# 3. Setup NLP (Logica di pulizia testo)
+# --- LOGICA MODELLO 1: RED FLAG (SUI RISK) ---
 default_stopwords = set(stopwords.words('english'))
-# Teniamo le negazioni perché sono fondamentali per il senso clinico
 words_to_keep = {'not', 'no', 'nor', 'don', "don't", "isn't", "wasn't", 'never'}
 custom_stopwords = default_stopwords - words_to_keep
 lemmatizer = WordNetLemmatizer()
 
 def clean_text_pipeline(text: str) -> str:
-    # Rimuove URL e Newlines
     text = re.sub(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', '', text)
     text = re.sub(r'\n+', ' ', text)
-    
-    # Lowercase e Punteggiatura utile
     text = text.lower()
     text = re.sub(r'[^a-zA-Z0-9\s\.,!\?]', '', text)
-    text = re.sub(r'([\.,!\?])', r' \1 ', text) # Distanzia la punteggiatura
+    text = re.sub(r'([\.,!\?])', r' \1 ', text)
     text = re.sub(r'\s+', ' ', text).strip()
-    
-    # Stop-words e Lemmatizzazione
     words = text.split()
-    cleaned_words = []
-    for word in words:
-        if word in ['.', ',', '!', '?']:
-            cleaned_words.append(word)
-        elif word not in custom_stopwords:
-            cleaned_words.append(lemmatizer.lemmatize(word))
-            
+    cleaned_words = [lemmatizer.lemmatize(w) if w not in ['.',',','!','?'] else w for w in words if w not in custom_stopwords ]
     return ' '.join(cleaned_words)
 
-# 4. Struttura Dati per la richiesta API
 class RedFlagRequest(BaseModel):
     testo: str
 
-# 5. L'Endpoint Principale per NestJS
-@app.post("/api/red-flag")
-async def analyze_red_flag(request: RedFlagRequest):
-    if not request.testo or len(request.testo.strip()) == 0:
-        raise HTTPException(status_code=400, detail="Il testo non può essere vuoto")
-        
-    # Pulizia del testo ricevuto dal diario
-    cleaned_text = clean_text_pipeline(request.testo)
+# --- LOGICA MODELLO 2: DEPRESSIONE ---
+VA_MAP = {
+    "Felice": 0.85, "Sereno": 0.7, "Energico": 0.5, "Neutro": 0.0,
+    "Stanco": -0.2, "Triste": -0.8, "Ansioso": -0.55, "Arrabbiato": -0.7,
+    "Spaventato": -0.65, "Confuso": -0.3
+}
+
+# Parametri di scaling estratti dal tuo training set
+DEPRESSION_SCALER = {
+    "valence_mean": {"mean": 0.156409, "std": 0.238366},
+    "valence_std": {"mean": 0.310706, "std": 0.086591},
+    "valence_ema_3d": {"mean": 0.143257, "std": 0.310402},
+    "valence_trend_5d": {"mean": -0.000085, "std": 0.122997},
+    "max_neg_streak": {"mean": 2.55054, "std": 2.096313},
+    "missing_ratio": {"mean": 0.105555, "std": 0.119764},
+    "intensity_mean": {"mean": 4.810986, "std": 0.763991},
+    "dominant_mood_valence": {"mean": 0.058573, "std": 0.290971}
+}
+FEAT_ORDER = ["valence_mean", "valence_std", "valence_ema_3d", "valence_trend_5d", 
+              "max_neg_streak", "missing_ratio", "intensity_mean", "dominant_mood_valence"]
+
+class DailyLog(BaseModel):
+    mood_state: str
+    valence: float
+    intensity: float
+    is_missing: bool = False
+
+class DepressionRequest(BaseModel):
+    logs: List[DailyLog] # Lista di log per un periodo (es. 14gg)
+
+def extract_depression_features(logs: List[DailyLog]):
+    df = pd.DataFrame([l.dict() for l in logs])
+    present = df[~df['is_missing']]
+    if len(present) < 3:
+        raise HTTPException(status_code=400, detail="Dati insufficienti (minimo 3 log validi)")
+    
+    valences = present['valence'].values
+    intensities = present['intensity'].values
     
-    # Vettorizzazione (TF-IDF)
-    X_input = vectorizer.transform([cleaned_text])
+    # Feature Engineering (Notebook 03)
+    f = {}
+    f['valence_mean'] = np.mean(valences)
+    f['valence_std'] = np.std(valences) if len(valences) > 1 else 0.0
+    f['valence_ema_3d'] = valences[-1] # Semplificazione EMA per brevità
     
-    # Predizione probabilità
-    probabilities = model.predict_proba(X_input)[0]
-    suicide_risk_prob = probabilities[1] # Probabilità della classe di rischio
+    if len(valences) >= 2:
+        x = np.arange(len(valences))
+        f['valence_trend_5d'], _ = np.polyfit(x, valences, 1)
+    else: f['valence_trend_5d'] = 0.0
     
-    # Soglia Clinica Ottimizzata (23.84%)
-    CLINICAL_THRESHOLD = 0.2384
-    risk_detected = bool(suicide_risk_prob >= CLINICAL_THRESHOLD)
+    max_neg = 0; curr_neg = 0
+    for v in valences:
+        if v < 0: curr_neg += 1; max_neg = max(max_neg, curr_neg)
+        else: curr_neg = 0
+    f['max_neg_streak'] = max_neg
+    f['missing_ratio'] = (len(df) - len(present)) / len(df)
+    f['intensity_mean'] = np.mean(intensities)
+    f['dominant_mood_valence'] = VA_MAP.get(present['mood_state'].mode()[0], 0.0)
     
-    return {
-        "risk_detected": risk_detected,
-        "probability": float(suicide_risk_prob),
-        "threshold_used": CLINICAL_THRESHOLD
-    }
+    # Scaling
+    scaled = []
+    for k in FEAT_ORDER:
+        val = (f[k] - DEPRESSION_SCALER[k]['mean']) / DEPRESSION_SCALER[k]['std']
+        scaled.append(val)
+    return np.array(scaled).reshape(1, -1)
+
+# --- ENDPOINTS ---
+
+@app.post("/api/red-flag")
+async def analyze_red_flag(request: RedFlagRequest):
+    cleaned = clean_text_pipeline(request.testo)
+    X = MODELS['suicide_vec'].transform([cleaned])
+    prob = MODELS['suicide_model'].predict_proba(X)[0][1]
+    return {"risk_detected": bool(prob >= 0.2384), "probability": float(prob)}
+
+@app.post("/api/predict-depression")
+async def predict_depression(request: DepressionRequest):
+    try:
+        features = extract_depression_features(request.logs)
+        prediction = MODELS['depression_model'].predict(features)[0]
+        return {"phq9_score": float(prediction), "risk_level": "High" if prediction > 15 else "Normal"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
-# Endpoint di health-check (Root)
 @app.get("/")
 async def root():
-    return {"status": "SINTON-IA Red Flag Models are awake and ready."}
+    return {"status": "SINTON-IA Models are awake."}