Update app.py

app.py

@@ -4,11 +4,10 @@ import numpy as np
 import seaborn as sns
 import matplotlib.pyplot as plt
 from statistics import mode, StatisticsError
-import io
 
-# --- Scikit-learn ---
+# Scikit-learn
 from sklearn.model_selection import train_test_split, GridSearchCV
-from sklearn.preprocessing import StandardScaler, LabelEncoder
+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
@@ -16,29 +15,22 @@ from sklearn.linear_model import LogisticRegression
 from sklearn.svm import SVC
 from sklearn.neural_network import MLPClassifier
 
-# --- PyTorch (per VAE) ---
+# PyTorch
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-import torch.utils.data
-import random
 
-# Impostazioni generali Streamlit
-st.set_page_config(
-    page_title="WEEKO - AI Reuse Analyzer",
-    page_icon="♻️",
-    layout="wide"
-)
+# Transformers per la GenAI testuale
+from transformers import pipeline
 
-##########################################
-# 1) MODELLI ML (Zero Scarto Analyzer)
-##########################################
+############### STREAMLIT SETUP ###############
+st.set_page_config(page_title="WEEKO - AI Reuse Analyzer",
+                   page_icon="♻️",
+                   layout="wide")
 
+############### MODELLI PLACEHOLDER ############
 class DummyTabTransformerClassifier:
-    """
-    Placeholder modello: in realtà è un MLP, 
-    ma finge di essere un TabTransformer
-    """
+    """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)
@@ -52,13 +44,10 @@ class DummyTabTransformerClassifier:
             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])
+            return np.array([[1.0,0.0] if p==0 else [0.0,1.0] for p in preds])
 
 class DummySAINTClassifier:
-    """
-    Placeholder modello: in realtà è un MLP, 
-    ma finge di essere un SAINT
-    """
+    """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)
@@ -72,7 +61,7 @@ class DummySAINTClassifier:
             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])
+            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'),
@@ -83,10 +72,7 @@ MODELS = {
     "SAINT (Dummy)": DummySAINTClassifier()
 }
 
-##########################################
-# 2) VAE per generative reuse (Fase 2)
-##########################################
-
+############### VAE PER FASE 2 ###############
 class MiniVAE(nn.Module):
     def __init__(self, input_dim=5, latent_dim=2):
         super().__init__()
@@ -103,7 +89,7 @@ class MiniVAE(nn.Module):
     def reparameterize(self, mu, logvar):
         std = torch.exp(0.5 * logvar)
         eps = torch.randn_like(std)
-        return mu + eps * std
+        return mu + eps*std
 
     def decode(self, z):
         h = F.relu(self.fc3(z))
@@ -120,57 +106,53 @@ def vae_loss(recon_x, x, mu, logvar):
     kld = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
     return recon_loss + kld
 
-##########################################
-# Feature sets
-##########################################
+############### 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']
+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 ###############
 SHAPE_MAPPING = {
-    'axisymmetric': 0,
-    'sheet_metal': 1,
-    'alloy_plate': 2,
-    'complex_plastic': 3
+    'axisymmetric':0,
+    'sheet_metal':1,
+    'alloy_plate':2,
+    'complex_plastic':3
 }
 
-##########################################
-# Generazione dataset sintetico
-##########################################
+############### 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(['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)
+    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
+        'length': length,
+        'width': width,
+        'RUL': RUL,
+        'margin': margin,
+        'shape': shapes,
+        'weight': weight,
+        'thickness': thickness
     })
 
-##########################################
-# dimension_match + assegnazione classe
-##########################################
+############### 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_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
+    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
+    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:
@@ -178,28 +160,25 @@ def assign_class(row, threshold_score=0.5, alpha=0.5, beta=0.5):
     else:
         return "Upcycling Creativo"
 
-##########################################
-# --- Fase 1: Preparazione Dataset
-##########################################
+############### 1) PHASE: PREPARE DATASET ###############
 def prepare_dataset():
     st.header("♻️ 1. Preparazione Dataset EoL")
-
-    tab1, tab2 = st.tabs(["Carica/Genera Dati", "Definisci Compatibilità & Target"])
+    tab1, tab2 = st.tabs(["Carica/Genera Dati","Definisci Compatibilità & Target"])
     data = None
     with tab1:
-        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)
+        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=n_samples)
+                data=generate_synthetic_data(n_samples=ns)
                 st.session_state.data_source="generated"
         else:
-            file=st.file_uploader("Carica CSV con le feature minime", type=["csv"])
-            if file:
+            upfile=st.file_uploader("Carica CSV con feature minime", type=["csv"])
+            if upfile:
                 try:
-                    data=pd.read_csv(file)
+                    data=pd.read_csv(upfile)
                     if not all(col in data.columns for col in DEFAULT_FEATURES_STEP1):
-                        st.error(f"Il CSV deve contenere almeno: {DEFAULT_FEATURES_STEP1}")
+                        st.error(f"Mancano colonne minime: {DEFAULT_FEATURES_STEP1}")
                         data=None
                     else:
                         st.session_state.data_source="uploaded"
@@ -209,111 +188,100 @@ def prepare_dataset():
 
     if data is not None:
         with tab2:
-            st.subheader("Parametri di Compatibilità")
+            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,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)
+                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,250.0,80.0,step=1.0)
-                t_thick=st.number_input("Spessore target (mm)",0.5,30.0,8.0,step=0.5)
+                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("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)
+                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("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)
+                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_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)
+            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)
 
-            # Codifica shape
+            # shape_code
             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)
+            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_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
+                "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,
+                "threshold_score": thr_sc,
                 "alpha": alpha,
                 "beta": beta
             }
 
             st.dataframe(data.head(10))
-            st.write("Distribuzione Classi:", data['Target'].value_counts())
+            st.write("Distribuzione classi:", data["Target"].value_counts())
 
-            numeric_cols = data.select_dtypes(include=np.number)
+            numeric_cols=data.select_dtypes(include=np.number)
             if not numeric_cols.empty:
-                fig,ax=plt.subplots(figsize=(8,6))
+                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=data.to_csv(index=False).encode('utf-8')
-            st.download_button("Scarica Dataset Elaborato CSV", csv, "dataset_processed.csv")
+            csv_proc=data.to_csv(index=False).encode('utf-8')
+            st.download_button("Scarica Dataset Elaborato", csv_proc, "dataset_processed.csv")
 
-#######################################
-#  Fase 2: Training Modelli ML
-#######################################
+############### 2) PHASE: TRAIN MODELLI ML ############
 def train_models(data):
     st.header("🤖 2. Addestramento ML (Riutilizzo vs Upcycling)")
     if data is None:
-        st.error("Nessun dataset elaborato. Torna alla Fase 1.")
+        st.error("Dataset non disponibile (Fase 1).")
         return
     if 'Target' not in data.columns:
-        st.error("Colonna 'Target' assente. Verifica la Fase 1.")
+        st.error("Colonna 'Target' mancante. Rivedi la Fase 1.")
         return
 
-    # 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 per l'addestramento ML.")
+        st.error("Nessuna feature 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
+    X = data[features_to_use].copy()
+    y = data['Target'].map({"Riutilizzo Funzionale":0,"Upcycling Creativo":1})
     if len(y.unique())<2:
-        st.error("Il dataset contiene una sola classe. Aggiusta i parametri in Fase 1.")
+        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)
+    st.write(f"Train={len(X_train)}, Test={len(X_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"Dati: {len(X_train)} train, {len(X_test)} test.")
-    tune_rf=st.checkbox("Ottimizza RandomForest (GridSearchCV)", value=False)
-
+    tune_rf= st.checkbox("Ottimizza RandomForest (GridSearchCV)",False)
     trained_pipelines={}
     results=[]
+
     for name,model in MODELS.items():
         st.subheader(f"Modello: {name}")
         from sklearn.pipeline import Pipeline
@@ -323,17 +291,18 @@ def train_models(data):
         ])
         try:
             if tune_rf and name=="Random Forest":
-                st.write("GridSearch per RandomForest...")
+                st.write("Esecuzione GridSearchCV su RandomForest...")
                 param_grid={
                     'clf__n_estimators':[50,100],
-                    'clf__max_depth':[None,10,15]
+                    'clf__max_depth':[None,10],
                 }
-                grid=GridSearchCV(pipe, param_grid, cv=2, scoring='accuracy', n_jobs=-1)
+                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_model=grid.best_estimator_
+                best_est=grid.best_estimator_
                 st.write(f"Migliori parametri: {grid.best_params_}")
-                y_pred=best_model.predict(X_test)
-                pipe_to_use=best_model
+                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)
@@ -341,16 +310,15 @@ def train_models(data):
 
             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})
+            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")
+            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}")
 
@@ -358,295 +326,323 @@ def train_models(data):
             st.error(f"Errore addestramento {name}: {e}")
 
     if results:
-        results_df=pd.DataFrame(results).sort_values(by="Accuracy",ascending=False)
-        st.dataframe(results_df)
-        st.session_state.train_results=results_df
+        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
     else:
         st.error("Nessun modello addestrato con successo.")
         st.session_state.models=None
 
-#######################################
-# Fase 3: Inferenza + Trigger Upcycling -> VAE
-#######################################
+############### 3) PHASE: INFERE ############
 def model_inference(trained_pipelines, data):
