Update app.py

app.py

@@ -4,17 +4,17 @@ import numpy as np
 import seaborn as sns
 import matplotlib.pyplot as plt
 from statistics import mode, StatisticsError
-import io # Per gestione file upload
+import io
 
 # --- 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.preprocessing import StandardScaler, LabelEncoder
 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.svm import SVC
-from sklearn.neural_network import MLPClassifier # Usato nei dummy models
+from sklearn.neural_network import MLPClassifier
 
 # --- PyTorch (per VAE) ---
 import torch
@@ -23,7 +23,7 @@ import torch.nn.functional as F
 import torch.utils.data
 import random
 
-# --- Impostazioni Pagina Streamlit ---
+# Impostazioni generali Streamlit
 st.set_page_config(
     page_title="WEEKO - AI Reuse Analyzer",
     page_icon="♻️",
@@ -31,45 +31,49 @@ st.set_page_config(
 )
 
 ##########################################
-# 1. PLACEHOLDER / DUMMY MODELS (dal codice Zero Scarto)
+# 1) MODELLI ML (Zero Scarto Analyzer)
 ##########################################
+
 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)
+    """
+    Placeholder modello: in realtà è un MLP, 
+    ma finge di essere un TabTransformer
+    """
+    def __init__(self, input_dim=8):
+        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)
+        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])
 
-
 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)
+    """
+    Placeholder modello: in realtà è un MLP, 
+    ma finge di essere un SAINT
+    """
+    def __init__(self, input_dim=8):
+        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'):
+        if hasattr(self.clf, 'predict_proba'):
             return self.clf.predict_proba(X)
-         else:
+        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])
+            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),
@@ -80,17 +84,15 @@ MODELS = {
 }
 
 ##########################################
-# 2. DEFINIZIONE MODELLO VAE (Step 2 - Generative)
+# 2) VAE per generative reuse (Fase 2)
 ##########################################
+
 class MiniVAE(nn.Module):
-    # input_dim: numero di feature geometriche/fisiche usate dal VAE
     def __init__(self, input_dim=5, latent_dim=2):
         super().__init__()
-        # 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.fc21 = nn.Linear(32, latent_dim)
+        self.fc22 = nn.Linear(32, latent_dim)
         self.fc3 = nn.Linear(latent_dim, 32)
         self.fc4 = nn.Linear(32, input_dim)
 
@@ -113,710 +115,562 @@ class MiniVAE(nn.Module):
         recon = self.decode(z)
         return recon, mu, logvar
 
-# Loss function per VAE
 def vae_loss(recon_x, x, mu, logvar):
     recon_loss = F.mse_loss(recon_x, x, reduction='sum')
     kld = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
     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)
+# Feature sets
 ##########################################
-# 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
+DEFAULT_FEATURES_STEP1 = ['length','width','RUL','margin','shape','weight','thickness']
+ML_FEATURES_STEP1 = ['length','width','shape_code','weight','thickness','RUL','margin','compat_dim']
+VAE_FEATURES_STEP2 = ['length','width','weight','thickness','shape_code']
 
+##########################################
+# Mappatura forma -> shape_code
+##########################################
+SHAPE_MAPPING = {
+    'axisymmetric': 0,
+    'sheet_metal': 1,
+    'alloy_plate': 2,
+    'complex_plastic': 3
+}
 
+##########################################
+# Generazione dataset sintetico
+##########################################
 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
