Update app.py

app.py

@@ -1,285 +1,368 @@
 import streamlit as st
+import pandas as pd
+import numpy as np
+from PIL import Image
+import os
+
+# Scikit-learn
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+from sklearn.metrics import accuracy_score, confusion_matrix
+from sklearn.pipeline import Pipeline
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# PyTorch
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-import numpy as np
-import pandas as pd
+import random
+
+###########################################
+# 1) Libreria Destinazioni (multi-class)
+###########################################
+TARGET_LABELS = ["Armadio", "Dock", "Vetrina", "Tool"]
+
+def pick_random_target(row):
+    """
+    Logica fittizia: in base ad area e shape_code assegna una destinazione
+    """
+    # Semplifichiamo: se shape_code = 0 => preferiamo "Armadio"
+    # shape_code = 1 => "Dock"
+    # shape_code = 2 => "Vetrina"
+    # shape_code = 3 => "Tool"
+    # ma aggiungiamo un po' di random
+    code = int(row["shape_code"])
+    return TARGET_LABELS[code]
+
+###########################################
+# 2) Genera dataset sintetico
+###########################################
+def generate_synthetic_data_mc(n=300, seed=42):
+    """
+    Genera un dataset multi-classe:
+      - volume, area, lunghezza, spessore, shape_code (0..3), usura
+      - label = "Armadio"/"Dock"/"Vetrina"/"Tool" (fittizi)
+    """
+    np.random.seed(seed)
+    random.seed(seed)
+
+    volume = np.clip(np.random.normal(50,15,n), 10, 200)
+    area   = np.clip(np.random.normal(20,8,n), 5, 200)
+    lung   = np.clip(np.random.normal(100,30,n), 20, 300)
+    spess  = np.clip(np.random.normal(5,1,n), 0.5, 10)
+    usura  = np.random.rand(n)  # 0..1
+    shape_code = np.random.randint(0,4,n) # 4 possibili "forme"
+
+    df = pd.DataFrame({
+        "volume": volume,
+        "area": area,
+        "lunghezza": lung,
+        "spessore": spess,
+        "usura": usura,
+        "shape_code": shape_code
+    })
+
+    # label => in base a shape_code
+    df["target"] = df.apply(pick_random_target, axis=1)
+    return df
+
+###########################################
+# 3) Modello PyTorch VAE per generative reuse
+###########################################
+class MiniVAE(nn.Module):
+    def __init__(self, input_dim=4, latent_dim=2):
+        super().__init__()
+        self.fc1 = nn.Linear(input_dim, 16)
+        self.fc21 = nn.Linear(16, latent_dim)
+        self.fc22 = nn.Linear(16, latent_dim)
+        self.fc3 = nn.Linear(latent_dim, 16)
+        self.fc4 = nn.Linear(16, input_dim)
 
-from torch.utils.data import DataLoader, TensorDataset
-import plotly.graph_objects as go
+    def encode(self, x):
+        h = F.relu(self.fc1(x))
+        return self.fc21(h), self.fc22(h)
 
-# ===============================
-# DESTINAZIONI (4 CLASSI)
-# ===============================
-DESTINAZIONI = ["ArmadioAnta","DockRigenerato","OggettoVetrina","ToolEducativo"]
+    def reparameterize(self, mu, logvar):
+        std = torch.exp(0.5 * logvar)
+        eps = torch.randn_like(std)
+        return mu + eps*std
 
-# ===============================
-# MLP AVANZATA
-# ===============================
-class AdvancedMLP(nn.Module):
-    def __init__(self, input_dim=10, hidden1=32, hidden2=32, num_classes=4):
-        super().__init__()
-        self.bn_in = nn.BatchNorm1d(input_dim)
-        self.fc1 = nn.Linear(input_dim, hidden1)
-        self.bn1 = nn.BatchNorm1d(hidden1)
-        self.drop1 = nn.Dropout(0.2)
-        self.fc2 = nn.Linear(hidden1, hidden2)
-        self.bn2 = nn.BatchNorm1d(hidden2)
-        self.drop2 = nn.Dropout(0.2)
-        self.out = nn.Linear(hidden2, num_classes)
+    def decode(self, z):
+        h = F.relu(self.fc3(z))
+        return self.fc4(h)
 
     def forward(self, x):