-    st.header("🔮 3. Inferenza: Step 1 (Riutilizzo vs Upcycling) & Step 2 (VAE Upcycling)")
+    st.header("🔮 3. Inferenza: Step 1 & Step 2 (VAE + GenAI)")
 
     if not trained_pipelines:
-        st.error("Prima addestra i modelli (Fase 2).")
+        st.error("Prima addestra i modelli ML (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.")
+        st.error("Nessun dataset (Fase 1).")
         return
 
-    data_stats=data # useremo mediane per default
+    # Usiamo mediane del dataset per default
+    data_stats=data
 
-    with st.form(key="inference_form"):
-        st.subheader("Inserisci Caratteristiche EoL")
+    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()))
+            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()))
+            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)
+            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")
+        sub=st.form_submit_button("Predizione Step 1")
 
-    if submitted:
+    if sub:
         margin= val_merc - costo_rip
-        shape_code= SHAPE_MAPPING.get(shape_name, -1)
+        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
+            "length":length,
+            "width":width,
+            "shape":shape_name,
+            "weight":weight,
+            "thickness":thickness,
+            "RUL":RUL,
+            "margin":margin
         }
         temp_df=pd.DataFrame([input_dict])
 
-        # Calcola compat_dim
-        tparams=st.session_state.target_params
-        temp_df['compat_dim']=temp_df.apply(lambda r: dimension_match(r,**tparams), axis=1)
-
-        # Rimuovi shape testo e aggiungi shape_code
-        temp_df['shape_code']=shape_code
-        temp_df_ml= temp_df.drop(columns=['shape'])
+        # 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)
 
-        # Assicuriamoci di avere ML_FEATURES_STEP1
+        # shape_code
+        temp_df['shape_code']= shape_code
+        # Manteniamo solo le col ML
         try:
-            X_inference=temp_df_ml[ML_FEATURES_STEP1]
+            X_inference=temp_df[ML_FEATURES_STEP1]
         except KeyError as e:
-            st.error(f"Mancano colonne per ML: {e}")
+            st.error(f"Mancano feature: {e}")
             return
 
-        # Predici con tutti i modelli
-        model_predictions=[]
+        # Eseguiamo predizione con i modelli
+        preds=[]
         details=[]
         for name,pipe in trained_pipelines.items():
             try:
-                pred_num=pipe.predict(X_inference)[0]
+                p_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]
+                    "Modello":name,
+                    "Pred(0=Riu,1=Upc)": p_num,
+                    "Prob_Riutilizzo": proba[0],
+                    "Prob_Upcycling": proba[1]
                 })
-                model_predictions.append(pred_num)
+                preds.append(p_num)
             except Exception as e:
                 st.error(f"Errore predizione {name}: {e}")
 
-        if not model_predictions:
-            st.error("Nessun modello ha prodotto predizioni.")
+        if not preds:
+            st.error("Nessuna predizione valida.")
             return
-
         # Aggrega con mode
+        from statistics import mode, StatisticsError
         try:
-            final_pred=mode(model_predictions)
+            final_pred=mode(preds)
         except StatisticsError:
-            # 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
+            # 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 (Step 1)")
-        st.metric("Classe Predetta:", final_label)
+        st.subheader("Risultato Aggregato")
+        st.metric("Classe", 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)
+        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 risulta "Upcycling Creativo", allora Step 2 (VAE)
+        # Se Upcycling Creativo => Step 2 (VAE + GenAI)
         if final_label=="Upcycling Creativo":
             st.markdown("---")
-            st.subheader("Upcycling Creativo → Esplorazione Generativa (VAE)")
+            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 alla fase '🧬 Training VAE (Step 2)' prima.")
-            else:
-                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: VAE o scaler non disponibile in session.")
-                else:
-                    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}")
+                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("Compatibilità => Riutilizzo Funzionale. Nessun passaggio generativo necessario.")
+            st.success("Predetto: Riutilizzo Funzionale. Nessun passaggio generativo richiesto.")
 
-#######################################
-# Fase 4: Training VAE
-#######################################
+############### 4) PHASE: TRAINING VAE ############
 def vae_training_phase():
-    st.header("🧬 Training VAE - Step 2")
-
+    st.header("🧬 Training VAE (Step 2)")
     if 'data' not in st.session_state or st.session_state['data'] is None:
-        st.error("Non c'è un dataset elaborato. Torna in Fase 1.")
+        st.error("Nessun dataset in session. Torna a Fase 1.")
         return
-
     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]
+
+    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}")
+        st.error(f"Nessuna feature da usare per VAE. Servirebbero: {VAE_FEATURES_STEP2}")
         return