+    length = np.clip(np.random.normal(100, 20, n_samples), 50, 250)
+    width  = np.clip(np.random.normal(50, 15, n_samples), 20, 150)
+    RUL    = np.clip(np.random.normal(500, 250, n_samples), 0, 1000).astype(int)
+    margin = np.clip(np.random.normal(150,150,n_samples), -200,600).astype(int)
+    shapes = np.random.choice(['axisymmetric','sheet_metal','alloy_plate','complex_plastic'],
+                              size=n_samples, p=[0.4,0.3,0.15,0.15])
+    weight = np.clip(np.random.normal(80,30,n_samples), 10, 250)
+    thickness = np.clip(np.random.normal(8,4,n_samples), 0.5, 30)
 
     return pd.DataFrame({
-        'length': length, 'width': width, 'RUL': RUL, 'margin': margin,
-        'shape': shapes, 'weight': weight, 'thickness': thickness
+        '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,
+##########################################
+# dimension_match + assegnazione classe
+##########################################
+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)
+    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
     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:
+    rul_norm = row['RUL']/1000.0
+    margin_norm = (row['margin']+200)/800.0
+    score = alpha*rul_norm + beta*margin_norm
+    if row['compat_dim']==1 and score>=threshold_score:
         return "Riutilizzo Funzionale"
     else:
-        # 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
 ##########################################
-
-# --- 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
+    tab1, tab2 = st.tabs(["Carica/Genera Dati", "Definisci Compatibilità & Target"])
+    data = None
     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")
+        data_option = st.radio("Fonte Dati", ["Genera dati sintetici","Carica CSV"], horizontal=True)
+        if data_option=="Genera dati sintetici":
+            n_samples=st.slider("Numero di campioni",100,2000,500,step=50)
             if st.button("Genera Dati"):
-                data = generate_synthetic_data(n_samples=n_samples)
-                st.session_state.data_source = "generated" # Salva la fonte
+                data=generate_synthetic_data(n_samples=n_samples)
+                st.session_state.data_source="generated"
         else:
-            uploaded_file = st.file_uploader("Carica un file CSV", type=["csv"], key="csv_up")
-            if uploaded_file:
+            file=st.file_uploader("Carica CSV con le feature minime", type=["csv"])
+            if file:
                 try:
-                    data = pd.read_csv(uploaded_file)
-                    # Controllo colonne minime
+                    data=pd.read_csv(file)
                     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
+                        st.error(f"Il CSV deve contenere almeno: {DEFAULT_FEATURES_STEP1}")
+                        data=None
                     else:
-                         st.session_state.data_source = "uploaded" # Salva la fonte
+                        st.session_state.data_source="uploaded"
                 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'.")
+                    st.error(f"Errore lettura CSV: {e}")
+                    data=None
 
-    # 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 tab2:
+            st.subheader("Parametri di Compatibilità")
+            c1,c2=st.columns(2)
+            with c1:
+                t_len=st.number_input("Lunghezza target (mm)",50.0,250.0,100.0,step=1.0)
+                t_wid=st.number_input("Larghezza target (mm)",20.0,150.0,50.0,step=1.0)
+                t_shape=st.selectbox("Forma target", list(SHAPE_MAPPING.keys()), index=0)
+            with c2:
+                t_weight=st.number_input("Peso target (kg)",10.0,250.0,80.0,step=1.0)
+                t_thick=st.number_input("Spessore target (mm)",0.5,30.0,8.0,step=0.5)
+
+            st.markdown("**Tolleranze**")
+            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")
+                tol_len=st.slider("Tolleranza lunghezza ±",0.0,20.0,5.0,step=0.5)
+                tol_wid=st.slider("Tolleranza larghezza ±",0.0,15.0,3.0,step=0.5)
             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
+                tol_we=st.slider("Tolleranza peso ±",0.0,30.0,10.0,step=1.0)
+                tol_th=st.slider("Tolleranza spessore ±",0.0,5.0,1.0,step=0.1)
+
+            st.markdown("**Score RUL & Margin**")
+            thr_score=st.slider("Soglia minima score",0.0,1.0,0.5,step=0.05)
+            alpha=st.slider("Peso RUL (α)",0.0,1.0,0.5,step=0.05)
+            beta=st.slider("Peso Margin (β)",0.0,1.0,0.5,step=0.05)
+
+            # Codifica shape
+            data['shape_code']=data['shape'].map(SHAPE_MAPPING).fillna(-1).astype(int)
+
+            # compat_dim
+            data['compat_dim'] = data.apply(
+                lambda row: dimension_match(row, 
+                                            target_length=t_len, target_width=t_wid, target_shape=t_shape,
+                                            target_weight=t_weight, target_thickness=t_thick,
+                                            tol_len=tol_len, tol_wid=tol_wid,
+                                            tol_weight=tol_we, tol_thickness=tol_th),
+                axis=1
+            )
+
+            # Assegna Target
+            data['Target']=data.apply(lambda row: assign_class(row,
+                                                               threshold_score=thr_score,
+                                                               alpha=alpha, beta=beta),
+                                      axis=1)
+
+            st.session_state.target_params={
+                "target_length": t_len,
+                "target_width": t_wid,
+                "target_shape": t_shape,
+                "target_weight": t_weight,
+                "target_thickness": t_thick,
+                "tol_len": tol_len,
+                "tol_wid": tol_wid,
+                "tol_weight": tol_we,
+                "tol_thickness": tol_th
+            }
+            st.session_state.score_params={
+                "threshold_score": thr_score,
+                "alpha": alpha,
+                "beta": beta
             }
-            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())
+            st.write("Distribuzione Classi:", 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) ---
+                fig,ax=plt.subplots(figsize=(8,6))
+                sns.heatmap(numeric_cols.corr(), annot=True, cmap='viridis', fmt=".2f", ax=ax)
+                st.pyplot(fig)
+
+            st.session_state.data=data
+            csv=data.to_csv(index=False).encode('utf-8')
+            st.download_button("Scarica Dataset Elaborato CSV", csv, "dataset_processed.csv")
+
+#######################################
+#  Fase 2: Training Modelli ML
+#######################################
 def train_models(data):
