Update app.py

app.py

@@ -1,85 +1,98 @@
 import streamlit as st
 import pandas as pd
 import numpy as np
-from PIL import Image
-import os
+import seaborn as sns
+import matplotlib.pyplot as plt
+from statistics import mode, StatisticsError
+import io # Per gestione file upload
 
-# Scikit-learn
-from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import LabelEncoder, StandardScaler
-from sklearn.metrics import accuracy_score, confusion_matrix
+# --- Scikit-learn ---
+from sklearn.model_selection import train_test_split, GridSearchCV
+from sklearn.preprocessing import StandardScaler, LabelEncoder # LabelEncoder servirà se usiamo VAE con shape_code
 from sklearn.pipeline import Pipeline
+from sklearn.metrics import confusion_matrix, accuracy_score, f1_score
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
 from sklearn.linear_model import LogisticRegression
-from sklearn.ensemble import RandomForestClassifier
-import matplotlib.pyplot as plt
-import seaborn as sns
+from sklearn.svm import SVC
+from sklearn.neural_network import MLPClassifier # Usato nei dummy models
 
-# PyTorch
+# --- PyTorch (per VAE) ---
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+import torch.utils.data
 import random
 
-###########################################
-# 1) Libreria Destinazioni (multi-class)
-###########################################
-TARGET_LABELS = ["Armadio", "Dock", "Vetrina", "Tool"]
-
-def pick_random_target(row):
-    """
-    Logica fittizia: in base ad area e shape_code assegna una destinazione
-    """
-    # Semplifichiamo: se shape_code = 0 => preferiamo "Armadio"
-    # shape_code = 1 => "Dock"
-    # shape_code = 2 => "Vetrina"
-    # shape_code = 3 => "Tool"
-    # ma aggiungiamo un po' di random
-    code = int(row["shape_code"])
-    return TARGET_LABELS[code]
-
-###########################################
-# 2) Genera dataset sintetico
-###########################################
-def generate_synthetic_data_mc(n=300, seed=42):
-    """
-    Genera un dataset multi-classe:
-      - volume, area, lunghezza, spessore, shape_code (0..3), usura
-      - label = "Armadio"/"Dock"/"Vetrina"/"Tool" (fittizi)
-    """
-    np.random.seed(seed)
-    random.seed(seed)
-
-    volume = np.clip(np.random.normal(50,15,n), 10, 200)
-    area   = np.clip(np.random.normal(20,8,n), 5, 200)
-    lung   = np.clip(np.random.normal(100,30,n), 20, 300)
-    spess  = np.clip(np.random.normal(5,1,n), 0.5, 10)
-    usura  = np.random.rand(n)  # 0..1
-    shape_code = np.random.randint(0,4,n) # 4 possibili "forme"
-
-    df = pd.DataFrame({
-        "volume": volume,
-        "area": area,
-        "lunghezza": lung,
-        "spessore": spess,
-        "usura": usura,
-        "shape_code": shape_code
-    })
-
-    # label => in base a shape_code
-    df["target"] = df.apply(pick_random_target, axis=1)
-    return df
-
-###########################################
-# 3) Modello PyTorch VAE per generative reuse
-###########################################
+# --- Impostazioni Pagina Streamlit ---
+st.set_page_config(
+    page_title="WEEKO - AI Reuse Analyzer",
+    page_icon="♻️",
+    layout="wide"
+)
+
+##########################################
+# 1. PLACEHOLDER / DUMMY MODELS (dal codice Zero Scarto)
+##########################################
+class DummyTabTransformerClassifier:
+    # Semplificato: usa MLP come base per il placeholder
+    def __init__(self, input_dim=8): # Input dim deve corrispondere alle feature usate
+         # Architettura minima
+        self.clf = MLPClassifier(hidden_layer_sizes=(max(16,input_dim*2), max(8,input_dim)), max_iter=100, random_state=42, alpha=0.01, learning_rate_init=0.01)
+    def fit(self, X, y):
+        self.clf.fit(X, y)
+        return self
+    def predict(self, X):
+        return self.clf.predict(X)
+    def predict_proba(self, X):
+        # Assicurati che predict_proba sia disponibile
+        if hasattr(self.clf, 'predict_proba'):
+            return self.clf.predict_proba(X)
+        else: # Fallback se il modello non ha predict_proba (improbabile per MLP)
+            preds = self.clf.predict(X)
+            return np.array([[1.0, 0.0] if p == 0 else [0.0, 1.0] for p in preds])
+
+
+class DummySAINTClassifier:
+     # Semplificato: usa MLP come base per il placeholder
+    def __init__(self, input_dim=8): # Input dim deve corrispondere alle feature usate
+        # Architettura minima
+        self.clf = MLPClassifier(hidden_layer_sizes=(max(20,input_dim*2), max(10,input_dim)), max_iter=120, random_state=42, alpha=0.005, learning_rate_init=0.005)
+    def fit(self, X, y):
+        self.clf.fit(X, y)
+        return self
+    def predict(self, X):
+        return self.clf.predict(X)
+    def predict_proba(self, X):
+         if hasattr(self.clf, 'predict_proba'):
+            return self.clf.predict_proba(X)
+         else:
+            preds = self.clf.predict(X)
+            return np.array([[1.0, 0.0] if p == 0 else [0.0, 1.0] for p in preds])
+
+# Dizionario Modelli ML (Step 1)
+MODELS = {
+    "Random Forest": RandomForestClassifier(random_state=42, n_estimators=100, class_weight='balanced'),
+    "Gradient Boosting": GradientBoostingClassifier(random_state=42, n_estimators=100),
+    "Logistic Regression": LogisticRegression(random_state=42, max_iter=500, class_weight='balanced'),
+    "Support Vector Machine": SVC(probability=True, random_state=42, class_weight='balanced'),
+    "TabTransformer (Dummy)": DummyTabTransformerClassifier(),
+    "SAINT (Dummy)": DummySAINTClassifier()
+}
+
+##########################################
+# 2. DEFINIZIONE MODELLO VAE (Step 2 - Generative)
+##########################################
 class MiniVAE(nn.Module):
-    def __init__(self, input_dim=4, latent_dim=2):
+    # input_dim: numero di feature geometriche/fisiche usate dal VAE
+    def __init__(self, input_dim=5, latent_dim=2):
         super().__init__()
-        self.fc1 = nn.Linear(input_dim, 16)
-        self.fc21 = nn.Linear(16, latent_dim)
-        self.fc22 = nn.Linear(16, latent_dim)
-        self.fc3 = nn.Linear(latent_dim, 16)
-        self.fc4 = nn.Linear(16, input_dim)
+        # Encoder
+        self.fc1 = nn.Linear(input_dim, 32)
+        self.fc21 = nn.Linear(32, latent_dim) # Mu
+        self.fc22 = nn.Linear(32, latent_dim) # LogVar
+        # Decoder
+        self.fc3 = nn.Linear(latent_dim, 32)
+        self.fc4 = nn.Linear(32, input_dim)
 
     def encode(self, x):
         h = F.relu(self.fc1(x))
@@ -88,7 +101,7 @@ class MiniVAE(nn.Module):
     def reparameterize(self, mu, logvar):
         std = torch.exp(0.5 * logvar)
         eps = torch.randn_like(std)
-        return mu + eps*std
+        return mu + eps * std
 
     def decode(self, z):
         h = F.relu(self.fc3(z))
