Create app.py

app.py

@@ -0,0 +1,418 @@
+# ================================================================
+# ANP Model | HF Free Tier (16GB CPU) | Background Training Daemon
+# ================================================================
+import os, time, math, random, uuid, threading
+from typing import List, Dict
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader
+from torch.optim import AdamW
+from torch.optim.lr_scheduler import CosineAnnealingLR
+from transformers import BertTokenizerFast
+
+import gradio as gr
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+random.seed(42)
+torch.manual_seed(42)
+
+# ── Config & Globals ──────────────────────────────────────────
+DEVICE     = torch.device("cpu") # HF Free tier is CPU
+MSG_TYPES  = ["offer", "counter", "accept", "reject", "exit", "stall"]
+MSG2IDX    = {m: i for i, m in enumerate(MSG_TYPES)}
+IDX2MSG    = {i: m for m, i in MSG2IDX.items()}
+CATEGORIES = ["used_car","domain_name","freelance_design","saas_license","electronics","bulk_groceries","consulting"]
+CAT2IDX    = {c: i for i, c in enumerate(CATEGORIES)}
+
+MAX_LEN  = 256
+D_MODEL  = 384
+N_HEADS  = 6
+N_LAYERS = 6
+FFN_DIM  = 1024
+
+print("Loading tokenizer...")
+tokenizer = BertTokenizerFast.from_pretrained("bert-base-uncased")
+
+# ── Thread-Safe State Manager ─────────────────────────────────
+class TrainingState:
+    def __init__(self):
+        self.lock = threading.Lock()
+        self.is_running = False
+        self.current_epoch = 0
+        self.total_epochs = 0
+        self.batch_progress = ""
+        self.logs = []
+        self.losses = []
+        self.model_ready = False
+
+    def log(self, msg: str):
+        with self.lock:
+            ts = time.strftime("%H:%M:%S")
+            self.logs.append(f"[{ts}] {msg}")
+            if len(self.logs) > 50: # Keep dashboard clean
+                self.logs.pop(0)
+            print(msg)
+
+STATE = TrainingState()
+GLOBAL_MODEL = None # Holds the model in memory for inference
+
+# ── Synthetic Data Generator ──────────────────────────────────
+def generate_sessions(n_sessions: int) -> List[Dict]:
+    """Generates synthetic negotiation data quickly in memory."""
+    all_rows = []
+    cats = list(CATEGORIES)
+    
+    # Simple templates for generator (training text)
+    _SO = ["{item} for sale. Asking ${p:,.0f}.", "Listing {item} at ${p:,.0f}."]
+    _SC = ["Best I can do is ${p:,.0f}.", "Can come down to ${p:,.0f}."]
+    _SS = ["Let me think about it.", "Need to check with my partner."]
+    _SA = ["Deal at ${p:,.0f}.", "Agreed. ${p:,.0f}."]
+    _BC = ["Offering ${p:,.0f}.", "${p:,.0f} is my ceiling."]
+    _BE = ["Too far apart. Going to pass.", "Price doesn't work for me."]
+    
+    def _t(templates, item="", p=0):
+        return random.choice(templates).format(item=item, p=p)
+
+    for _ in range(n_sessions):
+        cat = random.choice(cats)
+        item = f"Generic {cat} Item"
+        lp = round(random.uniform(500, 10000), -1)
+        sid = f"SYN-{uuid.uuid4().hex[:6].upper()}"
+        turn = 0
+        session_rows = []
+
+        def add(party, price, mtype, msg):
+            nonlocal turn
+            turn += 1
+            session_rows.append({
+                "session_id": sid, "turn_number": turn, "party": party,
+                "category": cat, "item": item, "list_price": lp,
+                "offer_price": price, "msg_type": mtype, "message": msg
+            })
+
+        sp = lp
+        bp = round(lp * random.uniform(0.6, 0.8), -1)
+        
+        add(0, sp, "offer", _t(_SO, item=item, p=sp))
+        add(1, bp, "counter", _t(_BC, p=bp))
+
+        target = random.choice(["accepted", "abandoned", "rejected"])
+        for _ in range(random.randint(2, 6)):
+            gap = sp - bp
+            if target == "accepted" and (gap / lp) < 0.05:
+                final_p = round((sp + bp) / 2, -1)
+                add(0 if random.random() < 0.5 else 1, final_p, "accept", _t(_SA, p=final_p))
+                break
+            if target == "abandoned" and random.random() < 0.2:
+                add(0, sp, "stall", _t(_SS))
+                add(1, bp, "exit", _t(_BE))
+                break
+                
+            sp = max(bp + gap * 0.3, sp - lp * random.uniform(0.02, 0.05))
+            sp = round(sp, -1)
+            add(0, sp, "counter", _t(_SC, p=sp))
+            
+            gap = sp - bp
+            if target == "accepted" and (gap / lp) < 0.05:
+                final_p = round((sp + bp) / 2, -1)
+                add(1, final_p, "accept", _t(_SA, p=final_p))
+                break
+                
+            bp = min(sp - gap * 0.3, bp + lp * random.uniform(0.02, 0.05))
+            bp = round(bp, -1)
+            add(1, bp, "counter", _t(_BC, p=bp))
+        else:
+            add(1, bp, "exit", _t(_BE))
+            
+        all_rows.extend(session_rows)
+    return all_rows
+
+# ── Dataset & Model ───────────────────────────────────────────
+class NegotiationDataset(Dataset):
+    def __init__(self, rows: List[Dict]):
+        self.samples = []
+        sessions = {}
+        for r in rows:
+            sessions.setdefault(r["session_id"], []).append(r)
+
+        for turns in sessions.values():
+            turns = sorted(turns, key=lambda x: int(x["turn_number"]))
+            lp = float(turns[0]["list_price"])
+            if lp <= 0: continue
+            
+            for i in range(1, len(turns)):
+                hist = turns[:i]
+                tgt = turns[i]
+                text = " [SEP] ".join(f"{'Seller' if t['party']==0 else 'Buyer'}: {t['message']}" for t in hist)
+                self.samples.append({
+                    "text": text,
+                    "party": int(tgt["party"]),
+                    "category": CAT2IDX.get(tgt["category"], 0),
+                    "ofn": min(float(tgt["offer_price"]) / lp, 3.0),
+                    "tn": min(int(tgt["turn_number"]) / 20.0, 1.0),
+                    "msg_type": MSG2IDX.get(tgt["msg_type"], 1),
+                    "price_t": min(float(tgt["offer_price"]) / lp, 3.0),
+                })
+
+    def __len__(self): return len(self.samples)
+    def __getitem__(self, idx):
+        s = self.samples[idx]
+        enc = tokenizer(s["text"], max_length=MAX_LEN, padding="max_length", truncation=True, return_tensors="pt")
+        return {
+            "input_ids": enc["input_ids"].squeeze(0),
+            "attn_mask": enc["attention_mask"].squeeze(0),
+            "party": torch.tensor(s["party"], dtype=torch.long),
+            "category": torch.tensor(s["category"], dtype=torch.long),
+            "ofn": torch.tensor(s["ofn"], dtype=torch.float),
+            "tn": torch.tensor(s["tn"], dtype=torch.float),
+            "msg_type": torch.tensor(s["msg_type"], dtype=torch.long),
+            "price_t": torch.tensor(s["price_t"], dtype=torch.float),
+        }
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, d: int, max_len: int = 512):
+        super().__init__()
+        self.drop = nn.Dropout(0.1)
+        pe = torch.zeros(max_len, d)
+        pos = torch.arange(max_len).unsqueeze(1).float()
+        div = torch.exp(torch.arange(0, d, 2).float() * (-math.log(10000.0) / d))
+        pe[:, 0::2] = torch.sin(pos * div)
+        pe[:, 1::2] = torch.cos(pos * div)
+        self.register_buffer("pe", pe.unsqueeze(0))
+
+    def forward(self, x): return self.drop(x + self.pe[:, :x.size(1)])
+
+class NegotiationTransformer(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.emb = nn.Embedding(30522, D_MODEL, padding_idx=0)
+        self.pos = PositionalEncoding(D_MODEL)
+        enc_layer = nn.TransformerEncoderLayer(D_MODEL, N_HEADS, FFN_DIM, dropout=0.1, batch_first=True, norm_first=True)
+        self.encoder = nn.TransformerEncoder(enc_layer, N_LAYERS)
+        self.p_emb = nn.Embedding(2, 32)
+        self.c_emb = nn.Embedding(len(CATEGORIES), 64)
+        self.fusion = nn.Sequential(nn.Linear(D_MODEL + 32 + 64 + 2, D_MODEL), nn.GELU())
+        self.msg_head = nn.Linear(D_MODEL, len(MSG_TYPES))
+        self.px_head = nn.Sequential(nn.Linear(D_MODEL, 128), nn.GELU(), nn.Linear(128, 1), nn.Softplus())
+
+    def forward(self, ids, mask, party, cat, ofn, tn):
+        x = self.pos(self.emb(ids))
+        x = self.encoder(x, src_key_padding_mask=(mask == 0))
+        cls = x[:, 0]
+        f = self.fusion(torch.cat([cls, self.p_emb(party), self.c_emb(cat), torch.stack([ofn, tn], dim=1)], dim=1))
+        return self.msg_head(f), self.px_head(f).squeeze(1)
+
+# ── Background Training Daemon ────────────────────────────────
+def _training_thread_target(n_sessions: int, epochs: int, batch_size: int, lr: float):
+    global GLOBAL_MODEL
+    try:
+        STATE.log(f"Starting data generation: {n_sessions:,} sessions (~{n_sessions*5:,} rows)")
+        
+        # Generation runs in main memory, yields CPU often enough
+        rows = generate_sessions(n_sessions)
+        STATE.log(f"Data generated. Tokenizing into dataset...")
+        
+        dataset = NegotiationDataset(rows)
+        loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=0)
+        
+        STATE.log(f"Dataset ready: {len(dataset):,} samples. Initializing Model...")
+        model = NegotiationTransformer().to(DEVICE)
+        
+        opt = AdamW(model.parameters(), lr=lr, weight_decay=1e-2)
+        sch = CosineAnnealingLR(opt, T_max=epochs)
+        ce, mse = nn.CrossEntropyLoss(), nn.MSELoss()
+        
+        with STATE.lock:
+            STATE.total_epochs = epochs
+            STATE.losses = []
+        
+        STATE.log("Entering Training Loop (CPU mode).")
+        total_batches = len(loader)
+        
+        for ep in range(epochs):
+            model.train()
+            ep_loss = 0.0
+            with STATE.lock:
+                STATE.current_epoch = ep + 1
+            
+            for i, batch in enumerate(loader):
+                if i % max(1, total_batches // 10) == 0:
+                    with STATE.lock:
+                        STATE.batch_progress = f"Epoch {ep+1}/{epochs} | Batch {i}/{total_batches}"
+                        
+                opt.zero_grad()
+                mt_logits, px_pred = model(
+                    batch["input_ids"].to(DEVICE), batch["attn_mask"].to(DEVICE),
+                    batch["party"].to(DEVICE), batch["category"].to(DEVICE),
+                    batch["ofn"].to(DEVICE), batch["tn"].to(DEVICE)
+                )
+                loss = ce(mt_logits, batch["msg_type"].to(DEVICE)) + 0.5 * mse(px_pred, batch["price_t"].to(DEVICE))
+                loss.backward()
+                nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+                opt.step()
+                ep_loss += loss.item()
+                
+            sch.step()
+            avg_loss = ep_loss / max(total_batches, 1)
+            
+            with STATE.lock:
+                STATE.losses.append(avg_loss)
+            STATE.log(f"Epoch {ep+1} complete. Loss: {avg_loss:.4f}")
+
+        STATE.log("Training complete. Applying weights to Global Model.")
+        model.eval()
+        GLOBAL_MODEL = model
+        with STATE.lock:
+            STATE.model_ready = True
+            
+    except Exception as e:
+        STATE.log(f"ERROR: {str(e)}")
+    finally:
+        with STATE.lock:
+            STATE.is_running = False
+
+def start_training(n_sessions, epochs, batch_size, lr):
+    with STATE.lock:
+        if STATE.is_running:
+            return "Training is already running!"
+        STATE.is_running = True
+        STATE.logs = []
+        STATE.batch_progress = "Initializing..."
+        
+    t = threading.Thread(target=_training_thread_target, args=(int(n_sessions), int(epochs), int(batch_size), float(lr)), daemon=True)
+    t.start()
+    return "Background training thread triggered."
+
+# ── Inference with Pre-built Templates ────────────────────────
+def _get_template_message(msg_type: str, price: float, item: str, is_buyer: bool) -> str:
+    """The 'Mouth': Translates the Model's strategy (msg_type, price) into prose."""
+    px = f"${price:,.2f}"
+    if is_buyer:
+        templates = {
+            "offer":   f"I'll start the bidding at {px} for the {item}.",
+            "counter": random.choice([f"I can offer {px}.", f"How about {px}?", f"My counter is {px}."]),
+            "accept":  f"{px} works for me. I'll take it.",
+            "reject":  "That's too high for my budget, I have to pass.",
+            "stall":   "I need to check my budget and get back to you.",
+            "exit":    "We're too far apart. Moving on."
+        }
+    else:
+        templates = {
+            "offer":   f"I'm looking to get {px} for the {item}.",
+            "counter": random.choice([f"I can drop to {px}.", f"Best I can do right now is {px}.", f"Let's meet at {px}."]),
+            "accept":  f"You got a deal at {px}.",
+            "reject":  "I can't go that low.",
+            "stall":   "Let me see if I have other offers first.",
+            "exit":    "I can't sell it for that. Goodbye."
+        }
+    return templates.get(msg_type, f"Action: {msg_type} at {px}")
+
+def predict(category, item, list_price, current_offer, history_text, party_str):
+    if GLOBAL_MODEL is None:
+        return "Model not trained yet. Run training tab first.", "", "", ""
+        
+    try:
+        lp, cp = float(list_price), float(current_offer)
+        is_buyer = (party_str == "Buyer")
+        pty = 1 if is_buyer else 0
+        
+        enc = tokenizer(history_text or "(start)", max_length=MAX_LEN, padding="max_length", truncation=True, return_tensors="pt")
+        turns = len([l for l in history_text.strip().split("\n") if l.strip()])
+        
+        p = torch.tensor([pty], dtype=torch.long)
+        c = torch.tensor([CAT2IDX.get(category, 0)], dtype=torch.long)
+        ofn = torch.tensor([min(cp/lp, 3.0)], dtype=torch.float)
+        tn = torch.tensor([min(turns/20.0, 1.0)], dtype=torch.float)
+
+        with torch.no_grad():
+            mt_logits, px = GLOBAL_MODEL(enc["input_ids"], enc["attention_mask"], p, c, ofn, tn)
+
+        mt_idx = mt_logits.argmax(dim=1).item()
+        msg_out = IDX2MSG[mt_idx]
+        price_out = round(px.item() * lp, 2)
+        
+        prose_msg = _get_template_message(msg_out, price_out, item, is_buyer)
+        probs = F.softmax(mt_logits, dim=1).squeeze().tolist()
+        prob_str = " | ".join(f"{MSG_TYPES[i]}: {probs[i]:.2f}" for i in range(len(MSG_TYPES)))
+        
+        return msg_out, f"${price_out:,.2f}", prose_msg, prob_str
+    except Exception as e:
+        return "Error", "", str(e), ""
+
+# ── Dashboard UI (Polling) ────────────────────────────────────
+def refresh_dashboard():
+    with STATE.lock:
+        is_run = STATE.is_running
+        status = "🟢 ACTIVE - " + STATE.batch_progress if is_run else "🔴 IDLE"
+        log_text = "\n".join(STATE.logs)
+        losses = list(STATE.losses)
+        ready = "✅ Ready" if STATE.model_ready else "❌ Needs Training"
+        
+    fig, ax = plt.subplots(figsize=(6, 3))
+    if losses:
+        ax.plot(range(1, len(losses)+1), losses, "b-o", markersize=4)
+        ax.set_title("Training Loss")
+    else:
+        ax.text(0.5, 0.5, 'No data yet', ha='center', va='center', alpha=0.5)
+    ax.grid(alpha=0.3)
+    plt.tight_layout()
+    
+    return status, log_text, fig, ready
+
+# ── Gradio ────────────────────────────────────────────────────
+with gr.Blocks(title="ANP | HF Daemon Trainer", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# ANP Background Trainer\nTrains on the HF free CPU via a background thread while you watch.")
+
+    with gr.Tab("Dashboard & Training"):
+        with gr.Row():
+            n_sessions = gr.Number(value=40000, label="Sessions (~200k rows)")
+            epochs     = gr.Slider(1, 20, value=5, step=1, label="Epochs")
+            batch_size = gr.Slider(16, 256, value=64, step=16, label="Batch Size")
+            lr         = gr.Number(value=5e-4, label="Learning Rate")
+            
+        tr_btn = gr.Button("🚀 Start Background Training", variant="primary")
+        
+        gr.Markdown("### Real-Time Status *(Polls automatically)*")
+        status_box = gr.Textbox(label="Thread Status", interactive=False)
+        with gr.Row():
+            log_box = gr.Textbox(label="System Logs", lines=12, interactive=False)
+            plt_out = gr.Plot(label="Loss Curve")
+
+        # Gradio Timer continuously updates the dashboard every 3 seconds
+        gr.Timer(3, active=True).tick(
+            fn=refresh_dashboard, 
+            outputs=[status_box, log_box, plt_out, gr.Textbox(visible=False)]
+        )
+
+    with gr.Tab("Inference Sandbox"):
+        ready_indicator = gr.Textbox(label="Model Status", interactive=False)
+        gr.Timer(5, active=True).tick(fn=lambda: "✅ Ready" if STATE.model_ready else "❌ Needs Training", outputs=[ready_indicator])
+        
+        with gr.Row():
+            d_cat = gr.Dropdown(CATEGORIES, value="used_car", label="Category")
+            d_pty = gr.Radio(["Seller","Buyer"], value="Buyer", label="Party to Simulate")
+        with gr.Row():
+            d_lp  = gr.Number(value=18500, label="List Price ($)")
+            d_co  = gr.Number(value=16000, label="Current Offer ($)")
+            
+        d_item = gr.Textbox(value="2019 Honda Civic", label="Item Name (for template)")
+        d_hist = gr.Textbox(lines=4, label="Turn History", placeholder="Seller: Asking $18,500.\nBuyer: I can do $15,000.")
+        
+        d_btn = gr.Button("Generate Move & Message", variant="primary")
+        
+        with gr.Row():
+            d_msg = gr.Textbox(label="Action Head")
+            d_px  = gr.Textbox(label="Pricing Head")
+        d_prose = gr.Textbox(label="Generated Message (Template)", lines=2)
+        d_prob  = gr.Textbox(label="Action Probabilities")
+        
+        d_btn.click(predict, inputs=[d_cat, d_item, d_lp, d_co, d_hist, d_pty], outputs=[d_msg, d_px, d_prose, d_prob])
+        
+    tr_btn.click(start_training, inputs=[n_sessions, epochs, batch_size, lr], outputs=[status_box])
+
+# Launch blocking the main thread, daemons will run in background
+demo.launch(server_name="0.0.0.0", server_port=7860)