-    st.header("🤖 2. Addestramento Modelli Classificazione (Step 1)")
+    st.header("🤖 2. Addestramento ML (Riutilizzo vs Upcycling)")
     if data is None:
-        st.error("Dataset non disponibile. Preparalo nella Fase 1.")
-        return None
+        st.error("Nessun dataset elaborato. Torna alla Fase 1.")
+        return
     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'.")
+        st.error("Colonna 'Target' assente. Verifica la Fase 1.")
+        return
 
-    # 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}")
+    # X,y
+    features_to_use=[f for f in ML_FEATURES_STEP1 if f in data.columns]
     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")
+        st.error("Nessuna feature valida per l'addestramento ML.")
+        return
+
+    X=data[features_to_use].copy()
+    y=data['Target'].map({"Riutilizzo Funzionale":0, "Upcycling Creativo":1})
+
+    # Se c'è una sola classe
+    if len(y.unique())<2:
+        st.error("Il dataset contiene una sola classe. Aggiusta i parametri in Fase 1.")
+        return
+
+    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"Dati: {len(X_train)} train, {len(X_test)} test.")
+    tune_rf=st.checkbox("Ottimizza RandomForest (GridSearchCV)", value=False)
+
+    trained_pipelines={}
+    results=[]
+    for name,model in MODELS.items():
+        st.subheader(f"Modello: {name}")
+        from sklearn.pipeline import Pipeline
+        pipe=Pipeline([
+            ("scaler",StandardScaler()),
+            ("clf",model)
+        ])
+        try:
+            if tune_rf and name=="Random Forest":
+                st.write("GridSearch per RandomForest...")
+                param_grid={
+                    'clf__n_estimators':[50,100],
+                    'clf__max_depth':[None,10,15]
+                }
+                grid=GridSearchCV(pipe, param_grid, cv=2, scoring='accuracy', n_jobs=-1)
+                grid.fit(X_train,y_train)
+                best_model=grid.best_estimator_
+                st.write(f"Migliori parametri: {grid.best_params_}")
+                y_pred=best_model.predict(X_test)
+                pipe_to_use=best_model
+            else:
+                pipe.fit(X_train,y_train)
+                y_pred=pipe.predict(X_test)
+                pipe_to_use=pipe
+
+            acc=accuracy_score(y_test,y_pred)
+            f1=f1_score(y_test,y_pred,average='weighted')
+            results.append({"Modello":name,"Accuracy":acc,"F1 Score":f1})
+            trained_pipelines[name]=pipe_to_use
+
+            cm=confusion_matrix(y_test,y_pred)
+            fig,ax=plt.subplots()
+            sns.heatmap(cm,annot=True,fmt='d',ax=ax,cmap="Greens")
+            plt.xlabel("Pred")
+            plt.ylabel("True")
+            st.pyplot(fig)
+
+            st.metric("Accuracy",f"{acc:.3f}")
+            st.metric("F1 Score",f"{f1:.3f}")
+
+        except Exception as e:
+            st.error(f"Errore addestramento {name}: {e}")
+
     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