@@ -100,269 +113,710 @@ class MiniVAE(nn.Module):
         recon = self.decode(z)
         return recon, mu, logvar
 
+# Loss function per VAE
 def vae_loss(recon_x, x, mu, logvar):
-    mse = F.mse_loss(recon_x, x, reduction='sum')
+    recon_loss = F.mse_loss(recon_x, x, reduction='sum')
     kld = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
-    return mse + kld
-
-
-###########################################
-# STREAMLIT SETUP
-###########################################
-st.set_page_config(page_title="WEEKO – Full AI App", layout="wide")
-st.title("WEEKO – Full AI Demo: multi-class + generative + overlay")
-
-if "df" not in st.session_state:
-    st.session_state["df"] = None
-if "model" not in st.session_state:
-    st.session_state["model"] = None
-if "vae" not in st.session_state:
-    st.session_state["vae"] = None
-if "vae_trained" not in st.session_state:
-    st.session_state["vae_trained"] = False
-if "label_enc" not in st.session_state:
-    st.session_state["label_enc"] = None
-
-
-###########################################
-# SIDEBAR
-###########################################
-menu = st.sidebar.radio("Fasi", ["Dataset","Training","Inferenza","Generative Reuse (VAE)","Overlay Estetico","Dashboard"])
-
-###########################################
-# FUNZIONE: Caricamento/generazione dataset
-###########################################
-def dataset_phase():
-    st.subheader("Fase 1: Dataset")
-
-    data_option = st.radio("Scegli la fonte del dataset", ["Genera Sintetico","Carica CSV"], horizontal=True)
-    if data_option == "Genera Sintetico":
-        n = st.slider("Numero di campioni", 50,1000,300,step=50)
-        if st.button("Genera"):
-            df = generate_synthetic_data_mc(n=n)
-            st.session_state["df"] = df
-            st.success("Dataset sintetico generato!")
+    return recon_loss + kld
+
+# Funzione Helper per ottenere Embeddings VAE (se servirà in futuro)
+def get_vae_embeddings(data_df, vae_model, scaler):
+    if vae_model is None or scaler is None: return None
+    try:
+        if not hasattr(scaler, 'feature_names_in_'): raise ValueError("Scaler non fittato o senza feature names.")
+        ordered_cols = scaler.feature_names_in_
+        if not all(col in data_df.columns for col in ordered_cols): raise ValueError("Colonne mancanti per VAE.")
+        data_ordered = data_df[ordered_cols]
+        data_scaled = scaler.transform(data_ordered)
+        data_t = torch.tensor(data_scaled, dtype=torch.float32)
+        vae_model.eval()
+        with torch.no_grad():
+            mu, _ = vae_model.encode(data_t)
+        return mu.numpy()
+    except Exception as e:
+        st.error(f"Errore embedding VAE: {e}")
+        return None
+
+##########################################
+# 3. FUNZIONI LOGICA OR6 (Step 1 - Zero Scarto Analyzer)
+##########################################
+# Features: length, width, RUL, margin, shape, weight, thickness
+DEFAULT_FEATURES_STEP1 = ['length', 'width', 'RUL', 'margin', 'shape', 'weight', 'thickness']
+# Features numeriche usate per ML (shape diventa shape_code)
+ML_FEATURES_STEP1 = ['length', 'width', 'shape_code', 'weight', 'thickness', 'RUL', 'margin', 'compat_dim']
+# Features geometriche/fisiche per VAE (Step 2) - Sottoinsieme delle precedenti
+VAE_FEATURES_STEP2 = ['length', 'width', 'weight', 'thickness', 'shape_code'] # Escludiamo RUL, margin, compat_dim
+
+
+def generate_synthetic_data(n_samples=300, seed=42):
+    np.random.seed(seed)
+    length = np.clip(np.random.normal(loc=100, scale=20, size=n_samples), 50, 250) # Aumentato range
+    width = np.clip(np.random.normal(loc=50, scale=15, size=n_samples), 20, 150)  # Aumentato range
+    RUL = np.clip(np.random.normal(loc=500, scale=250, size=n_samples), 0, 1000).astype(int) # Più varianza RUL
+    margin = np.clip(np.random.normal(loc=150, scale=150, size=n_samples), -200, 600).astype(int) # Più varianza margin
+    shapes = np.random.choice(['axisymmetric', 'sheet_metal', 'alloy_plate', 'complex_plastic'], size=n_samples, p=[0.4, 0.3, 0.15, 0.15]) # Aggiunta forma
+    weight = np.clip(np.random.normal(loc=80, scale=30, size=n_samples), 10, 250) # Range peso più ampio
+    thickness = np.clip(np.random.normal(loc=8, scale=4, size=n_samples), 0.5, 30) # Range spessore più ampio
+
+    return pd.DataFrame({
+        'length': length, 'width': width, 'RUL': RUL, 'margin': margin,
+        'shape': shapes, 'weight': weight, 'thickness': thickness
+    })
+
+# Funzione per match dimensionale (resta uguale)
+def dimension_match(row, target_length, target_width, target_shape, target_weight, target_thickness,
+                    tol_len, tol_wid, tol_weight, tol_thickness):
+    cond_length = abs(row['length'] - target_length) <= tol_len
+    cond_width = abs(row['width'] - target_width) <= tol_wid
+    cond_shape = row['shape'] == target_shape
+    cond_weight = abs(row['weight'] - target_weight) <= tol_weight
+    cond_thickness = abs(row['thickness'] - target_thickness) <= tol_thickness
+    # Ora richiede TUTTE le condizioni (più stringente)
+    return 1 if (cond_length and cond_width and cond_shape and cond_weight and cond_thickness) else 0
+
+# Funzione per assegnare classe (resta uguale)
+def assign_class(row, threshold_score=0.5, alpha=0.5, beta=0.5):
+    rul_norm = row['RUL'] / 1000.0 # Normalizza RUL
+    margin_norm = (row['margin'] + 200.0) / 800.0 # Normalizza margin [-200, 600] -> [0, 1]
+    score = alpha * rul_norm + beta * margin_norm
+    if row['compat_dim'] == 1 and score >= threshold_score:
+        return "Riutilizzo Funzionale"
     else:
-        file = st.file_uploader("Carica CSV con colonne: volume, area, lunghezza, spessore, usura, shape_code, target", type=["csv"])
-        if file:
-            df = pd.read_csv(file)
-            st.session_state["df"] = df
-            st.success("Dataset caricato!")
-
-    if st.session_state["df"] is not None:
-        st.write("Anteprima dataset:")
-        st.dataframe(st.session_state["df"].head(10))
-        st.write("Distribuzione target:", st.session_state["df"]["target"].value_counts())
-        csv = st.session_state["df"].to_csv(index=False)
-        st.download_button("Scarica Dataset", csv, "dataset.csv","text/csv")
-
-###########################################
-# FUNZIONE: Training multi-class (es. RandomForest)
-###########################################
-def training_phase():
-    st.subheader("Fase 2: Training Modello Multi-Classe")
-    df = st.session_state["df"]
-    if df is None:
-        st.error("Prima genera o carica il dataset!")
-        return
-    
-    st.write("Esempio: usiamo un RandomForest + pipeline StandardScaler.")
-    from sklearn.pipeline import Pipeline
-    from sklearn.ensemble import RandomForestClassifier
-
-    # Prepara X,y
-    # NB: shape_code e -> numerico, target -> labelEnc
-    if "target" not in df.columns:
-        st.error("Il dataset deve avere colonna 'target'!")
+        # Se non c'è compatibilità dimensionale O lo score è basso -> Upcycling
+        return "Upcycling Creativo"
+
+# Mapping forma a codice numerico
+SHAPE_MAPPING = {'axisymmetric': 0, 'sheet_metal': 1, 'alloy_plate': 2, 'complex_plastic': 3}
+
+##########################################
+# 4. FUNZIONI STREAMLIT PER LE FASI
+##########################################
+
+# --- Fase 1: Preparazione Dataset ---
+def prepare_dataset():
+    st.header("♻️ 1. Preparazione Dataset EoL")
+    # Tabs per organizzare
+    tab1, tab2 = st.tabs(["Carica/Genera Dati", "Definisci Compatibilità & Target"])
+
+    data_loaded = False
+    with tab1:
+        st.subheader("Fonte Dati")
+        data_option = st.radio("Scegli", ["Genera dati sintetici", "Carica un CSV"], horizontal=True, key="data_opt")
+        data = None # Inizializza data a None
+
+        if data_option == "Genera dati sintetici":
+            n_samples = st.slider("Numero di campioni", 100, 2000, 500, help="Seleziona il numero di campioni da generare", key="gen_n")
+            if st.button("Genera Dati"):
+                data = generate_synthetic_data(n_samples=n_samples)
+                st.session_state.data_source = "generated" # Salva la fonte
+        else:
+            uploaded_file = st.file_uploader("Carica un file CSV", type=["csv"], key="csv_up")
+            if uploaded_file:
+                try:
+                    data = pd.read_csv(uploaded_file)
+                    # Controllo colonne minime
+                    if not all(col in data.columns for col in DEFAULT_FEATURES_STEP1):
+                        st.error(f"Il CSV deve contenere almeno le colonne: {', '.join(DEFAULT_FEATURES_STEP1)}")
+                        data = None # Invalida i dati caricati
+                    else:
+                         st.session_state.data_source = "uploaded" # Salva la fonte
+                except Exception as e:
+                    st.error(f"Errore lettura CSV: {str(e)}")
+                    data = None
+            #else:
+                #st.info("Carica un file CSV o scegli 'Genera dati sintetici'.")
+
+    # Se i dati sono stati generati o caricati correttamente, procedi
+    if data is not None:
+         with tab2:
+            st.subheader("Parametri per Compatibilità e Classe Target")
+            st.markdown("Definisci i requisiti per il 'Riutilizzo Funzionale' e come calcolare lo score.")
+            # Parametri Target (per dimension_match)
+            col_t1, col_t2 = st.columns(2)
+            with col_t1:
+                 target_length = st.number_input("Lunghezza target (mm)", 50.0, 250.0, 100.0, step=1.0, key="t_len")
+                 target_width = st.number_input("Larghezza target (mm)", 20.0, 150.0, 50.0, step=1.0, key="t_wid")
+                 target_shape = st.selectbox("Forma target", list(SHAPE_MAPPING.keys()), index=0, key="t_shape")
+            with col_t2:
+                 target_weight = st.number_input("Peso target (kg)", 10.0, 250.0, 80.0, step=1.0, key="t_wei")
+                 target_thickness = st.number_input("Spessore target (mm)", 0.5, 30.0, 8.0, step=0.5, key="t_thi")
+
+            # Tolleranze
+            st.markdown("**Tolleranze Dimensionali:**")
+            col_tol1, col_tol2 = st.columns(2)
+            with col_tol1:
+                tol_len = st.slider("Tolleranza lunghezza (±mm)", 0.0, 20.0, 5.0, step=0.5, key="tol_l")
+                tol_wid = st.slider("Tolleranza larghezza (±mm)", 0.0, 15.0, 3.0, step=0.5, key="tol_w")
+            with col_tol2:
+                tol_weight = st.slider("Tolleranza peso (±kg)", 0.0, 30.0, 10.0, step=1.0, key="tol_we")
+                tol_thickness = st.slider("Tolleranza spessore (±mm)", 0.0, 5.0, 1.0, step=0.1, key="tol_t")
+
+            # Parametri per Score (assegnazione classe)
+            st.markdown("**Parametri per Score (RUL & Margin):**")
+            threshold_score = st.slider("Soglia minima score per Riutilizzo", 0.0, 1.0, 0.5, step=0.05, key="score_thr")
+            alpha = st.slider("Peso RUL nello score (α)", 0.0, 1.0, 0.5, step=0.05, key="alpha_w")
+            beta = st.slider("Peso Margin nello score (β)", 0.0, 1.0, 0.5, step=0.05, key="beta_w")
+
+            # --- Calcoli sul dataset (DOPO aver definito i parametri) ---
+            # Salva i parametri in session_state per usarli anche in inferenza
+            st.session_state.target_params = {
+                "target_length": target_length, "target_width": target_width, "target_shape": target_shape,
+                "target_weight": target_weight, "target_thickness": target_thickness,
+                "tol_len": tol_len, "tol_wid": tol_wid, "tol_weight": tol_weight, "tol_thickness": tol_thickness
+            }
+            st.session_state.score_params = {"threshold_score": threshold_score, "alpha": alpha, "beta": beta}
+
+            # Codifica numerica della forma (necessaria per ML e VAE)
+            data['shape_code'] = data['shape'].map(SHAPE_MAPPING)
+            # Gestisce eventuali shape non mappate (NaN) riempiendole con un codice default (es. -1)
+            data['shape_code'] = data['shape_code'].fillna(-1).astype(int)
+
+
+            # Calcola compat_dim
+            data['compat_dim'] = data.apply(lambda row: dimension_match(row, **st.session_state.target_params), axis=1)
+
+            # Assegna Target ("Riutilizzo Funzionale" o "Upcycling Creativo")
+            data['Target'] = data.apply(lambda row: assign_class(row, **st.session_state.score_params), axis=1)
+
+            # --- Visualizzazione e Download ---
+            st.subheader("Dataset Elaborato")
+            st.dataframe(data.head(10))
+            st.write("Distribuzione classi target generate:")
+            st.bar_chart(data['Target'].value_counts())
+
+            # Heatmap Correlazione (solo su colonne numeriche)
+            numeric_cols = data.select_dtypes(include=np.number)
+            if not numeric_cols.empty:
+                 with st.expander("Visualizza Heatmap Correlazioni"):
+                    fig, ax = plt.subplots(figsize=(8, 6))
+                    sns.heatmap(numeric_cols.corr(), annot=True, cmap='viridis', fmt=".2f", ax=ax)
+                    st.pyplot(fig)
+
+            # Download
+            csv_processed = data.to_csv(index=False).encode('utf-8')
+            st.download_button("Scarica Dataset Elaborato (CSV)", csv_processed, "dataset_processed.csv", "text/csv")
+
+            # Salva il dataframe elaborato in session state e resetta i modelli
+            st.session_state.data = data
+            st.session_state.models = None # Resetta modelli ML
+            st.session_state.vae_trained_on_eol = False # Resetta VAE
+            data_loaded = True # Flag per indicare che i dati sono pronti
+
+    # Mostra messaggio se i dati non sono ancora stati caricati/generati/elaborati
+    if not data_loaded and st.session_state.get("data_source") is not None:
+         st.info("Dati caricati/generati. Configura i parametri nella Tab 'Definisci Compatibilità & Target' per elaborare il dataset.")
+    elif st.session_state.get("data_source") is None:
+         st.info("Inizia generando o caricando un dataset nella Tab 'Carica/Genera Dati'.")
+
+# --- Fase 2: Addestramento Modelli ML (Step 1) ---
+def train_models(data):
+    st.header("🤖 2. Addestramento Modelli Classificazione (Step 1)")
+    if data is None:
+        st.error("Dataset non disponibile. Preparalo nella Fase 1.")
+        return None
+    if 'Target' not in data.columns:
+        st.error("Colonna 'Target' non trovata nel dataset elaborato.")
+        return None
+
+    st.markdown("Addestra diversi modelli per predire 'Riutilizzo Funzionale' vs 'Upcycling Creativo'.")
+
+    # Preparazione X, y
+    # Usiamo le feature definite in ML_FEATURES_STEP1, assicurandoci che esistano nel df
+    features_to_use = [f for f in ML_FEATURES_STEP1 if f in data.columns]
+    if len(features_to_use) < len(ML_FEATURES_STEP1):
+         st.warning(f"Alcune feature attese ({ML_FEATURES_STEP1}) non trovate. Usando: {features_to_use}")
+    if not features_to_use:
+         st.error("Nessuna feature valida trovata per l'addestramento.")
+         return None
+
+    X = data[features_to_use]
+    # Mappiamo le classi target a 0 e 1
+    y = data['Target'].map({"Riutilizzo Funzionale": 0, "Upcycling Creativo": 1})
+
+    # Controllo bilanciamento classi
+    if len(y.unique()) < 2:
+        st.error("Il dataset elaborato contiene una sola classe target. "
+                 "Verifica i parametri di compatibilità/score o il dataset originale. Impossibile addestrare.")
+        return None
+
+    # Split Train/Test
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42, stratify=y)
+    st.write(f"Dataset diviso in: {len(X_train)} training samples, {len(X_test)} test samples.")
+
+    # Opzione Tuning (solo per RF come esempio)
+    tune_rf = st.checkbox("Ottimizza iperparametri per Random Forest (lento)", value=False, key="tune_rf")
+
+    trained_pipelines = {}
+    results = []
+    all_models_container = st.container() # Container per i risultati dei modelli
+
+    with st.spinner("Addestramento modelli in corso..."):
+        # Aggiorna input_dim per i dummy models basato sulle feature reali
+        MODELS["TabTransformer (Dummy)"] = DummyTabTransformerClassifier(input_dim=X_train.shape[1])
+        MODELS["SAINT (Dummy)"] = DummySAINTClassifier(input_dim=X_train.shape[1])
+
+        for name, model in MODELS.items():
+             # Usiamo colonne per layout più compatto
+             col1, col2 = all_models_container.columns([3, 1]) # Nome modello + Bottone/Risultati
+             with col1:
+                 st.subheader(f"Modello: {name}")
+             try:
+                pipeline = Pipeline([
+                    ('scaler', StandardScaler()), # Scaling è sempre il primo step
+                    ('classifier', model)
+                ])
+
+                # Tuning opzionale per Random Forest
+                if tune_rf and name == "Random Forest":
+                    with col1:
+                         st.write("Esecuzione GridSearchCV per Random Forest...")
+                    param_grid = {
+                        'classifier__n_estimators': [50, 100], # Ridotto per velocità
+                        'classifier__max_depth': [None, 10, 15],
+                        'classifier__min_samples_split': [2, 5]
+                    }
+                    # Usiamo CV=2 per velocità nel demo
+                    grid = GridSearchCV(pipeline, param_grid, cv=2, scoring='accuracy', n_jobs=-1)
+                    grid.fit(X_train, y_train)
+                    best_pipeline = grid.best_estimator_
+                    with col1:
+                        st.write(f"Migliori parametri trovati: `{grid.best_params_}`")
+                    pipeline_to_evaluate = best_pipeline # Valuta il modello ottimizzato
+                else:
+                    # Addestramento standard
+                    pipeline.fit(X_train, y_train)
+                    pipeline_to_evaluate = pipeline # Valuta il modello standard
+
+                # Valutazione
+                y_pred = pipeline_to_evaluate.predict(X_test)
+                acc = accuracy_score(y_test, y_pred)
+                f1 = f1_score(y_test, y_pred, average='weighted') # Usiamo weighted F1
+
+                # Salva risultati e pipeline addestrata
+                results.append({'Modello': name, 'Accuracy': acc, 'F1 Score': f1})
+                trained_pipelines[name] = pipeline_to_evaluate
+
+                # Mostra risultati per il modello corrente
+                with col2:
+                    st.metric("Accuracy", f"{acc:.3f}")
+                    st.metric("F1 Score", f"{f1:.3f}")
+
+                # Matrice di Confusione
+                with col1:
+                    with st.expander("Mostra Matrice di Confusione"):
+                        fig, ax = plt.subplots(figsize=(4, 3))
+                        cm = confusion_matrix(y_test, y_pred)
+                        sns.heatmap(cm, annot=True, fmt='d', ax=ax, cmap="Greens",
+                                    xticklabels=["Riutilizzo", "Upcycling"], yticklabels=["Riutilizzo", "Upcycling"])
+                        plt.xlabel("Predicted")
+                        plt.ylabel("True")
+                        st.pyplot(fig)
+                all_models_container.markdown("---") # Separatore
+
+             except Exception as e:
+                  with col1:
+                       st.error(f"Errore durante l'addestramento di {name}: {e}")
+
+    # Mostra tabella riassuntiva finale
+    st.subheader("Risultati Complessivi Addestramento")
+    if results:
+        results_df = pd.DataFrame(results).sort_values(by="Accuracy", ascending=False).reset_index(drop=True)
+        st.dataframe(results_df.style.format({'Accuracy': "{:.3f}", 'F1 Score': "{:.3f}"})
+                                    .highlight_max(subset=['Accuracy', 'F1 Score'], color='lightgreen', axis=0))
+        st.session_state.train_results = results_df # Salva per Dashboard
+        st.session_state.models = trained_pipelines # Salva i modelli addestrati
+        return trained_pipelines
+    else:
+        st.error("Nessun modello è stato addestrato con successo.")
+        st.session_state.models = None
+        return None
+
+# --- Fase 3: Inferenza (Step 1) + Trigger VAE (Step 2) ---
+def model_inference(trained_pipelines, data_stats): # Passiamo stats per i default
+    st.header("🔮 3. Inferenza: Previsione Riutilizzo vs Upcycling")
+    if not trained_pipelines:
+        st.error("Nessun modello ML addestrato disponibile (Fase 2).")
         return
