Update app.py

app.py

@@ -5,669 +5,448 @@ import seaborn as sns
 import matplotlib.pyplot as plt
 from statistics import mode, StatisticsError
 
-# Scikit-learn
-from sklearn.model_selection import train_test_split, GridSearchCV
+# scikit-learn
+from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import StandardScaler
 from sklearn.pipeline import Pipeline
 from sklearn.metrics import confusion_matrix, accuracy_score, f1_score
-from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+from sklearn.ensemble import RandomForestClassifier
 from sklearn.linear_model import LogisticRegression
 from sklearn.svm import SVC
 from sklearn.neural_network import MLPClassifier
 
-# PyTorch
+# torch
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
 
-# Transformers per la GenAI testuale
+# HF Transformers per generazione testo
 from transformers import pipeline
 
-############### STREAMLIT SETUP ###############
-st.set_page_config(page_title="WEEKO - AI Reuse Analyzer",
-                   page_icon="♻️",
-                   layout="wide")
+#############################
+# STREAMLIT config
+#############################
+st.set_page_config(page_title="WEEKO – 4 Step Flow", layout="wide")
 
-############### MODELLI PLACEHOLDER ############
+#############################
+# DIZIONARIO MODELLI ML
+#############################
 class DummyTabTransformerClassifier:
-    """Finto modello: in realtà un MLP."""
     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)
+        self.clf = MLPClassifier(hidden_layer_sizes=(16,8), max_iter=100, random_state=42)
     def fit(self, X, y):
-        self.clf.fit(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:
-            preds = self.clf.predict(X)
+            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:
-    """Finto modello: in realtà un MLP."""
-    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'):
-            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])
-
-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()
+MODELS_ML = {
+    "RandomForest": RandomForestClassifier(random_state=42, n_estimators=100),
+    "LogisticRegression": LogisticRegression(random_state=42, max_iter=500),
+    "SVM": SVC(probability=True, random_state=42),
+    "TabTransformer(Dummy)": DummyTabTransformerClassifier()
 }
 
-############### VAE PER FASE 2 ###############
+#############################
+# VAE
+#############################
 class MiniVAE(nn.Module):
     def __init__(self, input_dim=5, latent_dim=2):
         super().__init__()
-        self.fc1 = nn.Linear(input_dim, 32)
-        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)
-
-    def encode(self, x):
-        h = F.relu(self.fc1(x))
+        self.fc1 = nn.Linear(input_dim,32)
+        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)
+    def encode(self,x):
+        h=F.relu(self.fc1(x))
         return self.fc21(h), self.fc22(h)
-
     def reparameterize(self, mu, logvar):
-        std = torch.exp(0.5 * logvar)
+        std = torch.exp(0.5*logvar)
         eps = torch.randn_like(std)
         return mu + eps*std
-
-    def decode(self, z):
-        h = F.relu(self.fc3(z))
+    def decode(self,z):
+        h=F.relu(self.fc3(z))
         return self.fc4(h)
-
-    def forward(self, x):
-        mu, logvar = self.encode(x)
-        z = self.reparameterize(mu, logvar)
-        recon = self.decode(z)
+    def forward(self,x):
+        mu,logvar=self.encode(x)
+        z=self.reparameterize(mu,logvar)
+        recon=self.decode(z)
         return recon, mu, logvar
 
-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
-
-############### Feature sets ###############
-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']
-
-############### SHAPE MAPPING ###############
-SHAPE_MAPPING = {
-    'axisymmetric':0,
-    'sheet_metal':1,
-    'alloy_plate':2,
-    'complex_plastic':3
-}
-
-############### GENERAZIONE DATI SINTETICI ###############
-def generate_synthetic_data(n_samples=300, seed=42):
-    np.random.seed(seed)
-    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(list(SHAPE_MAPPING.keys()), p=[0.4,0.3,0.2,0.1], size=n_samples)
-    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
-    })
-
-############### dimension_match + assign_class ###############
-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_thick  = abs(row['thickness']-target_thickness)<=tol_thickness
-    return 1 if (cond_length and cond_width and cond_shape and cond_weight and cond_thick) else 0
-
-def assign_class(row, threshold_score=0.5, alpha=0.5, beta=0.5):
-    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:
+def vae_loss(recon_x,x,mu,logvar):
+    mse = F.mse_loss(recon_x,x,reduction='sum')
+    kld = -0.5*torch.sum(1 + logvar - mu.pow(2)-logvar.exp())
+    return mse+kld
+
+#############################
+# UTILITY
+#############################
+SHAPE_MAPPING = {"axisymmetric":0,"sheet_metal":1,"alloy_plate":2,"complex_plastic":3}
+ML_FEATURES = ["length","width","shape_code","weight","thickness","RUL","margin","compat_dim"]
+VAE_FEATURES= ["length","width","weight","thickness","shape_code"]
+
+def dimension_match(r, target_len, target_wid, t_shape, t_w, t_th, tol_len, tol_wid, tol_we, tol_th):
+    c_len= abs(r["length"]-target_len)<=tol_len
+    c_wid= abs(r["width"]-target_wid)<=tol_wid
+    c_shp= (r["shape"]==t_shape)
+    c_wei= abs(r["weight"]-t_w)<= tol_we
+    c_thi= abs(r["thickness"]-t_th)<= tol_th
+    return 1 if (c_len and c_wid and c_shp and c_wei and c_thi) else 0
+
+def assign_class(r, thr_score=0.5, alpha=0.5, beta=0.5):
+    rul_norm = r["RUL"]/1000.0
+    margin_norm=(r["margin"]+200)/800.0
+    score= alpha*rul_norm + beta*margin_norm
+    if r["compat_dim"]==1 and score>=thr_score:
         return "Riutilizzo Funzionale"
     else:
         return "Upcycling Creativo"
 
