Update app.py

app.py

@@ -5,16 +5,17 @@ import torch.nn.functional as F
 import pandas as pd
 import numpy as np
 from PIL import Image
+import os
 
-# =========================
-# 1) LIBRERIA OUTPUT: possibili nuovi usi
-#   Ognuno ha un "mini embedding" e un'immagine di esempio
-# =========================
+# -------------------------------------------------------------------
+# OUTPUT-LIBRERIA: possibili destinazioni d'uso
+# con embedding fittizio e immagine di riferimento
+# -------------------------------------------------------------------
 output_libreria = {
     "ArmadioAnta": {
-        "embedding": [1.0, 0.0],   # fittizio
+        "embedding": [1.0, 0.0],
         "descrizione": "Riutilizzo come anta armadio",
-        "img": "armadio.jpg"       # se ce l'hai, o lascialo vuoto
+        "img": "armadio.jpg"
     },
     "DockRigenerato": {
         "embedding": [0.5, 0.5],
@@ -27,50 +28,81 @@ output_libreria = {
         "img": "vetrina.jpg"
     }
 }
-# In un caso reale potresti mettere molte voci, con embeddings più ricchi
-# e parametri più precisi
-
-# =========================
-# 2) MODELLO AI: un MLP
-#    Input: [volume, area, lunghezza, spessore, usura, (materiale cod?),  + output_embedding(2)]
-#    Output: punteggio compatibilità (float)
-# =========================
+
+# -------------------------------------------------------------------
+# MLP per compatibilità
+# -------------------------------------------------------------------
 class SimpleMLP(nn.Module):
     def __init__(self):
         super().__init__()
-        self.fc1 = nn.Linear(8, 16)
-        self.fc2 = nn.Linear(16, 8)
-        self.fc3 = nn.Linear(8, 1)
+        self.fc1 = nn.Linear(8,16)
+        self.fc2 = nn.Linear(16,8)
+        self.fc3 = nn.Linear(8,1)
 
     def forward(self, x):
         x = F.relu(self.fc1(x))
         x = F.relu(self.fc2(x))
-        x = torch.sigmoid(self.fc3(x))  # punteggio tra 0 e 1
+        x = torch.sigmoid(self.fc3(x))  # punteggio 0..1
         return x
 
-# =========================
-# Salviamo il modello in session_state per poterlo usare da più sezioni
-# =========================
-if "model" not in st.session_state:
-    st.session_state["model"] = SimpleMLP()
-if "trained" not in st.session_state:
-    st.session_state["trained"] = False
-
-# Ottimizziamo i param in session
-optimizer = torch.optim.Adam(st.session_state["model"].parameters(), lr=1e-3)
-
-# ============== FUNZIONE DI TRAIN FAKE ================
-def train_fake_model(epochs=20, batch_size=32):
-    """
-    Genera un dataset fittizio di EoL + output => score
-    e allena un MLP in session_state["model"].
-    """
-    # Generiamo un dataset random con 1000 esempi
-    # EoL -> (vol, area, lunghezza, spessore, usura, materialeCod)
-    # Output -> 2D embedding
-    # Score -> random 0..1 ma correlato un po' a "logica" fittizia
-    n = 1000
+# -------------------------------------------------------------------
+# VAE per "generative reuse" (mini, 4D)
+# -------------------------------------------------------------------
+class MiniVAE(nn.Module):
+    def __init__(self, input_dim=4, latent_dim=2):
+        super().__init__()
+        self.fc1 = nn.Linear(input_dim, 8)
+        self.fc21 = nn.Linear(8, latent_dim)
+        self.fc22 = nn.Linear(8, latent_dim)
+        self.fc3 = nn.Linear(latent_dim, 8)
+        self.fc4 = nn.Linear(8, 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)
+        eps = torch.randn_like(std)
+        return mu + eps*std
+
+    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)
+        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
+
+# -------------------------------------------------------------------
+# Session state
+# -------------------------------------------------------------------
+if "mlp" not in st.session_state:
+    st.session_state["mlp"] = SimpleMLP()
+if "trained_mlp" not in st.session_state:
+    st.session_state["trained_mlp"] = False
+
+if "vae" not in st.session_state:
+    st.session_state["vae"] = MiniVAE()
+if "trained_vae" not in st.session_state:
+    st.session_state["trained_vae"] = False
+
+optimizer_mlp = torch.optim.Adam(st.session_state["mlp"].parameters(), lr=1e-3)
+optimizer_vae = torch.optim.Adam(st.session_state["vae"].parameters(), lr=1e-3)
+
+# -------------------------------------------------------------------
+# Funzione training MLP (fittizio)
+# -------------------------------------------------------------------
+def train_fake_mlp(epochs=20, batch_size=32):
     rng = np.random.default_rng(42)