-
-    # Estrai X e y
-    # Minimal check: [volume, area, lunghezza, spessore, usura, shape_code]
-    needed_cols = ["volume","area","lunghezza","spessore","usura","shape_code","target"]
-    for c in needed_cols:
-        if c not in df.columns:
-            st.error(f"Colonna '{c}' assente nel dataset!")
+    if 'target_params' not in st.session_state:
+         st.error("Parametri target non definiti. Completa la Fase 1.")
+         return
+
+    with st.form(key="inference_form_step1"):
+        st.markdown("#### Inserisci Dati Componente EoL")
+        # Usiamo data_stats (median) per valori di default sensati
+        col_inf1, col_inf2, col_inf3 = st.columns(3)
+        with col_inf1:
+            length = st.number_input("Lunghezza (mm)", min_value=0.0, value=float(data_stats['length'].median()), step=1.0)
+            width = st.number_input("Larghezza (mm)", min_value=0.0, value=float(data_stats['width'].median()), step=1.0)
+            selected_shape = st.selectbox("Forma", list(SHAPE_MAPPING.keys()), index=0)
+        with col_inf2:
+            weight = st.number_input("Peso (kg)", min_value=0.0, value=float(data_stats['weight'].median()), step=0.1)
+            thickness = st.number_input("Spessore (mm)", min_value=0.0, value=float(data_stats['thickness'].median()), step=0.1)
+            RUL = st.number_input("RUL (0-1000)", min_value=0, max_value=1000, value=int(data_stats['RUL'].median()), step=10)
+        with col_inf3:
+            # Margin è calcolato, chiediamo Costo e Valore
+            valore_mercato = st.number_input("Valore Mercato Stimato (€)", min_value=0.0, value=float(data_stats['margin'].median()+50), step=10.0) # Default basato su margin mediano + costo fittizio
+            costo_riparazione = st.number_input("Costo Riparazione Stimato (€)", min_value=0.0, value=50.0, step=10.0)
+
+        submit_button = st.form_submit_button("Esegui Predizione (Step 1)")
+
+    if submit_button:
+        # --- Preparazione Input per Modelli ML ---
+        margin = valore_mercato - costo_riparazione
+        shape_code = SHAPE_MAPPING.get(selected_shape, -1) # Usa mapping, default -1 se non trovato
+
+        # Crea dizionario input per compat_dim e ML
+        input_dict_ml = {
+            "length": length, "width": width, "shape": selected_shape, # shape stringa per dimension_match
+            "weight": weight, "thickness": thickness, "RUL": RUL, "margin": margin
+        }
+        input_df_temp = pd.DataFrame([input_dict_ml])
+
+        # Calcola compat_dim usando parametri salvati
+        input_df_temp['compat_dim'] = input_df_temp.apply(lambda row: dimension_match(row, **st.session_state.target_params), axis=1)
+
+        # Aggiungi shape_code e rimuovi shape stringa per predizione ML
+        input_df_ml = input_df_temp.copy()
+        input_df_ml['shape_code'] = shape_code
+        input_df_ml = input_df_ml.drop(columns=['shape'])
+
+        # Assicura che le colonne siano nell'ordine atteso dai modelli (basato su ML_FEATURES_STEP1)
+        try:
+            input_df_ml_ordered = input_df_ml[ML_FEATURES_STEP1]
+        except KeyError as e:
+             st.error(f"Errore: Colonna mancante nell'input per ML: {e}. Feature attese: {ML_FEATURES_STEP1}")
+             st.dataframe(input_df_ml) # Mostra cosa è stato preparato
+             return # Interrompi se l'input non è corretto
+
+        # --- Predizione con tutti i modelli addestrati ---
+        model_predictions = []
+        model_details_list = []
+        with st.spinner("Esecuzione predizioni modelli ML..."):
+            for name, pipe in trained_pipelines.items():
+                try:
+                    pred_num = pipe.predict(input_df_ml_ordered)[0] # 0 o 1
+                    proba = pipe.predict_proba(input_df_ml_ordered)[0] # Probabilità [prob_0, prob_1]
+                    model_predictions.append(pred_num)
+                    model_details_list.append({
+                        "Modello": name,
+                        "Predizione (0=Riutilizzo, 1=Upcycling)": pred_num,
+                        "Prob. Riutilizzo": proba[0],
+                        "Prob. Upcycling": proba[1]
+                    })
+                except Exception as e:
+                     st.warning(f"Errore durante la predizione con {name}: {e}")
+
+        # --- Aggregazione Risultati ---
+        if not model_predictions:
+            st.error("Nessun modello ha prodotto una predizione valida.")
             return
 