-############### 1) PHASE: PREPARE DATASET ###############
-def prepare_dataset():
-    st.header("♻️ 1. Preparazione Dataset EoL")
-    tab1, tab2 = st.tabs(["Carica/Genera Dati","Definisci Compatibilità & Target"])
-    data = None
-    with tab1:
-        data_opt = st.radio("Fonte Dati", ["Genera dati sintetici","Carica CSV"], horizontal=True)
-        if data_opt=="Genera dati sintetici":
-            ns=st.slider("Campioni sintetici",100,2000,500,step=100)
-            if st.button("Genera Dati"):
-                data=generate_synthetic_data(n_samples=ns)
-                st.session_state.data_source="generated"
+#############################
+# Step 1: Dataset
+#############################
+def step1_dataset():
+    st.header("Step 1: Dataset")
+    # Genera / Carica
+    col1,col2 = st.columns(2)
+    with col1:
+        data_choice= st.radio("Fonte Dati",["Genera","Carica CSV"],horizontal=True)
+        data=None
+        if data_choice=="Genera":
+            n= st.slider("Campioni sintetici",100,2000,300,step=50)
+            if st.button("Genera"):
+                data= generate_synthetic_data(n_samples=n)
+                st.session_state["data_source"]="generated"
         else:
-            upfile=st.file_uploader("Carica CSV con feature minime", type=["csv"])
-            if upfile:
-                try:
-                    data=pd.read_csv(upfile)
-                    if not all(col in data.columns for col in DEFAULT_FEATURES_STEP1):
-                        st.error(f"Mancano colonne minime: {DEFAULT_FEATURES_STEP1}")
-                        data=None
-                    else:
-                        st.session_state.data_source="uploaded"
-                except Exception as e:
-                    st.error(f"Errore lettura CSV: {e}")
-                    data=None
-
-    if data is not None:
-        with tab2:
-            st.subheader("Parametri per Compatibilità")
-            c1,c2=st.columns(2)
-            with c1:
-                t_len=st.number_input("Lunghezza target (mm)",50.0,250.0,100.0)
-                t_wid=st.number_input("Larghezza target (mm)",20.0,150.0,50.0)
-                t_shape=st.selectbox("Forma target", list(SHAPE_MAPPING.keys()))
-            with c2:
-                t_weight=st.number_input("Peso target (kg)",10.0,300.0,80.0)
-                t_thick=st.number_input("Spessore target (mm)",0.5,50.0,8.0)
-
-            st.markdown("**Tolleranze**")
-            col_tol1,col_tol2=st.columns(2)
-            with col_tol1:
-                tol_len=st.slider("Tol. lunghezza ±",0.0,30.0,5.0,step=0.5)
-                tol_wid=st.slider("Tol. larghezza ±",0.0,20.0,3.0,step=0.5)
-            with col_tol2:
-                tol_we=st.slider("Tol. peso ±",0.0,50.0,10.0,step=1.0)
-                tol_th=st.slider("Tol. spessore ±",0.0,5.0,1.0,step=0.1)
-
-            st.markdown("**Score RUL & Margin**")
-            thr_sc=st.slider("Soglia 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)
-
-            # shape_code
-            data['shape_code']=data['shape'].map(SHAPE_MAPPING).fillna(-1).astype(int)
-            data['compat_dim']= data.apply(lambda r: dimension_match(r,
-                              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)
-
-            data['Target'] = data.apply(lambda r: assign_class(r,
-                              threshold_score=thr_sc,
-                              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_sc,
-                "alpha": alpha,
-                "beta": beta
-            }
-
-            st.dataframe(data.head(10))
-            st.write("Distribuzione classi:", data["Target"].value_counts())
-
-            numeric_cols=data.select_dtypes(include=np.number)
-            if not numeric_cols.empty:
-                fig,ax=plt.subplots()
-                sns.heatmap(numeric_cols.corr(), annot=True, cmap='viridis', fmt=".2f", ax=ax)
-                st.pyplot(fig)
-
-            st.session_state.data=data
-            csv_proc=data.to_csv(index=False).encode('utf-8')
-            st.download_button("Scarica Dataset Elaborato", csv_proc, "dataset_processed.csv")
-
-############### 2) PHASE: TRAIN MODELLI ML ############
-def train_models(data):
-    st.header("🤖 2. Addestramento ML (Riutilizzo vs Upcycling)")
+            upl=st.file_uploader("Carica CSV con col: length,width,RUL,margin,shape,weight,thickness",type=["csv"])
+            if upl:
+                df= pd.read_csv(upl)
+                needed_cols=["length","width","RUL","margin","shape","weight","thickness"]
+                if not all(c in df.columns for c in needed_cols):
+                    st.error("CSV non valido. Manca qualche colonna.")
+                else:
+                    data=df
+                    st.session_state["data_source"]="uploaded"
     if data is None:
-        st.error("Dataset non disponibile (Fase 1).")
-        return
-    if 'Target' not in data.columns:
-        st.error("Colonna 'Target' mancante. Rivedi la Fase 1.")
+        st.info("Genera o carica un dataset per proseguire.")
         return
 
-    features_to_use=[f for f in ML_FEATURES_STEP1 if f in data.columns]
-    if not features_to_use:
-        st.error("Nessuna feature per l'addestramento ML.")
+    # Param compat
+    with col2:
+        st.subheader("Param Compatibilità")
+        t_len= st.number_input("Lunghezza target (mm)",50.0,300.0,100.0)
+        t_wid= st.number_input("Larghezza target (mm)",20.0,200.0,50.0)
+        t_shp= st.selectbox("Forma target", list(SHAPE_MAPPING.keys()))
+        t_we = st.number_input("Peso target (kg)",5.0,300.0,80.0)
+        t_th = st.number_input("Spessore target (mm)",0.5,50.0,8.0)
+        tol_len = st.slider("Tol len ±",0.0,30.0,5.0)
+        tol_wid = st.slider("Tol wid ±",0.0,20.0,3.0)
+        tol_wei = st.slider("Tol weight ±",0.0,50.0,10.0)
+        tol_thi = st.slider("Tol thick ±",0.0,5.0,1.0)
+        st.markdown("**Score RUL & margin**")
+        thr= st.slider("Soglia score",0.0,1.0,0.5)
+        alpha= st.slider("Peso RUL(α)",0.0,1.0,0.5)
+        beta= st.slider("Peso Margin(β)",0.0,1.0,0.5)
+
+    # Prepara dataset
+    data['shape_code']= data['shape'].map(SHAPE_MAPPING).fillna(-1).astype(int)
+    data['compat_dim']= data.apply(lambda r: dimension_match(r,t_len,t_wid,t_shp,t_we,t_th,tol_len,tol_wid,tol_wei,tol_thi), axis=1)
+    data['Target']    = data.apply(lambda r: assign_class(r,thr_score=thr,alpha=alpha,beta=beta), axis=1)
+
+    st.dataframe(data.head(10))
+    st.write("Distribuzione classi:", data["Target"].value_counts())
+
+    st.session_state["data"] = data
+    st.session_state["params_dim"]={
+        "target_len": t_len, "target_wid": t_wid,
+        "target_shp": t_shp, "target_we": t_we, "target_th": t_th,
+        "tol_len": tol_len,"tol_wid": tol_wid,"tol_wei":tol_wei,"tol_thi":tol_thi,
+        "thr_score":thr,"alpha":alpha,"beta":beta
+    }
+    csv_data= data.to_csv(index=False).encode('utf-8')
+    st.download_button("Scarica dataset elaborato",csv_data,"dataset_processed.csv","text/csv")
+
+#############################
+# Step 2: Addestramento ML
+#############################
+def step2_trainML():
+    st.header("Step 2: Addestramento ML (Riutilizzo vs Upcycling)")
+    data= st.session_state.get("data",None)
+    if data is None:
+        st.error("Prima prepara dataset in Step 1.")
+        return
+    if "Target" not in data.columns:
+        st.error("Colonna 'Target' mancante. Rivedi step 1.")
         return
 
-    X = data[features_to_use].copy()
-    y = data['Target'].map({"Riutilizzo Funzionale":0,"Upcycling Creativo":1})
+    features_ml=[f for f in ML_FEATURES if f in data.columns]
+    if not features_ml:
+        st.error(f"Mancano feature minime per ML: {ML_FEATURES}")
+        return
+    X= data[features_ml].copy()
+    y= data["Target"].map({"Riutilizzo Funzionale":0,"Upcycling Creativo":1})
     if len(y.unique())<2:
         st.error("Il dataset ha una sola classe. Non si può addestrare.")
         return
-    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.25,random_state=42,stratify=y)
+    from sklearn.model_selection import train_test_split
+    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"Train={len(X_train)}, Test={len(X_test)}")
 
-    tune_rf= st.checkbox("Ottimizza RandomForest (GridSearchCV)",False)
-    trained_pipelines={}
+    # Addestra
+    trained_pipes={}
     results=[]
-
-    for name,model in MODELS.items():
-        st.subheader(f"Modello: {name}")
+    for nome, model in MODELS_ML.items():
+        st.subheader(f"Modello: {nome}")
         from sklearn.pipeline import Pipeline
-        pipe=Pipeline([
-            ("scaler",StandardScaler()),
+        pipe= Pipeline([
+            ("scaler", StandardScaler()),
             ("clf",model)
         ])
         try:
-            if tune_rf and name=="Random Forest":
-                st.write("Esecuzione GridSearchCV su RandomForest...")
-                param_grid={
-                    'clf__n_estimators':[50,100],
-                    'clf__max_depth':[None,10],
-                }
-                from sklearn.model_selection import GridSearchCV
-                grid=GridSearchCV(pipe,param_grid,cv=2,scoring='accuracy',n_jobs=-1)
-                grid.fit(X_train,y_train)
-                best_est=grid.best_estimator_
-                st.write(f"Migliori parametri: {grid.best_params_}")
-                y_pred=best_est.predict(X_test)
-                pipe_to_use=best_est
-            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',cmap="Greens",ax=ax)
+            pipe.fit(X_train,y_train)
+            y_pred= pipe.predict(X_test)
+            acc= accuracy_score(y_test,y_pred)
+            f1= f1_score(y_test,y_pred,average='weighted')
+            results.append({"Modello":nome,"Accuracy":acc,"F1 Score":f1})
+            trained_pipes[nome]= pipe
+
+            cm= confusion_matrix(y_test,y_pred)
+            fig, ax= plt.subplots()
+            sns.heatmap(cm, annot=True, fmt='d', cmap="Greens", ax=ax)
             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}")
+            st.error(f"Errore addestramento {nome}: {e}")
 
     if results:
-        df_res=pd.DataFrame(results).sort_values(by="Accuracy",ascending=False)
-        st.dataframe(df_res)
-        st.session_state.train_results=df_res
-        st.session_state.models=trained_pipelines
+        df_r= pd.DataFrame(results).sort_values(by="Accuracy",ascending=False)
+        st.dataframe(df_r)
+        st.session_state["models"]= trained_pipes
+        st.session_state["ml_results"]= df_r
     else:
         st.error("Nessun modello addestrato con successo.")
-        st.session_state.models=None
+        st.session_state["models"]=None
 
-############### 3) PHASE: INFERE ############
-def model_inference(trained_pipelines, data):
-    st.header("🔮 3. Inferenza: Step 1 & Step 2 (VAE + GenAI)")
+#############################
+# Step 2B: Training VAE
+#############################
+def step2b_trainVAE():
+    st.header("Step 2B: Training VAE (per Upcycling)")
 
-    if not trained_pipelines:
-        st.error("Prima addestra i modelli ML (Fase 2).")
-        return
+    data=st.session_state.get("data",None)
     if data is None:
-        st.error("Nessun dataset (Fase 1).")
+        st.error("Prima prepara dataset in Step 1.")
         return
-
-    # Usiamo mediane del dataset per default
-    data_stats=data
-
-    with st.form("inference_form"):
-        st.subheader("Inserisci Dati 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)
-
-        sub=st.form_submit_button("Predizione Step 1")
-
-    if sub:
-        margin= val_merc - costo_rip
-        shape_code = SHAPE_MAPPING.get(shape_name,-1)
-
-        input_dict={
-            "length":length,
-            "width":width,
-            "shape":shape_name,
-            "weight":weight,
-            "thickness":thickness,
-            "RUL":RUL,
-            "margin":margin
-        }
-        temp_df=pd.DataFrame([input_dict])
-
-        # compat_dim
-        if 'target_params' not in st.session_state:
-            st.error("Parametri target non definiti. Fase 1 mancante.")
-            return
-        param_t=st.session_state.target_params
-        temp_df['compat_dim'] = temp_df.apply(lambda r: 
-             dimension_match(r, **param_t), axis=1)
-
-        # shape_code
-        temp_df['shape_code']= shape_code
-        # Manteniamo solo le col ML
-        try:
-            X_inference=temp_df[ML_FEATURES_STEP1]
-        except KeyError as e:
-            st.error(f"Mancano feature: {e}")
-            return
-
-        # Eseguiamo predizione con i modelli
-        preds=[]
-        details=[]
-        for name,pipe in trained_pipelines.items():
-            try:
-                p_num=pipe.predict(X_inference)[0]
-                proba=pipe.predict_proba(X_inference)[0]
-                details.append({
-                    "Modello":name,
-                    "Pred(0=Riu,1=Upc)": p_num,
-                    "Prob_Riutilizzo": proba[0],
-                    "Prob_Upcycling": proba[1]
-                })
-                preds.append(p_num)
-            except Exception as e:
-                st.error(f"Errore predizione {name}: {e}")
-
-        if not preds:
-            st.error("Nessuna predizione valida.")
-            return
-        # Aggrega con mode
-        from statistics import mode, StatisticsError
-        try:
-            final_pred=mode(preds)
-        except StatisticsError:
-            # Se c'è tie, guardiamo la media upcycling
-            avg_upc= np.mean([d["Prob_Upcycling"] for d in details])
-            final_pred=1 if avg_upc>=0.5 else 0
-
-        final_label="Riutilizzo Funzionale" if final_pred==0 else "Upcycling Creativo"
-        st.subheader("Risultato Aggregato")
-        st.metric("Classe", final_label)
-
-        with st.expander("Dettagli singoli modelli"):
-            df_det=pd.DataFrame(details)
-            df_det["Prob_Riutilizzo"]= df_det["Prob_Riutilizzo"].apply(lambda x:f"{x:.1%}")
-            df_det["Prob_Upcycling"]= df_det["Prob_Upcycling"].apply(lambda x:f"{x:.1%}")
-            st.dataframe(df_det)
-
-        # Se Upcycling Creativo => Step 2 (VAE + GenAI)
-        if final_label=="Upcycling Creativo":
-            st.markdown("---")
-            st.subheader("Fase 2: Generazione con VAE + GenAI Testuale")
-
-            if not st.session_state.get("vae_trained_on_eol",False):
-                st.error("VAE non addestrato. Vai a '🧬 Training VAE (Step 2)'.")
-                return
-            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("VAE o scaler mancanti in session.")
-                return
-
-            n_ideas=st.number_input("Quante idee generare col VAE?",1,10,3)
-            if st.button("Genera Configurazioni + Testo Upcycling"):
-                vae_model.eval()
-                with torch.no_grad():
-                    lat_dim= vae_model.fc21.out_features
-                    z=torch.randn(n_ideas, lat_dim)
-                    recon= vae_model.decode(z)
-
-                arr=recon.numpy()
-                try:
-                    arr_inv= vae_scaler.inverse_transform(arr)
-                    feat_names= vae_scaler.feature_names_in_
-                    df_gen= pd.DataFrame(arr_inv, columns=feat_names)
-
-                    # Riconverti shape_code -> shape
-                    if 'shape_code' in df_gen.columns:
-                        df_gen['shape_code']= df_gen['shape_code'].round().astype(int)
-                        inv_map={v:k for k,v in SHAPE_MAPPING.items()}
-                        df_gen['shape']= df_gen['shape_code'].map(inv_map).fillna('unknown')
-
-                    st.write("**Configurazioni generate (VAE)**")
-                    st.dataframe(df_gen.round(2))
-
-                    # --- Integrazione GenAI testuale con Transformers ---
-                    st.markdown("#### Suggerimenti testuali per ciascuna configurazione")
-
-                    # Carichiamo pipeline testuale (distilgpt2, ad es.)
-                    # Se su HF Spaces serve un modello leggero
-                    text_generator = pipeline(
-                        "text-generation",
-                        model="distilgpt2",
-                        device=0 if torch.cuda.is_available() else -1
-                    )
-
-                    def gen_upcycle_text(row):
-                        shape = row.get("shape","unknown")
-                        thick = row.get("thickness",0.0)
-                        wei   = row.get("weight",0.0)
-                        prompt= (
-                            f"Ho un componente EoL con forma {shape}, spessore {thick:.1f} mm, peso {wei:.1f} kg.\n"
-                            "Dammi un'idea creativa di upcycling (in italiano) con passaggi principali:"
-                        )
-                        result= text_generator(prompt, max_new_tokens=50, do_sample=True, top_k=50)
-                        return result[0]["generated_text"]
-
-                    ideas_text=[]
-                    for i, r in df_gen.iterrows():
-                        text_sugg = gen_upcycle_text(r)
-                        ideas_text.append(text_sugg)
-
-                    for i, r in df_gen.iterrows():
-                        st.write(f"**Idea {i+1}** - shape={r['shape']}, thickness={r['thickness']:.1f}, weight={r['weight']:.1f}")
-                        st.info(ideas_text[i])
-                        st.markdown("---")
-
-                except Exception as e:
-                    st.error(f"Errore decoding VAE: {e}")
-        else:
-            st.success("Predetto: Riutilizzo Funzionale. Nessun passaggio generativo richiesto.")
-
-############### 4) PHASE: TRAINING VAE ############
-def vae_training_phase():
-    st.header("🧬 Training VAE (Step 2)")
-    if 'data' not in st.session_state or st.session_state['data'] is None:
-        st.error("Nessun dataset in session. Torna a Fase 1.")
-        return
-    data=st.session_state['data']
-
-    feats=[f for f in VAE_FEATURES_STEP2 if f in data.columns]
+    feats= [f for f in VAE_FEATURES if f in data.columns]
     if not feats:
-        st.error(f"Nessuna feature da usare per VAE. Servirebbero: {VAE_FEATURES_STEP2}")
+        st.error(f"Mancano feature per VAE: {VAE_FEATURES}")
         return
-    st.write(f"VAE userà feature: {feats}")
+    st.write("Useremo le feature:", feats)
 
-    lat_dim= st.slider("Dimensione Latente",2,10,2)
-    ep= st.number_input("Epochs VAE",10,300,50)
-    lr= st.number_input("Learning Rate VAE",1e-5,1e-2,1e-3,format="%e")
-    bs= st.selectbox("Batch Size",[16,32,64], index=1)
+    lat_dim= st.slider("Dim latente",2,10,2)
+    ep= st.number_input("Epoch",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], index=1)
 
-    if not st.session_state.get("vae_trained_on_eol",False):
-        st.warning("VAE non addestrato.")
-        if st.button("Avvia Training VAE"):
-            # Inizializza
+    if not st.session_state.get("vae_trained",False):
+        st.warning("VAE non ancora addestrato.")
+        if st.button("Allena VAE"):
+            # Inizializzo
             st.session_state["vae"]= MiniVAE(input_dim=len(feats), latent_dim=lat_dim)
-            st.session_state["vae_trained_on_eol"]=False
-
             from sklearn.preprocessing import StandardScaler
             X_vae= data[feats].copy()
-            # Riempi NaN
             for c in X_vae.columns:
                 if X_vae[c].isnull().any():
-                    X_vae[c].fillna(X_vae[c].median(), inplace=True)
-
-            # Scalatura
+                    X_vae[c].fillna(X_vae[c].median(),inplace=True)
             scaler= StandardScaler()
-            X_scaled= scaler.fit_transform(X_vae)
+            X_s= scaler.fit_transform(X_vae)
             st.session_state["vae_scaler"]= scaler
 
-            dataset=torch.utils.data.TensorDataset(torch.tensor(X_scaled,dtype=torch.float32))
+            dataset= torch.utils.data.TensorDataset(torch.tensor(X_s,dtype=torch.float32))
             loader= torch.utils.data.DataLoader(dataset,batch_size=bs,shuffle=True)
-            vae=st.session_state["vae"]
-            optimizer= torch.optim.Adam(vae.parameters(),lr=lr)
-
+            vae= st.session_state["vae"]
+            opt= torch.optim.Adam(vae.parameters(),lr=lr)
             losses=[]
             vae.train()
             for epoch in range(int(ep)):
-                epoch_loss=0
+                ep_loss=0
                 for (batch,) in loader:
-                    optimizer.zero_grad()
+                    opt.zero_grad()
                     recon, mu, logvar= vae(batch)
-                    loss= vae_loss(recon, batch, mu, logvar)
+                    loss= vae_loss(recon,batch,mu,logvar)
                     loss.backward()
-                    optimizer.step()
-                    epoch_loss+= loss.item()
-                avg_loss= epoch_loss/len(dataset)
-                losses.append(avg_loss)
+                    opt.step()
+                    ep_loss+=loss.item()
+                avgL= ep_loss/len(dataset)
+                losses.append(avgL)
                 st.progress((epoch+1)/ep)
-            st.session_state["vae_trained_on_eol"]=True
-            st.success(f"VAE addestrato. Ultimo Loss ~ {avg_loss:.2f}")
+            st.success(f"Training VAE completato, Loss ~ {avgL:.2f}")
             st.line_chart(losses)
+            st.session_state["vae_trained"]= True
     else:
-        st.success("VAE già addestrato. Se vuoi rifare training, clicca 'Riallena'.")
-        if st.button("Riallena"):
-            st.session_state["vae_trained_on_eol"]=False
-            st.rerun()
+        st.success("VAE già addestrato. Se vuoi rifarlo, resetta e ricarica.")
+
+#############################
+# STEP 3: Upcycling Generative
+#############################
+def step3_upcycling_generative():
+    st.header("Step 3: Upcycling Generative – Genera idee con VAE + GenAI")
+
+    # Verifica se VAE c'è
+    if not st.session_state.get("vae_trained",False):
+        st.error("Devi addestrare il VAE (Step 2B) prima.")
+        return
+    vae= st.session_state.get("vae",None)
+    vae_scaler= st.session_state.get("vae_scaler",None)
+    if vae is None or vae_scaler is None:
+        st.error("VAE o scaler mancanti.")
+        return
+
+    st.write("Inserisci manualmente i param EoL (opzionale) oppure generiamo n idee random dal VAE?")
 
-############### 5) PHASE: DASHBOARD ############
+    if st.checkbox("Usa param EoL come base? (NON implementato)"):
+        st.info("Potresti implementare un partial-conditional VAE. Attualmente generiamo in modo random lat space.")
+        # In un VAE classico non-conditional, non possiamo forzare i param a una base specifica, a meno di trick
+
+    n_ideas= st.number_input("N. idee da generare",1,10,3)
+    if st.button("Genera Upcycling"):
+        vae.eval()
+        with torch.no_grad():
+            lat_dim= vae.fc21.out_features
+            z= torch.randn(n_ideas, lat_dim)
+            recon= vae.decode(z)
+        arr= recon.numpy()
+        try:
+            arr_inv= vae_scaler.inverse_transform(arr)
+            df_gen= pd.DataFrame(arr_inv, columns=vae_scaler.feature_names_in_)
+
+            # shape_code -> shape
+            if 'shape_code' in df_gen.columns:
+                df_gen['shape_code']= df_gen['shape_code'].round().astype(int)
+                rev_map= {v:k for k,v in SHAPE_MAPPING.items()}
+                df_gen['shape']= df_gen['shape_code'].map(rev_map).fillna('unknown')
+
+            st.subheader("Configurazioni Generate (VAE)")
+            st.dataframe(df_gen.round(2))
+
+            # Gen testo con pipeline HF
+            st.markdown("### Suggerimenti Testuali di Upcycling")
+            text_generator = pipeline("text-generation", model="distilgpt2", 
+                                      device=0 if torch.cuda.is_available() else -1)
+
+            def gen_upcycle_text(shape, thick, wei):
+                prompt= (
+                  f"Ho un componente EoL di forma {shape}, spessore {thick:.1f} mm, peso {wei:.1f} kg.\n"
+                  "Dammi un'idea creativa di upcycling in italiano, con passaggi principali:"
+                )
+                out= text_generator(prompt, max_new_tokens=50, do_sample=True, top_k=50)
+                return out[0]["generated_text"]
+
+            for i, row in df_gen.iterrows():
+                s= row.get("shape","unknown")
+                t= row.get("thickness",1.0)
+                w= row.get("weight",10.0)
+                text_sug= gen_upcycle_text(s,t,w)
+                st.write(f"**Idea {i+1}**: shape={s}, thickness={t:.1f}, weight={w:.1f}")
+                st.info(text_sug)
+                st.markdown("---")
+
+        except Exception as e:
+            st.error(f"Errore decodifica VAE: {e}")
+
+#############################
+# DASHBOARD
+#############################
 def show_dashboard():
-    st.header("📊 Dashboard")
-    data= st.session_state.get('data', None)
+    st.header("Dashboard")
+    data= st.session_state.get("data",None)
     if data is None:
         st.error("Nessun dataset.")
         return
+    st.write("Distribuzione classi:\n", data["Target"].value_counts())
 
-    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:
-        df_res=st.session_state['train_results']
-        st.subheader("Risultati modelli ML")
-        st.dataframe(df_res)
+    if 'ml_results' in st.session_state and st.session_state["ml_results"] is not None:
+        st.subheader("Risultati ML")
+        st.dataframe(st.session_state["ml_results"])
     else:
-        st.info("Nessun risultato di training ML")
+        st.info("Nessun risultato ML salvato.")
 
-    st.subheader("Stato VAE")
-    if st.session_state.get("vae_trained_on_eol",False):
-        st.success("VAE addestrato. Pronto per generare idee di upcycling.")
+    if st.session_state.get("vae_trained",False):
+        st.success("VAE addestrato.")
     else:
-        st.warning("VAE non addestrato")
+        st.warning("VAE non addestrato.")
 
-############### 6) PHASE: GUIDA ############
+#############################
+# HELP
+#############################
 def show_help():
-    st.header("ℹ️ Guida all'Uso")
+    st.header("ℹ️ Guida all'Uso - Quattro Step")
     st.markdown("""
-**Flusso a due fasi (Riutilizzo vs Upcycling) e generazione creativa VAE + GenAI**:
-
-1. **Fase 1 (Dataset)**:  
-   - Generi/carichi dati su dimensioni, shape, RUL, margin, ecc.
-   - Definisci parametri e tolleranze per la compatibilità, assegni classi ("Riutilizzo Funzionale" vs "Upcycling Creativo").
-
-2. **Fase 2 (Addestramento ML)**:
-   - Alleni vari modelli (RF, SVM...) per predire la classe su nuovi EoL.
+**Flusso**:
+1. **Step 1: Dataset**  
+   - Generi o carichi CSV, definisci param. compatibilità, ottieni classi 'Riutilizzo' vs 'Upcycling'.
 
-3. **Fase 3 (Inferenza)**:
-   - Inserisci un nuovo EoL.
-   - Se la classe è "Riutilizzo Funzionale", stop. 
-   - Se "Upcycling Creativo", prosegui con generazione di soluzioni (VAE)...
+2. **Step 2: Addestramento ML**  
+   - Alleni modelli per predire su nuovi EoL.
 
-4. **Fase 4 (Training VAE)**:
-   - Prima devi addestrare il VAE su feature geometriche. 
-   - Finito l'allenamento, potrai generare configurazioni fittizie per l'upcycling (dim, spessore...).
+3. **Step 2B: Training VAE**  
+   - Alleni VAE su feature geometriche, per generare configurazioni creative.
 
-5. **Fase 3 (continuazione)**:
-   - Appena generi col VAE, un modello di GenAI testuale (distilgpt2) crea suggerimenti di riuso creativo in linguaggio naturale.
+4. **Step 3: Upcycling Generative**  
+   - Generi N idee dal VAE + un modello di text-generation (distilgpt2) fornisce suggerimenti creativi in italiano.  
 
-6. **Fase 5 (Dashboard)**:
-   - Visualizzi le metriche e lo stato dei modelli.
+**Dashboard**: mostra le metriche finali.
+    """)
 
-Puoi resettare l'app in qualsiasi momento dal pulsante "Reset App" nella sidebar.
-""")
-
-############### RESET ############
+#############################
+# RESET
+#############################
 def reset_app():
-    for k in ["data","models","train_results","vae","vae_trained_on_eol","vae_scaler","target_params","score_params","data_source"]:
+    for k in ["data","models","ml_results","vae","vae_trained","vae_scaler","data_source","params_dim"]:
         if k in st.session_state:
             del st.session_state[k]
-    st.success("App reset. Ricarico l'interfaccia.")
+    st.success("App resettata.")
     st.experimental_rerun()
 
-############### MAIN ############
+#############################
+# MAIN
+#############################
 def main():
-    st.sidebar.title("WEEKO - Menu")
-    step= st.sidebar.radio("Fasi:", [
-        "♻️ Dataset",
-        "🤖 Addestramento ML (Step 1)",
-        "🔮 Inferenza (Step 1 & 2)",
-        "🧬 Training VAE (Step 2)",
-        "📊 Dashboard",
-        "ℹ️ Guida"
+    st.sidebar.title("WEEKO 4 Step Flow")
+    step = st.sidebar.radio("Fasi:",[
+        "Step 1: Dataset",
+        "Step 2: Addestramento ML",
+        "Step 2B: Training VAE",
+        "Step 3: Upcycling Generative",
+        "Dashboard",
+        "Help"
     ])
-    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 st.session_state.get('models') is None:
-            st.error("Devi addestrare i modelli ML (Fase 2).")
-        else:
-            model_inference(st.session_state['models'], st.session_state.get('data',None))
-    elif step=="🧬 Training VAE (Step 2)":
-        vae_training_phase()
-    elif step=="📊 Dashboard":
+    if st.sidebar.button("Reset App"):
+        reset_app()
+
+    if step=="Step 1: Dataset":
+        step1_dataset()
+    elif step=="Step 2: Addestramento ML":
+        step2_trainML()
+    elif step=="Step 2B: Training VAE":
+        step2b_trainVAE()
+    elif step=="Step 3: Upcycling Generative":
+        step3_upcycling_generative()
+    elif step=="Dashboard":
         show_dashboard()
-    elif step=="ℹ️ Guida":
+    elif step=="Help":
         show_help()
 
 if __name__=="__main__":
-    main()
-
+    main()