+        results_df=pd.DataFrame(results).sort_values(by="Accuracy",ascending=False)
+        st.dataframe(results_df)
+        st.session_state.train_results=results_df
+        st.session_state.models=trained_pipelines
     else:
-        st.error("Nessun modello è stato addestrato con successo.")
-        st.session_state.models = None
-        return None
+        st.error("Nessun modello addestrato con successo.")
+        st.session_state.models=None
+
+#######################################
+# Fase 3: Inferenza + Trigger Upcycling -> VAE
+#######################################
+def model_inference(trained_pipelines, data):
+    st.header("🔮 3. Inferenza: Step 1 (Riutilizzo vs Upcycling) & Step 2 (VAE Upcycling)")
 
-# --- 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).")
+        st.error("Prima addestra i modelli (Fase 2).")
+        return
+    if data is None:
+        st.error("Nessun dataset disponibile in session. Torna a Fase 1.")
+        return
+    if 'target_params' not in st.session_state or 'score_params' not in st.session_state:
+        st.error("Parametri target non definiti. Completa la Fase 1.")
         return
-    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
+
+    data_stats=data # useremo mediane per default
+
+    with st.form(key="inference_form"):
+        st.subheader("Inserisci Caratteristiche EoL")
+        c1,c2,c3=st.columns(3)
+        with c1:
+            length=st.number_input("Lunghezza (mm)",0.0,300.0,float(data_stats['length'].median()),step=1.0)
+            width=st.number_input("Larghezza (mm)",0.0,200.0,float(data_stats['width'].median()),step=1.0)
+            shape_name=st.selectbox("Forma", list(SHAPE_MAPPING.keys()))
+        with c2:
+            weight=st.number_input("Peso (kg)",0.0,300.0,float(data_stats['weight'].median()),step=1.0)
+            thickness=st.number_input("Spessore (mm)",0.0,50.0,float(data_stats['thickness'].median()),step=0.5)
+            RUL=st.number_input("RUL (0-1000)",0,1000,int(data_stats['RUL'].median()))
+        with c3:
+            val_merc=st.number_input("Valore Mercato (€)",0.0,1e5, float(data_stats['margin'].median()+200),step=10.0)
+            costo_rip=st.number_input("Costo Riparazione (€)",0.0,1e5,50.0,step=10.0)
+
+        submitted=st.form_submit_button("Predizione Step 1")
+
+    if submitted:
+        margin= val_merc - costo_rip
+        shape_code= SHAPE_MAPPING.get(shape_name, -1)
+
+        # Prepariamo input per dimension_match
+        input_dict={
+            "length": length,
+            "width": width,
+            "shape": shape_name,
+            "weight": weight,
+            "thickness": thickness,
+            "RUL": RUL,
+            "margin": margin
         }
-        input_df_temp = pd.DataFrame([input_dict_ml])
+        temp_df=pd.DataFrame([input_dict])
 