-    X = df[["volume","area","lunghezza","spessore","usura","shape_code"]]
-    y = df["target"].astype(str)
-
-    # label encode
-    from sklearn.preprocessing import LabelEncoder
-    le = LabelEncoder()
-    y_enc = le.fit_transform(y)
-
-    st.session_state["label_enc"] = le
-
-    # train test split
-    from sklearn.model_selection import train_test_split
-    X_train, X_test, y_train, y_test = train_test_split(X, y_enc, test_size=0.2, random_state=42)
-
-    # pipeline
-    pipe = Pipeline([
-        ("scaler", StandardScaler()),
-        ("clf", RandomForestClassifier(n_estimators=100, random_state=42))
-    ])
-
-    pipe.fit(X_train, y_train)
-    pred = pipe.predict(X_test)
-
-    acc = accuracy_score(y_test, pred)
-    st.write(f"Accuracy su test: {acc:.3f}")
-
-    cm = confusion_matrix(y_test, pred)
-    fig, ax = plt.subplots()
-    sns.heatmap(cm, annot=True, fmt='d', ax=ax)
-    st.pyplot(fig)
-
-    st.session_state["model"] = pipe
-    st.success("Modello addestrato e salvato in session_state['model'].")
+        try:
+            # Usa la moda (predizione più frequente)
+            aggregated_pred_num = mode(model_predictions)
+        except StatisticsError:
+            # Se c'è pareggio, usa la media delle probabilità di 'Riutilizzo'
+            avg_prob_reuse = np.mean([d["Prob. Riutilizzo"] for d in model_details_list])
+            aggregated_pred_num = 0 if avg_prob_reuse >= 0.5 else 1
+
+        aggregated_label = "Riutilizzo Funzionale" if aggregated_pred_num == 0 else "Upcycling Creativo"
+
+        # --- Mostra Risultati Step 1 ---
+        st.subheader("Risultato Predizione (Step 1)")
+        st.metric("Previsione Aggregata:", aggregated_label)
+
+        with st.expander("Dettagli Predizioni Singoli Modelli"):
+            details_df = pd.DataFrame(model_details_list)
+            details_df["Prob. Riutilizzo"] = details_df["Prob. Riutilizzo"].apply(lambda x: f"{x:.1%}")
+            details_df["Prob. Upcycling"] = details_df["Prob. Upcycling"].apply(lambda x: f"{x:.1%}")
+            st.dataframe(details_df)
+
+        # --- LOGICA CONDIZIONALE PER STEP 2 (VAE/GenAI) ---
+        if aggregated_label == "Upcycling Creativo":
+            st.markdown("---")
+            st.subheader("🧬 Step 2: Esplorazione Generativa (Upcycling)")
+            st.warning("La predizione suggerisce 'Upcycling Creativo'. Puoi usare il VAE per generare idee di riuso.")
+
+            # Controlla se il VAE è stato addestrato
+            if not st.session_state.get("vae_trained_on_eol", False):
+                st.error("Il modello VAE non è stato ancora addestrato. Vai alla fase '🧬 Training VAE' e addestralo prima di generare idee.")
+            else:
+                vae_model = st.session_state.get("vae")
+                vae_scaler = st.session_state.get("vae_scaler")
+                if vae_model is None or vae_scaler is None:
+                     st.error("Errore: Modello VAE o scaler non trovati in session_state anche se marcato come addestrato.")
+                else:
+                    n_generate_vae = st.number_input("Quante idee generare?", 1, 10, 3, key="n_gen_vae_inf")
+                    if st.button("Genera Idee di Riuso con VAE"):
+                        with st.spinner("Generazione VAE in corso..."):
+                             vae_model.eval()
+                             with torch.no_grad():
+                                # Recupera latent_dim dal modello caricato
+                                latent_dim = vae_model.fc21.out_features
+                                z = torch.randn(n_generate_vae, latent_dim)
+                                recon_scaled = vae_model.decode(z)
+
+                                try:
+                                    # Decodifica e mostra
+                                    recon_original = vae_scaler.inverse_transform(recon_scaled.numpy())
+                                    # Le colonne sono quelle usate per addestrare il VAE
+                                    vae_feature_names = vae_scaler.feature_names_in_
+                                    df_gen = pd.DataFrame(recon_original, columns=vae_feature_names)
+
+                                    st.write(f"**{n_generate_vae} Configurazioni Geometriche Generate:**")
+                                    # Arrotonda e formatta shape_code come intero
+                                    if 'shape_code' in df_gen.columns:
+                                        df_gen['shape_code'] = df_gen['shape_code'].round().astype(int)
+                                        # Opzionale: riconverti shape_code in nome forma
+                                        inv_shape_map = {v: k for k, v in SHAPE_MAPPING.items()}
+                                        df_gen['shape'] = df_gen['shape_code'].map(inv_shape_map).fillna('sconosciuto')
+
+                                    st.dataframe(df_gen.round(2))
+                                    st.caption("Nota: Queste sono configurazioni generate casualmente dal VAE, basate sulla distribuzione appresa. Rappresentano 'idee' o punti di partenza.")
+
+                                except Exception as e:
+                                     st.error(f"Errore durante decodifica VAE: {e}")
+
+        elif aggregated_label == "Riutilizzo Funzionale":
+             st.success("La predizione suggerisce 'Riutilizzo Funzionale'. Non è richiesta la generazione VAE per questo caso.")
+
+# --- Fase 4: Training VAE (NUOVA FASE) ---
+def vae_training_phase():
+    st.header("🧬 4. Training VAE (Generative AI - Step 2)")
+    st.markdown("Addestra il Variational Autoencoder (VAE) sulle feature geometriche/fisiche del dataset per la generazione di idee di upcycling.")
+
+    if 'data' not in st.session_state or st.session_state['data'] is None:
+        st.error("Dataset non disponibile. Prepara il dataset nella Fase 1.")
+        return
 