-        x = self.bn_in(x)
-        x = F.relu(self.fc1(x))
-        x = self.bn1(x)
-        x = self.drop1(x)
-        x = F.relu(self.fc2(x))
-        x = self.bn2(x)
-        x = self.drop2(x)
-        logits = self.out(x)
-        return logits  # shape [batch, num_classes]
-
-# ===============================
-# STREAMLIT
-# ===============================
-st.set_page_config(page_title="Weeko - Advanced AI", layout="wide")
-st.title("Weeko - Modello Avanzato per Compatibilità EoL (OR6.2/OR6.3)")
-
-# Session state
-if "model" not in st.session_state:
-    st.session_state["model"] = AdvancedMLP()
-if "trained" not in st.session_state:
-    st.session_state["trained"] = False
-if "X_val" not in st.session_state:
-    st.session_state["X_val"] = None
-if "y_val" not in st.session_state:
-    st.session_state["y_val"] = None
-
-# Funzione di train
-def train_model(dataset, epochs=20, batch_size=32):
-    model = st.session_state["model"]
-    def init_weights(m):
-        if isinstance(m, nn.Linear):
-            nn.init.xavier_uniform_(m.weight)
-            nn.init.zeros_(m.bias)
-    model.apply(init_weights)
-
-    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
-    lossf = nn.CrossEntropyLoss()
-
-    loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
-    for ep in range(epochs):
-        total_loss=0
-        for (xb, yb) in loader:
-            optimizer.zero_grad()
-            logits = model(xb)
-            loss = lossf(logits, yb)
-            loss.backward()
-            optimizer.step()
-            total_loss+=loss.item()
-
-    st.session_state["trained"] = True
-
-# ============= TABS =============
-tabs = st.tabs(["1) Genera Dataset Avanzato","2) Train & Val","3) Valuta Nuovo EoL"])
-
-# ---------------- TAB 1 ----------------
-with tabs[0]:
-    st.subheader("Genera un dataset fittizio con 10 feature + 4 destinazioni")
-
-    st.write("""
-    **Feature** possibili:
-    1. volume (cm³)
-    2. area (cm²)
-    3. lunghezza (mm)
-    4. spessore (mm)
-    5. usura (0..1)
-    6. rigidità (0..1)
-    7. shape_complexity (0..1)
-    8. fori_count (numero fori)
-    9. estetica_rating (0..1)
-    10. materiale_code (0..3)
-
-    **Destinazione**: 4 classi (ArmadioAnta, DockRigenerato, OggettoVetrina, ToolEducativo)
-    """)
-
-    n = st.number_input("Quanti campioni fittizi generare?", 100,20000, 1000)
-    if st.button("Genera dataset & Memorizza in session"):
-        rng = np.random.default_rng(42)
-        volume = rng.normal(50,15,n)
-        area = rng.normal(20,5,n)
-        lung = rng.normal(100,30,n)
-        spess = rng.uniform(0.5,5,n)
-        usura = rng.uniform(0,1,n)
-        rigid = rng.uniform(0,1,n)
-        shape_c = rng.uniform(0,1,n)
-        fori = rng.integers(0,10,n)
-        estetica = rng.uniform(0,1,n)
-        materiale = rng.integers(0,4,n)
-
-        # Creiamo un "assegnamento" di destinazione fittizio
-        # Esempio di logica: se spess<2 => preferiamo Dock; se volume>70 => preferiamo Armadio, etc.
-        # + un tocco di casualità
-        y = []
-        for i in range(n):
-            # base logic
-            if volume[i]>70 and spess[i]<3:
-                cl = "ArmadioAnta"
-            elif shape_c[i]<0.3 and area[i]<25:
-                cl = "DockRigenerato"
-            elif estetica[i]>0.6:
-                cl = "OggettoVetrina"
-            else:
-                cl = "ToolEducativo"
-            # random dev
-            if rng.random()<0.1:
-                cl = rng.choice(DESTINAZIONI)
-            y.append(cl)
-        
-        df = pd.DataFrame({
-            "volume":volume,"area":area,"lunghezza":lung,"spessore":spess,"usura":usura,"rigidita":rigid,
-            "shape_complex":shape_c,"fori_count":fori,"estetica":estetica,"materiale":materiale,
-            "destinazione":y
-        })
-
-        st.dataframe(df.head(10))
-        st.session_state["data_df"] = df
-        st.success("Dataset generato e salvato in session.")
-
-# ---------------- TAB 2 ----------------
-with tabs[1]:
-    st.subheader("Train & Validation")
-
-    if "data_df" not in st.session_state:
-        st.warning("Genera prima il dataset fittizio (Tab 1).")
-    else:
-        df = st.session_state["data_df"]
-        st.write(f"Dataset size: {len(df)}")
-
-        if st.button("Esegui training rete neurale"):
-            # Prepariamo tensori
-            X_np = df[["volume","area","lunghezza","spessore","usura","rigidita","shape_complex","fori_count","estetica","materiale"]].to_numpy()
-            y_list = df["destinazione"].tolist()
-            # Mappiamo destinazioni -> int
-            label2id = {cls:i for i,cls in enumerate(DESTINAZIONI)}
-            y_np = np.array([label2id[v] for v in y_list], dtype=np.int64)
-
-            # Shuffle & split
-            rng = np.random.default_rng(999)
-            idx = np.arange(len(X_np))
-            rng.shuffle(idx)
-            train_size = int(len(X_np)*0.8)
-            train_idx = idx[:train_size]
-            val_idx = idx[train_size:]
-
-            X_train = X_np[train_idx]
-            y_train = y_np[train_idx]
-            X_val = X_np[val_idx]
-            y_val = y_np[val_idx]
-
-            # PyTorch
-            X_t = torch.tensor(X_train, dtype=torch.float32)
-            y_t = torch.tensor(y_train, dtype=torch.long)
-            train_dataset = TensorDataset(X_t,y_t)
-
-            train_model(train_dataset, epochs=25, batch_size=64)
-
-            # Salviamo X_val e y_val
-            st.session_state["X_val"] = torch.tensor(X_val, dtype=torch.float32)
-            st.session_state["y_val"] = torch.tensor(y_val, dtype=torch.long)
-
-            st.success("Modello addestrato con successo!")
-
-        # Se già trainato, valutiamo la performance su val set
-        if st.session_state["trained"] and st.session_state["X_val"] is not None:
-            Xv = st.session_state["X_val"]
-            yv = st.session_state["y_val"]
-            model = st.session_state["model"]
-            with torch.no_grad():
-                logits = model(Xv)
-                preds = torch.argmax(logits, dim=1)
-                acc = (preds==yv).float().mean().item()
-            st.info(f"Accuracy su validation set: {acc:.2f}")
+        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):
+    mse = F.mse_loss(recon_x, x, reduction='sum')
+    kld = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
+    return mse + kld
 
 
-# ---------------- TAB 3 ----------------
-with tabs[2]:
-    st.subheader("Valuta un nuovo EoL e vedi bounding box design wise")
+###########################################
+# STREAMLIT SETUP
+###########################################
+st.set_page_config(page_title="WEEKO – Full AI App", layout="wide")
+st.title("WEEKO – Full AI Demo: multi-class + generative + overlay")
 