-        # 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)
+        # Calcola compat_dim
+        tparams=st.session_state.target_params
+        temp_df['compat_dim']=temp_df.apply(lambda r: dimension_match(r,**tparams), 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'])
+        # Rimuovi shape testo e aggiungi shape_code
+        temp_df['shape_code']=shape_code
+        temp_df_ml= temp_df.drop(columns=['shape'])
 
-        # Assicura che le colonne siano nell'ordine atteso dai modelli (basato su ML_FEATURES_STEP1)
+        # Assicuriamoci di avere ML_FEATURES_STEP1
         try:
-            input_df_ml_ordered = input_df_ml[ML_FEATURES_STEP1]
+            X_inference=temp_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}")
+            st.error(f"Mancano colonne per ML: {e}")
+            return
+
+        # Predici con tutti i modelli
+        model_predictions=[]
+        details=[]
+        for name,pipe in trained_pipelines.items():
+            try:
+                pred_num=pipe.predict(X_inference)[0]
+                proba=pipe.predict_proba(X_inference)[0]
+                details.append({
+                    "Modello": name,
+                    "Pred (0=Riuso,1=Upcycling)":pred_num,
+                    "Prob. Riuso": proba[0],
+                    "Prob. Upcycling": proba[1]
+                })
+                model_predictions.append(pred_num)
+            except Exception as e:
+                st.error(f"Errore predizione {name}: {e}")
 
-        # --- Aggregazione Risultati ---
         if not model_predictions:
-            st.error("Nessun modello ha prodotto una predizione valida.")
+            st.error("Nessun modello ha prodotto predizioni.")
             return
 
+        # Aggrega con mode
         try:
-            # Usa la moda (predizione più frequente)
-            aggregated_pred_num = mode(model_predictions)
+            final_pred=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":
+            # Se c'è pareggio, media prob upcycling
+            avg_prob_upc=np.mean([d["Prob. Upcycling"] for d in details])
+            final_pred=1 if avg_prob_upc>=0.5 else 0
+
+        final_label="Riutilizzo Funzionale" if final_pred==0 else "Upcycling Creativo"
+        st.subheader("Risultato Aggregato (Step 1)")
+        st.metric("Classe Predetta:", final_label)
+
+        with st.expander("Dettagli Singoli Modelli"):
+            df_details=pd.DataFrame(details)
+            df_details["Prob. Riuso"]=df_details["Prob. Riuso"].apply(lambda x:f"{x:.1%}")
+            df_details["Prob. Upcycling"]=df_details["Prob. Upcycling"].apply(lambda x:f"{x:.1%}")
+            st.dataframe(df_details)
+
+        # Se risulta "Upcycling Creativo", allora Step 2 (VAE)
+        if final_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.")
+            st.subheader("Upcycling Creativo → Esplorazione Generativa (VAE)")
 
-            # 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.")
+            if not st.session_state.get("vae_trained_on_eol",False):
+                st.error("VAE non addestrato. Vai alla fase '🧬 Training VAE (Step 2)' prima.")
             else:
-                vae_model = st.session_state.get("vae")
-                vae_scaler = st.session_state.get("vae_scaler")
+                vae_model=st.session_state.get("vae", None)
+                vae_scaler=st.session_state.get("vae_scaler", None)
                 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.")
+                    st.error("Errore: VAE o scaler non disponibile in session.")
                 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) ---
+                    n_ideas=st.number_input("Quante idee generare con VAE?",1,10,3)
+                    if st.button("Genera Idee Upcycling"):
+                        vae_model.eval()
+                        with torch.no_grad():
+                            z_dim=vae_model.fc21.out_features
+                            z=torch.randn(n_ideas,z_dim)
+                            recon=vae_model.decode(z)
+                        arr=recon.numpy()
+                        # Proviamo a invertire lo scaler
+                        try:
+                            arr_inv=vae_scaler.inverse_transform(arr)
+                            feat_names=vae_scaler.feature_names_in_
+                            df_gen=pd.DataFrame(arr_inv, columns=feat_names)
+
+                            # Se c'è shape_code, arrotondiamolo
+                            if 'shape_code' in df_gen.columns:
+                                df_gen['shape_code']=df_gen['shape_code'].round().astype(int)
+                                inv_shape_map={v:k for k,v in SHAPE_MAPPING.items()}
+                                df_gen['shape']=df_gen['shape_code'].map(inv_shape_map).fillna('unknown')
+                            st.write("**Idee Generative** (dimensioni, spessore, shape..)")
+                            st.dataframe(df_gen.round(2))
+                        except Exception as e:
+                            st.error(f"Errore decoding VAE: {e}")
+        else:
+            st.success("Compatibilità => Riutilizzo Funzionale. Nessun passaggio generativo necessario.")
+
+#######################################
+# Fase 4: Training VAE
+#######################################
 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.")