-###########################################
-# FUNZIONE: Inference multi-class
-###########################################
-def inference_phase():
-    st.subheader("Fase 3: Inferenza su un nuovo EoL")
-    if st.session_state["model"] is None:
-        st.error("Devi prima addestrare il modello!")
+    data = st.session_state['data']
+    # Seleziona le feature definite in VAE_FEATURES_STEP2, controllando che esistano
+    features_for_vae = [f for f in VAE_FEATURES_STEP2 if f in data.columns]
+    if not features_for_vae:
+        st.error(f"Nessuna delle feature richieste per il VAE ({VAE_FEATURES_STEP2}) trovata nel dataset.")
         return
-    model = st.session_state["model"]
-    le = st.session_state["label_enc"]
-
-    # Inserimento EoL
-    col1, col2 = st.columns(2)
-    with col1:
-        vol = st.number_input("Volume (cm³)",0.0,1000.0,50.0,step=1.0)
-        area= st.number_input("Area (cm²)",0.0,1000.0,30.0,step=1.0)
-        lung= st.number_input("Lunghezza (mm)",0.0,2000.0,120.0,step=1.0)
-    with col2:
-        spess= st.number_input("Spessore (mm)",0.0,20.0,5.0,step=0.5)
-        usura= st.slider("Usura (0=nuovo,1=usuratissimo)",0.0,1.0,0.3)
-        shape_code = st.selectbox("Shape Code", [0,1,2,3], index=0)
-
-    if st.button("Calcola Compatibilità"):
-        x_np = np.array([[vol, area, lung, spess, usura, shape_code]], dtype=float)
-        proba = model.predict_proba(x_np)[0]
-        classes = le.inverse_transform(range(len(proba)))
-        # Ordina disc
-        sorted_idx = np.argsort(-proba)
-        st.write("**Compatibilità con i possibili target** (ordine decrescente):")
-        for i in sorted_idx:
-            st.write(f"- {classes[i]}: {proba[i]*100:.1f}%")
-        # Top1
-        top1 = classes[sorted_idx[0]]
-        st.success(f"**Consiglio**: {top1}")
-
-###########################################
-# FUNZIONE: Mini VAE generative reuse
-###########################################
-def generative_phase():
-    st.subheader("Fase 4: Generative Reuse (VAE)")
-
-    # Creiamo / inizializziamo
-    if st.session_state["vae"] is None:
-        st.session_state["vae"] = MiniVAE()
+
+    st.write(f"Il VAE sarà addestrato su: `{', '.join(features_for_vae)}`")
+    INPUT_DIM_VAE = len(features_for_vae)
+
+    # --- Configurazione VAE ---
+    with st.expander("Parametri VAE", expanded=False):
+        latent_dim = st.slider("Dimensione Latente VAE", 2, 16, 3, step=1, key="vae_lat_dim_train")
+        epochs = st.number_input("Epochs VAE", 10, 500, 100, step=10, key="vae_epo_train")
+        lr = st.number_input("Learning Rate VAE", 1e-5, 1e-2, 1e-3, format="%e", key="vae_lr_train")
+        batch_size = st.selectbox("Batch Size VAE", [16, 32, 64, 128], index=1, key="vae_bs_train")
+
+    # --- Inizializzazione/Reinizializzazione VAE ---
+    vae_needs_reinit = False
+    if "vae" not in st.session_state or st.session_state["vae"] is None: vae_needs_reinit = True
+    elif st.session_state["vae"].fc1.in_features != INPUT_DIM_VAE or st.session_state["vae"].fc21.out_features != latent_dim: vae_needs_reinit = True
+
+    if vae_needs_reinit:
+        st.session_state["vae"] = MiniVAE(input_dim=INPUT_DIM_VAE, latent_dim=latent_dim)
+        st.session_state["vae_trained_on_eol"] = False
+        st.session_state["vae_scaler"] = None
+        st.info(f"VAE Inizializzato (Input={INPUT_DIM_VAE}, Latent={latent_dim}). Pronto per l'addestramento.")
     vae = st.session_state["vae"]
 