+    n = 1000
     vol = rng.normal(50,15,n)
     area = rng.normal(20,5,n)
     lung = rng.normal(100,30,n)
@@ -78,135 +110,232 @@ def train_fake_model(epochs=20, batch_size=32):
     usura = rng.uniform(0,1,n)
     materiale = rng.integers(0,3,n).astype(float)
 
-    # Scegli output a caso
     out_keys = list(output_libreria.keys())
-    output_idx = rng.integers(0,len(out_keys),n)
-    # costruiamo embedding 2D
-    out_emb = []
-    for i in output_idx:
-        key = out_keys[i]
-        out_emb.append(output_libreria[key]["embedding"])
-    out_emb = np.array(out_emb)
+    out_idx = rng.integers(0,len(out_keys),n)
+    out_embed = []
+    for i in out_idx:
+        emb = output_libreria[out_keys[i]]["embedding"]
+        out_embed.append(emb)
+    out_embed = np.array(out_embed)
 
     # Score fittizio
-    # Esempio: se volume < 200 e usura < 0.5 => punteggio + 
-    # + un offset se output = "ArmadioAnta" e spess < 3 => punteggio alto
     base_score = 0.5 * np.ones(n)
     base_score -= (usura * 0.3)
     base_score -= ((vol - 200)/400)
-    # se spess < 3 e out=Armadio => +0.2
-    # se out=DockRigenerato => +0.1 random
+    # Aggiustiamo se out=Armadio e spess < 3 => +0.2
     for i in range(n):
-        if out_keys[output_idx[i]]=="ArmadioAnta" and spess[i]<3:
+        if out_keys[out_idx[i]]=="ArmadioAnta" and spess[i]<3:
             base_score[i]+=0.2
-        if out_keys[output_idx[i]]=="DockRigenerato":
-            base_score[i]+=rng.uniform(0,0.1)
-    # bounding punteggio
-    base_score = np.clip(base_score,0,1)
+    base_score = np.clip(base_score, 0, 1)
 
-    X = np.column_stack([vol,area,lung,spess,usura,materiale,out_emb])
+    X = np.column_stack([vol,area,lung,spess,usura,materiale,out_embed])
     y = base_score.reshape(-1,1)
 
-    # Torch
-    X_t = torch.tensor(X, dtype=torch.float32)
-    y_t = torch.tensor(y, dtype=torch.float32)
+    X_t = torch.tensor(X,dtype=torch.float32)
+    y_t = torch.tensor(y,dtype=torch.float32)
 
-    dataset = torch.utils.data.TensorDataset(X_t, y_t)
-    loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
+    dataset = torch.utils.data.TensorDataset(X_t,y_t)
+    loader = torch.utils.data.DataLoader(dataset,batch_size=batch_size,shuffle=True)
+    model = st.session_state["mlp"]
 
-    model = st.session_state["model"]
-    # reinit param
-    def weights_init(m):
+    def reinit(m):
         if isinstance(m, nn.Linear):
             nn.init.xavier_uniform_(m.weight)
             nn.init.zeros_(m.bias)
-    model.apply(weights_init)
+    model.apply(reinit)
 
     lossf = nn.MSELoss()
     for ep in range(epochs):
-        totloss=0
+        tot=0
         for xb,yb in loader:
-            optimizer.zero_grad()
+            optimizer_mlp.zero_grad()
             pred = model(xb)
             loss=lossf(pred,yb)
             loss.backward()