+    st.header("🧬 Training VAE - Step 2")
 
     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.")
+        st.error("Non c'è un dataset elaborato. Torna in Fase 1.")
         return
 
-    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.")
+    data=st.session_state['data']
+    # Verifica se abbiamo le feature per il VAE
+    feats= [f for f in VAE_FEATURES_STEP2 if f in data.columns]
+    if not feats:
+        st.error(f"Il dataset non contiene feature minime per VAE: {VAE_FEATURES_STEP2}")
         return
+    st.write(f"**Il VAE userà le feature**: {feats}")
+
+    # Parametri
+    lat_dim=st.slider("Dimensione latente VAE",2,10,3)
+    ep=st.number_input("Epochs",10,300,50)
+    lr=st.number_input("Learning Rate",1e-5,1e-2,1e-3,format="%e")
+    bs=st.selectbox("Batch Size",[16,32,64,128],index=1)
 
-    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"]
-
-    # --- Bottone e Logica di Training ---
-    if not st.session_state.get("vae_trained_on_eol", False):
-        st.warning("VAE non ancora addestrato.")
+    if not st.session_state.get("vae_trained_on_eol",False):
+        st.warning("VAE non addestrato su EoL. Clicca il bottone per avviare.")
         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']))
+            st.session_state["vae"] = MiniVAE(input_dim=len(feats), latent_dim=lat_dim)
+            vae=st.session_state["vae"]
+            # Sostituisci eventuali NaN
+            X_vae=data[feats].copy()
+            for c in X_vae.columns:
+                if X_vae[c].isnull().any():
+                    X_vae[c].fillna(X_vae[c].median(), inplace=True)
+
+            # Scalatura
+            from sklearn.preprocessing import StandardScaler
+            scaler=StandardScaler()
+            X_scaled=scaler.fit_transform(X_vae)
+            st.session_state["vae_scaler"]=scaler
+
+            dataset=torch.utils.data.TensorDataset(torch.tensor(X_scaled,dtype=torch.float32))
+            loader=torch.utils.data.DataLoader(dataset,batch_size=bs,shuffle=True)
+            optimizer=torch.optim.Adam(vae.parameters(),lr=lr)
+
+            losses=[]
+            vae.train()
+            for epoch in range(int(ep)):
+                epoch_loss=0.0
+                for (batch,) in loader:
+                    optimizer.zero_grad()
+                    recon,mu,logvar=vae(batch)
+                    loss=vae_loss(recon,batch,mu,logvar)
+                    loss.backward()
+                    optimizer.step()
+                    epoch_loss+=loss.item()
+                avg_l=epoch_loss/len(dataset)
+                losses.append(avg_l)
+                st.progress((epoch+1)/ep)
+            st.session_state["vae_trained_on_eol"]=True
+            st.success(f"Training VAE completato. Loss finale ~ {avg_l:.2f}")
+            st.line_chart(losses)
     else:
-        st.info("Il VAE risulta già addestrato con i parametri correnti.")
+        st.success("VAE risulta già addestrato su EoL. Se vuoi rifarlo, premi 'Riallena' qui sotto.")
         if st.button("Riallena VAE"):
-             st.session_state["vae_trained_on_eol"] = False
-             st.rerun()
+            st.session_state["vae_trained_on_eol"]=False
+            st.rerun()
 
-# --- Fase 5: Dashboard (resta simile) ---
+#######################################
+# Fase 5: Dashboard
+#######################################
 def show_dashboard():
-    st.header("📊 Dashboard Riepilogativa")
+    st.header("📊 Dashboard")
     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.")
+        st.error("No dataset. Torna alla Fase 1.")
         return