-    if not st.session_state["trained"]:
-        st.warning("Occorre prima addestrare la rete neurale in Tab 2.")
+if "df" not in st.session_state:
+    st.session_state["df"] = None
+if "model" not in st.session_state:
+    st.session_state["model"] = None
+if "vae" not in st.session_state:
+    st.session_state["vae"] = None
+if "vae_trained" not in st.session_state:
+    st.session_state["vae_trained"] = False
+if "label_enc" not in st.session_state:
+    st.session_state["label_enc"] = None
+
+
+###########################################
+# SIDEBAR
+###########################################
+menu = st.sidebar.radio("Fasi", ["Dataset","Training","Inferenza","Generative Reuse (VAE)","Overlay Estetico","Dashboard"])
+
+###########################################
+# FUNZIONE: Caricamento/generazione dataset
+###########################################
+def dataset_phase():
+    st.subheader("Fase 1: Dataset")
+
+    data_option = st.radio("Scegli la fonte del dataset", ["Genera Sintetico","Carica CSV"], horizontal=True)
+    if data_option == "Genera Sintetico":
+        n = st.slider("Numero di campioni", 50,1000,300,step=50)
+        if st.button("Genera"):
+            df = generate_synthetic_data_mc(n=n)
+            st.session_state["df"] = df
+            st.success("Dataset sintetico generato!")
     else:
-        # Input EoL
-        st.write("Inserisci 10 feature del componente EoL:")
-        volume_in = st.number_input("Volume (cm³)", 0.0, 1000.0, 80.0)
-        area_in   = st.number_input("Area (cm²)", 0.0, 500.0, 30.0)
-        lung_in   = st.number_input("Lunghezza (mm)",0.0,2000.0,100.0)
-        spess_in  = st.number_input("Spessore (mm)",0.0,10.0,2.0)
-        usura_in  = st.slider("Usura",0.0,1.0,0.3)
-        rigid_in  = st.slider("Rigidità",0.0,1.0,0.5)
-        shape_in  = st.slider("Shape Complexity",0.0,1.0,0.4)
-        fori_in   = st.number_input("Numero fori",0,50,4)
-        estet_in  = st.slider("Estetica (0=brutto,1=figo)",0.0,1.0,0.6)
-        mat_in    = st.selectbox("Materiale code (0=Plastica,1=Metallo,2=PCB,3=Altro)",[0,1,2,3],index=1)
-
-        if st.button("Calcola Probabilità Compatibilità"):
-            x_in = np.array([[volume_in, area_in, lung_in, spess_in, usura_in, rigid_in, shape_in, fori_in, estet_in, mat_in]], dtype=np.float32)
-            model = st.session_state["model"]
-            xt = torch.tensor(x_in)
-            with torch.no_grad():
-                logits = model(xt)
-                probs = F.softmax(logits, dim=1).numpy()[0]
-            # Visual
-            st.write("**Probabilità su 4 destinazioni:**")
-            for i,cls in enumerate(DESTINAZIONI):
-                st.write(f"- {cls}: {probs[i]*100:.1f}%")
-            best_idx = np.argmax(probs)
-            best_cls = DESTINAZIONI[best_idx]
-            st.success(f"Più probabile destinazione: {best_cls}")
-
-            # Un bounding box 3D (fittizio)
-            # Esempio: disegniamo un parallelepipedo EoL in Plotly
-            def create_box(L, A, S):
-                # ipotesi: area = L x W => W= area / L
-                # volume= L x W x H => H= volume/(L x W)
-                # ma useremo spessore in parte
-                # semplifichiamo: base lung_in x sqrt(area_in), altezza = spess_in * 10...
-                import math
-                W = max(1, A / max(1,L))
-                H = max(1, S*15)  # spessore * 15 come fattore
-                # vertici
-                return [
-                    (0,0,0),(L,0,0),(L,W,0),(0,W,0),
-                    (0,0,H),(L,0,H),(L,W,H),(0,W,H)
-                ]
-            box_verts = create_box(lung_in, area_in, spess_in)
-            edges = [(0,1),(1,2),(2,3),(3,0),
-                     (4,5),(5,6),(6,7),(7,4),
-                     (0,4),(1,5),(2,6),(3,7)]
-            fig = go.Figure()
-            for (i,j) in edges:
-                xs = [box_verts[i][0], box_verts[j][0]]
-                ys = [box_verts[i][1], box_verts[j][1]]
-                zs = [box_verts[i][2], box_verts[j][2]]
-                fig.add_trace(go.Scatter3d(x=xs,y=ys,z=zs,mode='lines', line=dict(color='blue',width=5), showlegend=False))
-            fig.update_layout(
-                title="Bounding box EoL (fittizio design wise)",
-                scene=dict(
-                    xaxis_title='X(mm)', yaxis_title='Y(mm)', zaxis_title='Z(mm)'
-                ),
-                width=600,height=500
-            )
-            st.plotly_chart(fig, use_container_width=True)
-
-            # Testuale
-            st.write(f"Suggerimento generico di assemblaggio per {best_cls}:")
-
-            if best_cls=="ArmadioAnta":
-                st.info("Potresti aggiungere cerniere su spessore <3mm, rifinitura per margini.")
-            elif best_cls=="DockRigenerato":
-                st.info("Prevedi alloggiamento con fori=2-6 per connettori, ottimo su plastica/metallo.")
-            elif best_cls=="OggettoVetrina":
-                st.info("Valorizza l'estetica >0.5, rifinitura superficiale e shape complesso ok.")
-            else:
-                st.info("Kit didattico, personalizzabile con fori e shape vario.")
+        file = st.file_uploader("Carica CSV con colonne: volume, area, lunghezza, spessore, usura, shape_code, target", type=["csv"])
+        if file:
+            df = pd.read_csv(file)
+            st.session_state["df"] = df
+            st.success("Dataset caricato!")
+
+    if st.session_state["df"] is not None:
+        st.write("Anteprima dataset:")
+        st.dataframe(st.session_state["df"].head(10))
+        st.write("Distribuzione target:", st.session_state["df"]["target"].value_counts())
+        csv = st.session_state["df"].to_csv(index=False)
+        st.download_button("Scarica Dataset", csv, "dataset.csv","text/csv")
+
+###########################################
+# FUNZIONE: Training multi-class (es. RandomForest)
+###########################################
+def training_phase():
+    st.subheader("Fase 2: Training Modello Multi-Classe")
+    df = st.session_state["df"]
+    if df is None:
+        st.error("Prima genera o carica il dataset!")
+        return
+    
+    st.write("Esempio: usiamo un RandomForest + pipeline StandardScaler.")
+    from sklearn.pipeline import Pipeline
+    from sklearn.ensemble import RandomForestClassifier
+
+    # Prepara X,y
+    # NB: shape_code e -> numerico, target -> labelEnc
+    if "target" not in df.columns:
+        st.error("Il dataset deve avere colonna 'target'!")
+        return
+
+    # Estrai X e y
+    # Minimal check: [volume, area, lunghezza, spessore, usura, shape_code]
+    needed_cols = ["volume","area","lunghezza","spessore","usura","shape_code","target"]
+    for c in needed_cols:
+        if c not in df.columns:
+            st.error(f"Colonna '{c}' assente nel dataset!")
+            return
+
+    X = df[["volume","area","lunghezza","spessore","usura","shape_code"]]
+    y = df["target"].astype(str)
+
+    # label encode
+    from sklearn.preprocessing import LabelEncoder
+    le = LabelEncoder()
+    y_enc = le.fit_transform(y)
+
+    st.session_state["label_enc"] = le
+
+    # train test split
+    from sklearn.model_selection import train_test_split
+    X_train, X_test, y_train, y_test = train_test_split(X, y_enc, test_size=0.2, random_state=42)
+
+    # pipeline
+    pipe = Pipeline([
+        ("scaler", StandardScaler()),
+        ("clf", RandomForestClassifier(n_estimators=100, random_state=42))
+    ])
+
+    pipe.fit(X_train, y_train)
+    pred = pipe.predict(X_test)
+
+    acc = accuracy_score(y_test, pred)
+    st.write(f"Accuracy su test: {acc:.3f}")
+
+    cm = confusion_matrix(y_test, pred)
+    fig, ax = plt.subplots()
+    sns.heatmap(cm, annot=True, fmt='d', ax=ax)
+    st.pyplot(fig)
+
+    st.session_state["model"] = pipe
+    st.success("Modello addestrato e salvato in session_state['model'].")
+
+###########################################
+# FUNZIONE: Inference multi-class
+###########################################
+def inference_phase():
+    st.subheader("Fase 3: Inferenza su un nuovo EoL")
+    if st.session_state["model"] is None:
+        st.error("Devi prima addestrare il modello!")
+        return
+    model = st.session_state["model"]
+    le = st.session_state["label_enc"]
+
+    # Inserimento EoL
+    col1, col2 = st.columns(2)
+    with col1:
+        vol = st.number_input("Volume (cm³)",0.0,1000.0,50.0,step=1.0)
+        area= st.number_input("Area (cm²)",0.0,1000.0,30.0,step=1.0)
+        lung= st.number_input("Lunghezza (mm)",0.0,2000.0,120.0,step=1.0)
+    with col2:
+        spess= st.number_input("Spessore (mm)",0.0,20.0,5.0,step=0.5)
+        usura= st.slider("Usura (0=nuovo,1=usuratissimo)",0.0,1.0,0.3)
+        shape_code = st.selectbox("Shape Code", [0,1,2,3], index=0)
+
+    if st.button("Calcola Compatibilità"):
+        x_np = np.array([[vol, area, lung, spess, usura, shape_code]], dtype=float)
+        proba = model.predict_proba(x_np)[0]
+        classes = le.inverse_transform(range(len(proba)))
+        # Ordina disc
+        sorted_idx = np.argsort(-proba)
+        st.write("**Compatibilità con i possibili target** (ordine decrescente):")
+        for i in sorted_idx:
+            st.write(f"- {classes[i]}: {proba[i]*100:.1f}%")
+        # Top1
+        top1 = classes[sorted_idx[0]]
+        st.success(f"**Consiglio**: {top1}")
+
+###########################################
+# FUNZIONE: Mini VAE generative reuse
+###########################################
+def generative_phase():
+    st.subheader("Fase 4: Generative Reuse (VAE)")
+
+    # Creiamo / inizializziamo
+    if st.session_state["vae"] is None:
+        st.session_state["vae"] = MiniVAE()
+    vae = st.session_state["vae"]
+
+    # Se non allenato, lo alleniamo su dati fittizi
+    if not st.session_state["vae_trained"]:
+        if st.button("Allena VAE su dataset fittizio di 4 feature"):
+            # Generiamo un dataset: [dim1, dim2, spess, dec]
+            rng = np.random.default_rng(123)
+            n = 500
+            dim1 = rng.normal(50,10,n)
+            dim2 = rng.normal(20,5,n)
+            spess = rng.normal(5,1,n)
+            dec = rng.uniform(0,1,n)
+            arr = np.column_stack([dim1, dim2, spess, dec])
+            X_t = torch.tensor(arr,dtype=torch.float32)
+
+            optimizer = torch.optim.Adam(vae.parameters(), lr=1e-3)
+            epochs=20
+            batch_size=32
+            dataset = torch.utils.data.TensorDataset(X_t)
+            loader = torch.utils.data.DataLoader(dataset,batch_size=batch_size,shuffle=True)
+            
+            for ep in range(epochs):
+                total_loss=0
+                for (batch,) in loader:
+                    optimizer.zero_grad()
+                    recon, mu, logvar = vae(batch)
+                    loss=vae_loss(recon, batch, mu, logvar)
+                    loss.backward()
+                    optimizer.step()
+                    total_loss += loss.item()
+            st.session_state["vae_trained"] = True
+            st.success("VAE addestrato!")
+    else:
+        st.info("VAE già addestrato.")
 