-            optimizer.step()
-            totloss+=loss.item()
-    st.session_state["trained"] = True
-    return totloss
-
-# ============== UI Streamlit ================
-st.title("WEEKO – Flusso: EoL + Output-libreria + AI + Overlay Estetico")
-
-# TAB: Train AI + Avanzamento
-tab1, tab2, tab3 = st.tabs(["1) Train AI (finto)","2) Valuta EoL + Output","3) Overlay Estetico"])
-
-with tab1:
-    st.subheader("Fase 1: Train fittizio del modello AI")
-    st.write("Generiamo un dataset casuale simulando molte componenti EoL e possibili output.")
-    if st.button("🏋️ Esegui training fittizio"):
-        final_loss = train_fake_model(epochs=20)
-        st.success(f"Training completato, loss={final_loss:.4f}")
-    if st.session_state["trained"]:
-        st.info("Modello AI pronto all'uso.")
-    else:
-        st.warning("Non hai ancora addestrato il modello fittizio, i punteggi saranno casuali.")
-
-with tab2:
-    st.subheader("Fase 2: Inserisci EoL e scegli un Output")
-
-    # Carico eventuale foto EoL
-    file_eol = st.file_uploader("Foto EoL (opzionale)", type=["jpg","png"], key="eolFile2")
-    if file_eol:
-        st.image(file_eol, caption="Componente EoL", use_column_width=True)
-
-    # Dati EoL
-    vol_in = st.number_input("Volume (cm³)", 0.0, 1000.0, 100.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, 120.0)
-    spess_in = st.number_input("Spessore (mm)", 0.5, 10.0, 2.0)
-    usura_in = st.slider("Usura (0=nuovo,1=molto usurato)", 0.0,1.0,0.3)
-    mat_in = st.selectbox("Materiale", ["Plastica","Metallo","PCB"])
-    mat_code = {"Plastica":0.0,"Metallo":1.0,"PCB":2.0}[mat_in]
-
-    # Scegli un output
-    scelte = list(output_libreria.keys())
-    out_sel = st.selectbox("Scegli l'output-libreria", scelte)
-
-    if st.button("Calcola punteggio AI"):
-        model = st.session_state["model"]
-        embed = output_libreria[out_sel]["embedding"]  # 2D
-        x_np = np.array([[vol_in, area_in, lung_in, spess_in, usura_in, mat_code, embed[0], embed[1]]], dtype=np.float32)
-        x_t = torch.from_numpy(x_np)
-        with torch.no_grad():
-            pred = model(x_t).item()
-        st.info(f"Punteggio di compatibilità con '{out_sel}': {pred:.3f}")
-        if pred>0.7:
-            st.success("Ottima compatibilità! Procedi con la rigenerazione.")
-        elif pred>0.4:
-            st.warning("Compatibilità media: valuta modifiche/manuale rifinitura.")
+            optimizer_mlp.step()
+            tot+=loss.item()
+    st.session_state["trained_mlp"] = True
+    return tot
+
+# -------------------------------------------------------------------
+# Funzione training VAE (generative reuse)
+# -------------------------------------------------------------------
+def train_fake_vae(epochs=20, batch_size=32):
+    # mini VAE su 4 feature:
+    # es. [dim1, dim2, spessore, decorazione?] => generare "nuove proposte"
+    rng = np.random.default_rng(123)
+    n = 500
+    dim1 = rng.normal(50,10,n)   # es. lung dimensione
+    dim2 = rng.normal(20,5,n)    # es. larg dimensione
+    spess = rng.uniform(0.5,5,n)
+    dec = rng.uniform(0,1,n)     # "livello decoro" fittizio
+
+    data = np.column_stack([dim1,dim2,spess,dec])
+    data_t = torch.tensor(data,dtype=torch.float32)
+    dataset = torch.utils.data.TensorDataset(data_t)
+    loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
+
+    vae = st.session_state["vae"]
+    def reinit_vae(m):
+        if isinstance(m,nn.Linear):
+            nn.init.xavier_uniform_(m.weight)
+            nn.init.zeros_(m.bias)
+    vae.apply(reinit_vae)
+
+    lossf = vae_loss
+    for ep in range(epochs):
+        total=0
+        for (xb,) in loader:
+            optimizer_vae.zero_grad()
+            recon, mu, logvar = vae(xb)
+            loss=lossf(recon, xb, mu, logvar)
+            loss.backward()
+            optimizer_vae.step()
+            total+=loss.item()
+    st.session_state["trained_vae"] = True
+    return total
+
+# -------------------------------------------------------------------
+# Funzione per salvare feedback
+# -------------------------------------------------------------------
+def salva_feedback(eol_desc, out_desc, punteggio, decisione):
+    # Scrive su un CSV fittizio
+    row = f"{eol_desc},{out_desc},{punteggio:.2f},{decisione}\n"
+    with open("feedback.csv","a") as f:
+        f.write(row)
+
+# -------------------------------------------------------------------
+# STREAMLIT APP
+# -------------------------------------------------------------------
+st.set_page_config(page_title="Weeko Incrementale", layout="wide")
+st.title("WEEKO – App Incrementale")
+
+tabs = st.tabs(["1) Train AI","2) Valuta EoL + Output","3) Overlay Estetico","4) Generative Reuse","5) Feedback"])
+
+# ---------------------------
+# TAB 1 - Train AI
+# ---------------------------
+with tabs[0]:
+    st.subheader("Fase 1: Train AI fittizio")
+    colA, colB = st.columns(2)
+    with colA:
+        if st.button("🏋️ Train MLP x compatibilità"):
+            final_loss = train_fake_mlp(epochs=20)
+            st.success(f"MLP trained, last loss={final_loss:.2f}")
+    with colB:
+        if st.button("🎨 Train VAE x generative reuse"):
+            final_loss2 = train_fake_vae(epochs=20)
+            st.success(f"VAE trained, last loss={final_loss2:.2f}")
+
+    st.write("**MLP** = calcolo compatibilità EoL → output. **VAE** = generazione nuove soluzioni (ingombri, spessore, decorazione).")
+    if os.path.exists("feedback.csv"):
+        st.write("Feedback attuale:")
+        st.code(open("feedback.csv","r").read())
+
+# ---------------------------
+# TAB 2 - Valuta EoL + Output
+# ---------------------------
+with tabs[1]:
+    st.subheader("Fase 2: Inserisci EoL e seleziona output-libreria (AI MLP)")
+
+    file_eol_2 = st.file_uploader("Foto EoL (opzionale)", type=["jpg","png"], key="Eol2")
+    if file_eol_2:
+        st.image(file_eol_2, caption="Componente EoL", use_column_width=True)
+
+    vol = st.number_input("Volume (cm³)",0.0,1000.0,100.0)
+    area= st.number_input("Area (cm²)",0.0,500.0,50.0)
+    lung= st.number_input("Lunghezza (mm)",0.0,2000.0,120.0)
+    spess= st.number_input("Spessore (mm)",0.5,10.0,2.0)
+    usura= st.slider("Usura",0.0,1.0,0.3)
+    mat = st.selectbox("Materiale",["Plastica","Metallo","PCB"])
+    mat_code = {"Plastica":0.0,"Metallo":1.0,"PCB":2.0}[mat]
+
+    out_choices = list(output_libreria.keys())
+    out_sel = st.selectbox("Scegli Output-libreria", out_choices)
+
+    if st.button("Calcola punteggio compatibilità MLP"):
+        if not st.session_state["trained_mlp"]:
+            st.warning("MLP non addestrato, premi su 'Train MLP' nel Tab 1")
         else:
-            st.error("Compatibilità bassa, meglio cambiare output o scartare.")
+            model = st.session_state["mlp"]
+            emb = output_libreria[out_sel]["embedding"]
+            x_np = np.array([[vol,area,lung,spess,usura,mat_code,emb[0],emb[1]]],dtype=np.float32)
+            x_t = torch.from_numpy(x_np)
+            with torch.no_grad():
+                score = model(x_t).item()
+            st.info(f"Punteggio = {score:.3f}")
+            if score>0.7:
+                st.success("Alta compatibilità! Procedi pure.")
+            elif score>0.4:
+                st.warning("Compatibilità media, valuta modifiche.")
+            else:
+                st.error("Compatibilità bassa, magari scegli un altro output")
 
-with tab3:
-    st.subheader("Fase 3: Overlay Estetico")
-    st.write("Carica la foto EoL e la foto dell'Output finale per un effetto wow. (Puramente estetico)")
+# ---------------------------
+# TAB 3 - Overlay Estetico
+# ---------------------------
+with tabs[2]:
+    st.subheader("Fase 3: Overlay Estetico (effetto wow)")
 
     col1, col2 = st.columns(2)
     with col1:
-        file_eol_3 = st.file_uploader("Foto EoL", type=["jpg","png"], key="uplEol3")
+        eol_file = st.file_uploader("Foto EoL", type=["jpg","png"], key="overlayEol")
     with col2:
-        file_out_3 = st.file_uploader("Foto Oggetto Finale (es. Armadio?)", type=["jpg","png"], key="uplOut3")
+        final_file = st.file_uploader("Foto Oggetto Finale (es. armadio, scaffale..)", type=["jpg","png"], key="overlayFinal")
+
+    alpha = st.slider("Trasparenza EoL",0.0,1.0,0.5)
+
+    if eol_file and final_file:
+        eol_img = Image.open(eol_file).convert("RGBA")
+        fin_img = Image.open(final_file).convert("RGBA")
+        eol_img = eol_img.resize(fin_img.size)
+        blend = Image.blend(fin_img,eol_img,alpha)
+        st.image(blend, caption="Overlay EoL + Oggetto", use_column_width=True)
+    else:
+        st.info("Carica entrambe le immagini per l'overlay")
+
+# ---------------------------
+# TAB 4 - Generative Reuse (VAE)
+# ---------------------------
+with tabs[3]:
+    st.subheader("Fase 4: Generative Reuse con VAE")
+
+    st.write("**Obiettivo**: generare 'idee' di configurazioni (dim1, dim2, spess, decoro) per nuovi usi.")
+    if not st.session_state["trained_vae"]:
+        st.warning("VAE non addestrato, premi su 'Train VAE' nel Tab 1.")
+    else:
+        if st.button("Genera 5 configurazioni random dal VAE"):
+            vae = st.session_state["vae"]
+            # generiamo 5 sample random in latent space
+            z = torch.randn(5,2)  # latent_dim=2
+            with torch.no_grad():
+                samples = vae.decode(z)
+            arr = samples.numpy()
+            df = pd.DataFrame(arr, columns=["Dim1","Dim2","Spess","Decoro"])
+            st.dataframe(df.round(2))
+            st.info("Idee: potresti interpretare Dim1,Dim2 come lung/larg, Spess=spessore, Decoro=0..1 styling?")
+
+# ---------------------------
+# TAB 5 - Feedback
+# ---------------------------
+with tabs[4]:
+    st.subheader("Fase 5: Raccolta Feedback dell'utente")
+    st.write("Se hai calcolato un punteggio di compatibilità e vuoi salvare la tua decisione, fallo qui.")
 
-    alpha_val = st.slider("Trasparenza EoL", 0.0,1.0,0.5)
+    # Input testuale su EoL, output, punteggio e decisione
+    eol_desc = st.text_input("Descrizione EoL (es. lamiera 100x50)","lamiera 100x50")
+    out_desc = st.text_input("Output scelto","ArmadioAnta")
+    punteggio = st.number_input("Punteggio (0..1)",0.0,1.0,0.7)
+    dec = st.selectbox("Decisione",["Approvato","Rifiutato","In attesa"])
 
-    if file_eol_3 and file_out_3:
-        eol_img = Image.open(file_eol_3).convert("RGBA")
-        out_img = Image.open(file_out_3).convert("RGBA")
-        # ridimensioniamo la EoL all'immagine dell'oggetto
-        eol_img = eol_img.resize(out_img.size)
+    if st.button("Salva feedback"):
+        salva_feedback(eol_desc, out_desc, punteggio, dec)
+        st.success("Feedback salvato in feedback.csv!")
 
-        blend = Image.blend(out_img, eol_img, alpha_val)
-        st.image(blend, caption="Overlay EoL + Oggetto Finale", use_column_width=True)
+    # Mostra file di feedback
+    if os.path.exists("feedback.csv"):
+        st.write("Feedback attuale:")
+        txt = open("feedback.csv","r").read()
+        st.code(txt)
     else:
-        st.info("Attendi di caricare entrambe le immagini per vedere l'overlay.")
+        st.info("Nessun feedback.csv presente.")