-
-    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.")
+    data=st.session_state['data']
+    st.subheader("Distribuzione Classi EoL")
+    st.write(data['Target'].value_counts())
+
+    if 'train_results' in st.session_state and st.session_state['train_results'] is not None:
+        st.subheader("Risultati Modelli ML")
+        df_res=st.session_state['train_results']
+        st.dataframe(df_res)
     else:
-         st.info("Modello VAE non ancora inizializzato (visitare Fase 4).")
+        st.info("Modelli ML non addestrati o nessun risultato salvato.")
 
+    st.subheader("Stato VAE")
+    if st.session_state.get("vae_trained_on_eol",False):
+        st.success("VAE Addestrato")
+    else:
+        st.warning("VAE non addestrato o parametri cambiati.")
 
-# --- Fase 6: Guida (resta simile) ---
+#######################################
+# Fase 6: Guida
+#######################################
 def show_help():
-    st.header("ℹ️ Guida all'Uso")
+    st.header("ℹ️ Guida")
     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.
+    **Flusso a due fasi**:
+    
+    1. **Fase 1: Dataset**  
+       - Genera o carica dati su componenti EoL (dimensioni, RUL, margin, shape...)  
+       - Definisci parametri di compatibilità dimensionale e calcolo score RUL+margin. Il sistema assegna 'Riutilizzo Funzionale' o 'Upcycling Creativo'.  
+    2. **Fase 2: Addestramento ML**  
+       - Addestra modelli (RF, GB, SVM...) per predire la stessa classe su dati nuovi.  
+    3. **Fase 3: Inferenza**  
+       - Inserisci un nuovo pezzo EoL. Il sistema predice se 'Riutilizzo Funzionale' o 'Upcycling Creativo'.  
+       - Se 'Upcycling Creativo', appare la possibilità di generare idee con VAE (Fase successiva).  
+    4. **Fase 4: Training VAE**  
+       - Allena un VAE sulle feature geometriche per generare configurazioni fittizie (design space).  
+    5. **Fase 3 (continuazione)**  
+       - Se la previsione era 'Upcycling Creativo' e il VAE è addestrato, si possono generare soluzioni creative.  
+    6. **Fase 5: Dashboard**  
+       - Visualizza statistiche, performance modelli, ecc.  
     """)
 
-# --- Funzione Reset ---
+#######################################
+# 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)
-##########################################
+    keys=[
+        'data','models','train_results','vae','vae_trained_on_eol',
+        'vae_scaler','target_params','score_params','data_source'
+    ]
+    for k in keys:
+        if k in st.session_state:
+            del st.session_state[k]
+    st.success("Reset completato.")
+    st.experimental_rerun()
+
+#######################################
+# MAIN
+#######################################
 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).")
+    step=st.sidebar.radio("Fasi", [
+        "♻️ Dataset",
+        "🤖 Addestramento ML (Step 1)",
+        "🔮 Inferenza (Step 1 & 2)",
+        "🧬 Training VAE (Step 2)",
+        "📊 Dashboard",
+        "ℹ️ Guida"
+    ])
+    st.sidebar.button("Reset App", on_click=reset_app)
+
+    if step=="♻️ Dataset":
+        prepare_dataset()
+    elif step=="🤖 Addestramento ML (Step 1)":
+        train_models(st.session_state.get('data',None))
+    elif step=="🔮 Inferenza (Step 1 & 2)":
+        if 'models' not in st.session_state or st.session_state['models'] is None:
+            st.error("Non hai ancora addestrato 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
+            model_inference(st.session_state['models'], st.session_state.get('data',None))
+    elif step=="🧬 Training VAE (Step 2)":
         vae_training_phase()
-    elif phase == "📊 Dashboard":
+    elif step=="📊 Dashboard":
         show_dashboard()
-    elif phase == "ℹ️ Guida":
+    elif step=="ℹ️ Guida":
         show_help()
 
-if __name__ == "__main__":
-    main()
+if __name__=="__main__":
+    main()