-    st.write(f"**Il VAE userà le feature**: {feats}")
+    st.write(f"VAE userà 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)
+    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)
 
     if not st.session_state.get("vae_trained_on_eol",False):
-        st.warning("VAE non addestrato su EoL. Clicca il bottone per avviare.")
+        st.warning("VAE non addestrato.")
         if st.button("Avvia Training VAE"):
-            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()
+            # Inizializza
+            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
-            from sklearn.preprocessing import StandardScaler
-            scaler=StandardScaler()
-            X_scaled=scaler.fit_transform(X_vae)
-            st.session_state["vae_scaler"]=scaler
+            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)
+            loader= torch.utils.data.DataLoader(dataset,batch_size=bs,shuffle=True)
+            vae=st.session_state["vae"]
+            optimizer= torch.optim.Adam(vae.parameters(),lr=lr)
 
             losses=[]
             vae.train()
             for epoch in range(int(ep)):
-                epoch_loss=0.0
+                epoch_loss=0
                 for (batch,) in loader:
                     optimizer.zero_grad()
-                    recon,mu,logvar=vae(batch)
-                    loss=vae_loss(recon,batch,mu,logvar)
+                    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)
+                    epoch_loss+= loss.item()
+                avg_loss= epoch_loss/len(dataset)
+                losses.append(avg_loss)
                 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.success(f"VAE addestrato. Ultimo Loss ~ {avg_loss:.2f}")
             st.line_chart(losses)
     else:
-        st.success("VAE risulta già addestrato su EoL. Se vuoi rifarlo, premi 'Riallena' qui sotto.")
-        if st.button("Riallena VAE"):
+        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()
 
-#######################################
-# Fase 5: Dashboard
-#######################################
+############### 5) PHASE: DASHBOARD ############
 def show_dashboard():
     st.header("📊 Dashboard")
-    if 'data' not in st.session_state or st.session_state['data'] is None:
-        st.error("No dataset. Torna alla Fase 1.")
+    data= st.session_state.get('data', None)
+    if data is None:
+        st.error("Nessun dataset.")
         return
-    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.subheader("Risultati modelli ML")
         st.dataframe(df_res)
     else:
-        st.info("Modelli ML non addestrati o nessun risultato salvato.")
+        st.info("Nessun risultato di training ML")
 
     st.subheader("Stato VAE")
     if st.session_state.get("vae_trained_on_eol",False):
-        st.success("VAE Addestrato")
+        st.success("VAE addestrato. Pronto per generare idee di upcycling.")
     else:
-        st.warning("VAE non addestrato o parametri cambiati.")
+        st.warning("VAE non addestrato")
 
-#######################################
-# Fase 6: Guida
-#######################################
+############### 6) PHASE: GUIDA ############
 def show_help():
-    st.header("ℹ️ Guida")
+    st.header("ℹ️ Guida all'Uso")
     st.markdown("""
-    **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
-#######################################
+**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.
+
+3. **Fase 3 (Inferenza)**:
+   - Inserisci un nuovo EoL.
+   - Se la classe è "Riutilizzo Funzionale", stop. 
+   - Se "Upcycling Creativo", prosegui con generazione di soluzioni (VAE)...
+
+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...).
+
+5. **Fase 3 (continuazione)**:
+   - Appena generi col VAE, un modello di GenAI testuale (distilgpt2) crea suggerimenti di riuso creativo in linguaggio naturale.
+
+6. **Fase 5 (Dashboard)**:
+   - Visualizzi le metriche e lo stato dei modelli.
+
+Puoi resettare l'app in qualsiasi momento dal pulsante "Reset App" nella sidebar.
+""")
+
+############### RESET ############
 def reset_app():
-    keys=[
-        'data','models','train_results','vae','vae_trained_on_eol',
-        'vae_scaler','target_params','score_params','data_source'
-    ]
-    for k in keys:
+    for k in ["data","models","train_results","vae","vae_trained_on_eol","vae_scaler","target_params","score_params","data_source"]:
         if k in st.session_state:
             del st.session_state[k]
-    st.success("Reset completato.")
+    st.success("App reset. Ricarico l'interfaccia.")
     st.experimental_rerun()
 
-#######################################
-# MAIN
-#######################################
+############### MAIN ############
 def main():
-    st.sidebar.title("Menu Principale")
-    step=st.sidebar.radio("Fasi", [
+    st.sidebar.title("WEEKO - Menu")
+    step= st.sidebar.radio("Fasi:", [
         "♻️ Dataset",
         "🤖 Addestramento ML (Step 1)",
         "🔮 Inferenza (Step 1 & 2)",
@@ -661,8 +657,8 @@ def main():
     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).")
+        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)":
@@ -674,3 +670,4 @@ def main():
 
 if __name__=="__main__":
     main()
+