+    # Genera sample
+    if st.session_state["vae_trained"]:
+        if st.button("Genera 5 soluzioni"):
+            with torch.no_grad():
+                z = torch.randn(5,2)
+                recon = vae.decode(z)
+            arr = recon.numpy()
+            df = pd.DataFrame(arr, columns=["Dim1","Dim2","Spess","Decor"])
+            st.dataframe(df.round(2))
+            st.write("Interpretazione: Dim1, Dim2 = dimensioni, Spess=spessore, Decor=0..1 stima di ‘finitura artistica’?")
+
+###########################################
+# FUNZIONE: Overlay Estetico
+###########################################
+def overlay_phase():
+    st.subheader("Fase 5: Overlay Estetico")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        file_eol = st.file_uploader("Foto EoL", type=["jpg","png"], key="uplEolOverlay")
+    with col2:
+        file_obj = st.file_uploader("Foto Oggetto Finale", type=["jpg","png"], key="uplObjOverlay")
+
+    alpha = st.slider("Trasparenza EoL", 0.0,1.0,0.5)
+
+    if file_eol and file_obj:
+        eol_img = Image.open(file_eol).convert("RGBA")
+        obj_img = Image.open(file_obj).convert("RGBA")
+        eol_img = eol_img.resize(obj_img.size)
+        blended = Image.blend(obj_img, eol_img, alpha)
+        st.image(blended, caption="Overlay EoL + Oggetto Finale", use_column_width=True)
+    else:
+        st.info("Carica entrambe le immagini per vedere l'overlay")
+
+###########################################
+# FUNZIONE: Dashboard
+###########################################
+def dashboard_phase():
+    st.subheader("Dashboard")
+    if st.session_state["df"] is None:
+        st.error("Nessun dataset caricato/generato.")
+        return
+    df = st.session_state["df"]
+    st.write("**Info dataset**")
+    st.write(df.describe())
+
+    if "model" in st.session_state and st.session_state["model"] is not None:
+        st.write("**Modello**: RandomForest + pipeline (scaler). Se addestrato con logistic regression, stesso pipeline logic.")
+        # Non stai salvando metriche, potresti salvare accuracy e confusion matrix in session state
+        st.info("Per metrics dettagliate, vedi la fase Training.")
+    else:
+        st.warning("Modello non addestrato. Niente metriche da mostrare.")
+
+
+###########################################
+# MAIN flow
+###########################################
+if menu=="Dataset":
+    dataset_phase()
+elif menu=="Training":
+    training_phase()
+elif menu=="Inferenza":
+    inference_phase()
+elif menu=="Generative Reuse (VAE)":
+    generative_phase()
+elif menu=="Overlay Estetico":
+    overlay_phase()
+elif menu=="Dashboard":
+    dashboard_phase()