-    # Se non allenato, lo alleniamo su dati fittizi
-    if not st.session_state["vae_trained"]:
-        if st.button("Allena VAE su dataset fittizio di 4 feature"):
-            # Generiamo un dataset: [dim1, dim2, spess, dec]
-            rng = np.random.default_rng(123)
-            n = 500
-            dim1 = rng.normal(50,10,n)
-            dim2 = rng.normal(20,5,n)
-            spess = rng.normal(5,1,n)
-            dec = rng.uniform(0,1,n)
-            arr = np.column_stack([dim1, dim2, spess, dec])
-            X_t = torch.tensor(arr,dtype=torch.float32)
-
-            optimizer = torch.optim.Adam(vae.parameters(), lr=1e-3)
-            epochs=20
-            batch_size=32
-            dataset = torch.utils.data.TensorDataset(X_t)
-            loader = torch.utils.data.DataLoader(dataset,batch_size=batch_size,shuffle=True)
-            
-            for ep in range(epochs):
-                total_loss=0
-                for (batch,) in loader:
-                    optimizer.zero_grad()
-                    recon, mu, logvar = vae(batch)
-                    loss=vae_loss(recon, batch, mu, logvar)
-                    loss.backward()
-                    optimizer.step()
-                    total_loss += loss.item()
-            st.session_state["vae_trained"] = True
-            st.success("VAE addestrato!")
+    # --- Bottone e Logica di Training ---
+    if not st.session_state.get("vae_trained_on_eol", False):
+        st.warning("VAE non ancora addestrato.")
+        if st.button("Avvia Training VAE"):
+            X_vae = data[features_for_vae].copy()
+            # Gestione valori NaN (importante!) - Sostituzione con mediana come esempio
+            for col in X_vae.columns:
+                 if X_vae[col].isnull().any():
+                     median_val = X_vae[col].median()
+                     X_vae[col] = X_vae[col].fillna(median_val)
+                     st.warning(f"Valori NaN in '{col}' sostituiti con mediana ({median_val:.2f})")
+
+            with st.spinner("Training VAE in corso..."):
+                # Scaling
+                scaler = StandardScaler()
+                X_scaled = scaler.fit_transform(X_vae)
+                st.session_state["vae_scaler"] = scaler # Salva lo scaler FITTATO
+                X_t = torch.tensor(X_scaled, dtype=torch.float32)
+
+                # DataLoader & Optimizer
+                dataset = torch.utils.data.TensorDataset(X_t)
+                loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
+                optimizer = torch.optim.Adam(vae.parameters(), lr=lr)
+
+                # Training Loop
+                losses = []
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                vae.train()
+                for ep in range(epochs):
+                    epoch_loss = 0
+                    for batch_idx, (batch_data,) in enumerate(loader):
+                        optimizer.zero_grad()
+                        recon, mu, logvar = vae(batch_data)
+                        loss = vae_loss(recon, batch_data, mu, logvar)
+                        loss.backward()
+                        optimizer.step()
+                        epoch_loss += loss.item()
+                    avg_loss = epoch_loss / len(loader.dataset)
+                    losses.append(avg_loss)
+                    status_text.text(f"Epoch {ep+1}/{epochs} | Avg Loss: {avg_loss:.4f}")
+                    progress_bar.progress((ep + 1) / epochs)
+
+                st.session_state["vae_trained_on_eol"] = True
+                st.success("Training VAE completato!")
+                st.line_chart(pd.DataFrame(losses, columns=['VAE Training Loss']))
     else:
-        st.info("VAE già addestrato.")
-
-    # Genera sample
-    if st.session_state["vae_trained"]:
-        if st.button("Genera 5 soluzioni"):
-            with torch.no_grad():
-                z = torch.randn(5,2)
-                recon = vae.decode(z)
-            arr = recon.numpy()
-            df = pd.DataFrame(arr, columns=["Dim1","Dim2","Spess","Decor"])
-            st.dataframe(df.round(2))
-            st.write("Interpretazione: Dim1, Dim2 = dimensioni, Spess=spessore, Decor=0..1 stima di ‘finitura artistica’?")
-
-###########################################
-# FUNZIONE: Overlay Estetico
-###########################################
-def overlay_phase():
-    st.subheader("Fase 5: Overlay Estetico")
-
-    col1, col2 = st.columns(2)
-    with col1:
-        file_eol = st.file_uploader("Foto EoL", type=["jpg","png"], key="uplEolOverlay")
-    with col2:
-        file_obj = st.file_uploader("Foto Oggetto Finale", type=["jpg","png"], key="uplObjOverlay")
-
-    alpha = st.slider("Trasparenza EoL", 0.0,1.0,0.5)
-
-    if file_eol and file_obj:
-        eol_img = Image.open(file_eol).convert("RGBA")
-        obj_img = Image.open(file_obj).convert("RGBA")
-        eol_img = eol_img.resize(obj_img.size)
-        blended = Image.blend(obj_img, eol_img, alpha)
-        st.image(blended, caption="Overlay EoL + Oggetto Finale", use_column_width=True)
-    else:
-        st.info("Carica entrambe le immagini per vedere l'overlay")
-
-###########################################
-# FUNZIONE: Dashboard
-###########################################
-def dashboard_phase():
-    st.subheader("Dashboard")
-    if st.session_state["df"] is None:
-        st.error("Nessun dataset caricato/generato.")
+        st.info("Il VAE risulta già addestrato con i parametri correnti.")
+        if st.button("Riallena VAE"):
+             st.session_state["vae_trained_on_eol"] = False
+             st.rerun()
+
+# --- Fase 5: Dashboard (resta simile) ---
+def show_dashboard():
+    st.header("📊 Dashboard Riepilogativa")
+    if 'data' not in st.session_state or st.session_state['data'] is None:
+        st.error("Nessun dataset disponibile. Prepara il dataset nella Fase 1.")
         return
-    df = st.session_state["df"]
-    st.write("**Info dataset**")
-    st.write(df.describe())
-
-    if "model" in st.session_state and st.session_state["model"] is not None:
-        st.write("**Modello**: RandomForest + pipeline (scaler). Se addestrato con logistic regression, stesso pipeline logic.")
-        # Non stai salvando metriche, potresti salvare accuracy e confusion matrix in session state
-        st.info("Per metrics dettagliate, vedi la fase Training.")
+
+    data = st.session_state['data']
+    st.subheader("Panoramica Dataset Elaborato")
+    total_samples = len(data)
+    class_counts = data['Target'].value_counts()
+    reuse_pct = (class_counts.get("Riutilizzo Funzionale", 0) / total_samples) * 100
+    upcycling_pct = (class_counts.get("Upcycling Creativo", 0) / total_samples) * 100
+
+    col1, col2, col3 = st.columns(3)
+    col1.metric("Campioni Totali", total_samples)
+    col2.metric("Previsti Riutilizzo Funzionale", f"{reuse_pct:.1f}%")
+    col3.metric("Previsti Upcycling Creativo", f"{upcycling_pct:.1f}%")
+
+    # Grafico a Torta Distribuzione Classi
+    if not class_counts.empty:
+        fig_pie, ax_pie = plt.subplots(figsize=(5, 3))
+        ax_pie.pie(class_counts, labels=class_counts.index, autopct='%1.1f%%', startangle=90, colors=['#66c2a5','#fc8d62']) # Colori esempio
+        ax_pie.axis('equal')
+        st.pyplot(fig_pie)
+
+    st.subheader("Performance Modelli ML (Step 1)")
+    if 'train_results' in st.session_state:
+        results_df = st.session_state['train_results']
+        avg_accuracy = results_df['Accuracy'].mean()
+        best_model_idx = results_df['Accuracy'].idxmax()
+        best_model_name = results_df.loc[best_model_idx]['Modello']
+        best_model_acc = results_df.loc[best_model_idx]['Accuracy']
+
+        col4, col5 = st.columns(2)
+        col4.metric("Accuratezza Media Modelli", f"{avg_accuracy:.3f}")
+        col5.metric(f"Miglior Modello: {best_model_name}", f"{best_model_acc:.3f}")
+        st.dataframe(results_df.style.format({'Accuracy': "{:.3f}", 'F1 Score': "{:.3f}"}))
+    else:
+        st.info("Addestra i modelli ML (Fase 2) per visualizzare le metriche di performance.")
+
+    st.subheader("Stato Modello VAE (Step 2)")
+    if st.session_state.get("vae_trained_on_eol", False) and st.session_state.get("vae") is not None:
+         vae = st.session_state["vae"]
+         st.success("Modello VAE addestrato.")
+         col_v1, col_v2 = st.columns(2)
+         col_v1.metric("Feature Input VAE", vae.fc1.in_features)
+         col_v2.metric("Dimensione Latente VAE", vae.fc21.out_features)
+    elif "vae" in st.session_state and st.session_state["vae"] is not None:
+         st.warning("Modello VAE inizializzato ma non addestrato.")
     else:
-        st.warning("Modello non addestrato. Niente metriche da mostrare.")
-
-
-###########################################
-# MAIN flow
-###########################################
-if menu=="Dataset":
-    dataset_phase()
-elif menu=="Training":
-    training_phase()
-elif menu=="Inferenza":
-    inference_phase()
-elif menu=="Generative Reuse (VAE)":
-    generative_phase()
-elif menu=="Overlay Estetico":
-    overlay_phase()
-elif menu=="Dashboard":
-    dashboard_phase()
+         st.info("Modello VAE non ancora inizializzato (visitare Fase 4).")
+
+
+# --- Fase 6: Guida (resta simile) ---
+def show_help():
+    st.header("ℹ️ Guida all'Uso")
+    st.markdown("""
+    **Workflow Applicazione:**
+
+    1.  **♻️ Dataset:**
+        * Genera dati sintetici o carica un tuo file CSV con le caratteristiche dei componenti EoL.
+        * Nella tab "Definisci Compatibilità & Target", imposta i parametri dimensionali target, le tolleranze e i pesi per lo score RUL/Margin.
+        * Il sistema elabora i dati, calcola la compatibilità dimensionale (`compat_dim`) e assegna la classe **"Riutilizzo Funzionale"** o **"Upcycling Creativo"** a ciascun campione.
+        * Visualizza l'anteprima, la distribuzione delle classi e scarica il dataset elaborato.
+
+    2.  **🤖 Addestramento Modelli ML (Step 1):**
+        * Addestra una serie di modelli di Machine Learning (Random Forest, Gradient Boosting, ecc.) per predire la classe ("Riutilizzo Funzionale" / "Upcycling Creativo") basandosi sulle feature elaborate.
+        * Visualizza le performance (Accuracy, F1 Score) e le matrici di confusione per ciascun modello.
+
+    3.  **🔮 Inferenza (Step 1 & 2):**
+        * Inserisci le caratteristiche dimensionali ed economiche di un **nuovo** componente EoL.
+        * Clicca "Esegui Predizione". Il sistema usa i modelli ML addestrati per predire la classe più probabile (aggregando i risultati).
+        * **Flusso Condizionale:**
+            * Se la predizione è **"Riutilizzo Funzionale"**, il processo termina qui per questo componente.
+            * Se la predizione è **"Upcycling Creativo"**, appare una nuova sezione che ti permette di usare il modello VAE (Generative AI) per **generare idee** di configurazioni geometriche alternative, basate sulla distribuzione appresa dai dati. (Assicurati di aver addestrato il VAE nella Fase 4!).
+
+    4.  **🧬 Training VAE (Step 2):**
+        * Questa fase serve ad addestrare il modello VAE (Generative AI) usando le **feature geometriche/fisiche** del dataset preparato nella Fase 1.
+        * Questo modello impara la "forma" tipica dei dati e può essere usato nella Fase di Inferenza per generare nuove idee quando viene predetto "Upcycling Creativo". **Devi addestrare il VAE qui prima di poter generare idee nella fase di Inferenza.**
+
+    5.  **📊 Dashboard:**
+        * Visualizza una sintesi dello stato del dataset, delle performance dei modelli ML e dello stato del modello VAE.
+
+    **Reset:** Usa il pulsante "Reset" nella sidebar per cancellare tutti i dati e i modelli in memoria e ricominciare.
+    """)
+
+# --- Funzione Reset ---
+def reset_app():
+    # Lista delle chiavi da cancellare o resettare
+    keys_to_clear = ['data', 'models', 'train_results', 'vae', 'vae_trained_on_eol', 'vae_scaler', 'target_params', 'score_params', 'data_source']
+    for key in keys_to_clear:
+        if key in st.session_state:
+            del st.session_state[key]
+    st.success("Stato dell'applicazione resettato.")
+    # Potrebbe essere utile fare st.rerun() qui per aggiornare subito la UI
+    st.rerun()
+
+##########################################
+# 5. MAIN FUNCTION (Flusso Principale App)
+##########################################
+def main():
+    st.sidebar.image("https://www.weeko.it/wp-content/uploads/2023/07/logo-weeko-esteso-1.png", width=200) # Logo esempio
+    st.sidebar.title("Menu Principale")
+
+    # Inizializza session_state se non esiste (prima esecuzione)
+    if 'data' not in st.session_state: st.session_state.data = None
+    if 'models' not in st.session_state: st.session_state.models = None
+    if 'vae' not in st.session_state: st.session_state.vae = None
+    if 'vae_trained_on_eol' not in st.session_state: st.session_state.vae_trained_on_eol = False
+    if 'vae_scaler' not in st.session_state: st.session_state.vae_scaler = None
+    if 'target_params' not in st.session_state: st.session_state.target_params = {}
+    if 'score_params' not in st.session_state: st.session_state.score_params = {}
+    if 'train_results' not in st.session_state: st.session_state.train_results = None
+
+
+    # Menu Sidebar con le fasi corrette
+    phase = st.sidebar.radio(
+        "Seleziona fase:",
+        ["♻️ Dataset", "🤖 Addestramento ML (Step 1)", "🔮 Inferenza (Step 1 & 2)", "🧬 Training VAE (Step 2)", "📊 Dashboard", "ℹ️ Guida"],
+        key="main_menu"
+    )
+
+    # Pulsante Reset
+    st.sidebar.markdown("---")
+    st.sidebar.button("⚠️ Reset Applicazione", on_click=reset_app, type="primary")
+
+    # Esecuzione fase selezionata
+    if phase == "♻️ Dataset":
+        prepare_dataset() # Questa funzione ora salva i dati in st.session_state.data
+    elif phase == "🤖 Addestramento ML (Step 1)":
+        # Passiamo i dati dalla sessione
+        train_models(st.session_state.get('data'))
+    elif phase == "🔮 Inferenza (Step 1 & 2)":
+        # Controlla se i modelli ML e i dati esistono
+        if st.session_state.get('models') is None or st.session_state.get('data') is None:
+            st.error("Errore: Devi prima preparare il Dataset (Fase 1) e addestrare i Modelli ML (Fase 2).")
+        else:
+            # Passa i modelli e le statistiche del dataset (per i default nell'input form)
+            model_inference(st.session_state['models'], st.session_state['data'])
+    elif phase == "🧬 Training VAE (Step 2)":
+        # Questa fase usa st.session_state.data internamente
+        vae_training_phase()
+    elif phase == "📊 Dashboard":
+        show_dashboard()
+    elif phase == "ℹ️ Guida":
+        show_help()
+
+if __name__ == "__main__":
+    main()