Update app.py

app.py

@@ -249,8 +249,6 @@ for ep in range(1, EPOCHS + 1):
     if ep % 5 == 0:
         lr_now = opt.param_groups[0]["lr"]
         extra = f" hor={stats_va.get('maeH', float('nan')):.3f}" if "maeH" in stats_va else ""
-        print(f"epoch {ep:03d} | lr={lr_now:.2e} | train_loss={tot_loss:.3f} | "
-              f"val MAE: imp={stats_va['maeI']:.3f} dur={stats_va['maeD']:.3f}{extra}")
 
     # ---- early stopping on summed MAE ----
     if total_val < best_val - 1e-4:
@@ -260,7 +258,6 @@ for ep in range(1, EPOCHS + 1):
     else:
         bad += 1
         if bad >= patience:
-            print("early stopping.")
             break
 
 # ---- TEST with best checkpoint ----
@@ -270,10 +267,6 @@ stats_te = eval_block(
     (H_te_all_t if H_te_all_t is not None else None),
     (mH_te_t    if mH_te_t    is not None else None)
 )
-print("[TEST] MAE imp={maeI:.3f} (rho={rhoI:.3f}) | MAE dur={maeD:.3f} (rho={rhoD:.3f})".format(**stats_te))
-if "maeH" in stats_te:
-    print("[TEST] MAE hor={maeH:.3f} (rho={rhoH:.3f})".format(**stats_te))
-print("saved model -> mtl_net.pt")
 
 # ============================================================
 # 0) Setup: device, seeds, helper
@@ -324,8 +317,6 @@ i_tr = idx[:n_train]
 i_va = idx[n_train:n_train+n_val]
 i_te = idx[n_train+n_val:]
 
-print(f"[Split] train={len(i_tr)}  val={len(i_va)}  test={len(i_te)}")
-
 # ============================================================
 # 2) Standardize X using ONLY the train set, then tensorize
 # ============================================================
@@ -348,8 +339,6 @@ else:
     H_tr_all_t = H_va_all_t = H_te_all_t = None
     mH_tr_t = mH_va_t = mH_te_t = None
 
-print(f"[Check tensors] Xt_tr={Xt_tr.shape} Xt_va={Xt_va.shape} Xt_te={Xt_te.shape}")
-
 # ============================================================
 # 3) Model: Multi-Task MLP (shared trunk + 3 heads)
 #    Slightly wider trunk; textbook uncertainty weighting (0.5 factor)
@@ -484,9 +473,6 @@ for ep in range(1, EPOCHS + 1):
     if ep % 5 == 0:
         lr_now = opt.param_groups[0]["lr"]
         extraH = f" hor={stats_va.get('maeH', float('nan')):.3f}" if "maeH" in stats_va else ""
-        print(f"epoch {ep:03d} | lr={lr_now:.2e} | train_loss={tot_loss:.3f} | "
-              f"val MAE: imp={stats_va['maeI']:.3f} dur={stats_va['maeD']:.3f}{extraH} | "
-              f"rhoI={stats_va['rhoI']:.3f} rhoD={stats_va['rhoD']:.3f}")
 
     # ---- early stopping on summed MAE ----
     if total_val < best_val - 1e-4:
@@ -496,13 +482,11 @@ for ep in range(1, EPOCHS + 1):
     else:
         bad += 1
         if bad >= patience:
-            print("early stopping.")
             break
 
 # ============================================================
 # 6) TEST with best checkpoint + final confirmation
 # ============================================================
-print(f"[Final split check] train={Xt_tr.shape[0]}  val={Xt_va.shape[0]}  test={Xt_te.shape[0]}")
 
 net.load_state_dict(torch.load("mtl_net.pt", map_location=device))
 stats_te = eval_block(
@@ -510,10 +494,6 @@ stats_te = eval_block(
     (H_te_all_t if H_te_all_t is not None else None),
     (mH_te_t    if mH_te_t    is not None else None)
 )
-print("[TEST] MAE imp={maeI:.3f} (rho={rhoI:.3f}) | MAE dur={maeD:.3f} (rho={rhoD:.3f})".format(**stats_te))
-if "maeH" in stats_te:
-    print("[TEST] MAE hor={maeH:.3f} (rho={rhoH:.3f})".format(**stats_te))
-print("saved model -> mtl_net.pt")
 
 from datetime import datetime, timedelta, timezone
 import numpy as np
@@ -615,10 +595,14 @@ def priority_score(I, H_hours, due_dt, now=None, wI=0.70, wDeadline=0.25, wDur=0
     p01 = wI*(float(I)/10.0) + wDeadline*deadline_pressure + wDur*dur_pressure
     return round(1 + 9*p01, 1)
 
+from datetime import datetime, timezone
+
 def reorder_tasks(tasks_string, user_due_iso=None):
+    now = datetime.now(timezone.utc)
     tasks = [t.strip() for t in str(tasks_string).splitlines() if t.strip()]
     if not tasks:
-        return "", ""
+        # Return empty boxes and clear checkboxes
+        return "", "", "", gr.update(choices=[], value=[])
 
     # split/normalize user dates (string or list)
     if isinstance(user_due_iso, str) or user_due_iso is None:
@@ -643,34 +627,33 @@ def reorder_tasks(tasks_string, user_due_iso=None):
     with torch.no_grad():
         rI, rD, rH = net(torch.from_numpy(Xs).to(device))
         I  = torch.clamp(rI, 1.0, 10.0).cpu().numpy()
-        H  = torch.expm1(rD).clamp(0.25, 12.0).cpu().numpy()
-        Hd = torch.expm1(rH).clamp(0.0, 30.0).cpu().numpy()
+        H  = torch.expm1(rD).clamp(0.25, 12.0).cpu().numpy()    # duration (hrs), 0.25–12
+        Hd = torch.expm1(rH).clamp(0.0, 30.0).cpu().numpy()     # horizon (days), 0–30
 
     now = datetime.now(timezone.utc)
     assumed_local_tz = timezone.utc
 
     rows = []
     for t, due_s, i_imp, h_hrs, h_days in zip(tasks, due_lines, I, H, Hd):
-        # parse user date to UTC and keep whether it had time
+        # parse user date (if provided)
         due_user_utc, had_time = parse_user_due_utc(due_s, local_tz=assumed_local_tz) if due_s else (None, False)
 
-        # due used for scoring
+        # choose due_for_scores and display string
         if due_user_utc is not None:
             due_for_scores = due_user_utc
             display_due_str = _fmt_utc_for_display(due_user_utc, had_time)
         else:
             due_for_scores = _due_from_model(now, float(h_days)) or _due_from_heuristic(now, float(i_imp), float(h_hrs))
-            # suggested is always shown as UTC date
             display_due_str = _fmt_utc_for_display(due_for_scores, False)
 
-        hours_left = max((due_for_scores - now).total_seconds()/3600.0, 0.5)
-        U = float(np.clip(np.log1p(float(h_hrs)/hours_left), 0.0, 1.0))
+        # priority score
         P = priority_score(float(i_imp), float(h_hrs), due_for_scores, now=now)
 
         rows.append({
             "task": t,
             "display_due": display_due_str,
             "suggested_due_iso": due_for_scores.isoformat(),
+            "duration_hrs": float(h_hrs),       # keep raw number for sorting/formatting
             "priority_1to10": P,
         })
 
@@ -678,73 +661,75 @@ def reorder_tasks(tasks_string, user_due_iso=None):
         ["priority_1to10", "suggested_due_iso"], ascending=[False, True]
     ).reset_index(drop=True)
 
-    task_lines = "\n".join(out["task"].tolist())
-    due_lines_out = "\n".join(out["display_due"].tolist())
-    return task_lines, due_lines_out
+    choices = [f"{i+1}. {t}" for i, t in enumerate(out["task"].tolist())]
+
+    # Prepare the three text outputs
+    task_lines     = "\n".join(out["task"].tolist())
+    due_lines_out  = "\n".join(out["display_due"].tolist())
+    duration_lines = "\n".join(f"{d:.1f}" for d in out["duration_hrs"].tolist())
+
+    # IMPORTANT: don't wipe user selections each run
+    checkbox_update = gr.update(choices=choices)
+
+    return task_lines, due_lines_out, duration_lines, checkbox_update
 
 import re
 
-import gradio # For building the interface
+import gradio as gr # For building the interface
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Automated Task Prioritizer")
+    gr.Markdown("This app will take your to-do list and reorder it based on importance, urgency, and duration.")
+
+    with gr.Tab("Task Entry"):
+        with gr.Row():
+            sample_tasks = gr.Textbox(label="Task List", lines=10, placeholder="One task per line")
+            due_dates    = gr.Textbox(label="Due Date", lines=10, placeholder="One date per line (optional)")
+
+        run_btn = gr.Button("Prioritize")
+
+        gr.Examples(
+            examples=[[
+                "finish lab report before monday\n"
+                "email TA about grading\n"
+                "practice dance combo 20 minutes\n"
+                "apply to 3 jobs\n"
+                "review calculus problem set (10 problems)\n"
+                "call dentist to schedule appointment\n"
+                "draft 1-page cover letter\n"
+                "wash dishes\n"
+                "organize notes for history essay\n"
+                "watch tv show",
+                "10/6/25\n"
+                "10/4/25\n"
+                "10/4/25\n"
+                "\n"
+                "10/8/25\n"
+                "10/3/25\n"
+                "10/11/25\n"
+                "10/3/25\n"
+                "10/5/25\n"
+            ]],
+            inputs=[sample_tasks, due_dates],
+            label="Example",
+            examples_per_page=1,
+            cache_examples=False,
+        )
 
-with gradio.Blocks() as demo:
+    with gr.Tab("Prioritized List"):
+      with gr.Row():
+          priority_task  = gr.Textbox(label="Prioritized Task List", lines=10, interactive=False)
+          date_box       = gr.Textbox(label="Due Date", lines=10, interactive=False)
+          durations_box  = gr.Textbox(label="Duration (hrs)", lines=10, interactive=False)
 
-    # Let's start by adding a title and introduction
-    gradio.Markdown(
-        "# Automated Task Prioritizer"
-    )
-    gradio.Markdown(
-        "This app will take your to-do list and reorder it based on importance, urgency, and duration."
-    )
+      done_boxes = gr.CheckboxGroup(label="Mark completed tasks", interactive=True)  # <-- ensure interactive
 
-    with gradio.Tab("Task Entry"):
-
-    # This row contains all of the physical parameters
-      with gradio.Row():
-          sample_tasks = gradio.Textbox(label="Task List", lines=10)
-          due_dates = gradio.Textbox(label="Due Date", lines=10)
-
-      # Add a button to click to run the interface
-      run_btn = gradio.Button("Prioritize")
-      # Finally, add a few examples
-
-      gradio.Examples(
-          examples=[
-              ["finish lab report before monday\n"
-              "email TA about grading\n"
-              "practice dance combo 20 minutes\n"
-              "apply to 3 jobs\n"
-              "review calculus problem set (10 problems)\n"
-              "call dentist to schedule appointment\n"
-              "draft 1-page cover letter\n"
-              "wash dishes\n"
-              "organize notes for history essay\n"
-              "watch tv show",
-              "10/6/25\n"
-              "10/4/25\n"
-              "10/4/25\n"
-              "\n"
-              "10/8/25\n"
-              "10/3/25\n"
-              "10/11/25\n"
-              "10/3/25\n"
-              "10/5/25\n"]
-
-          ],
-          inputs=[sample_tasks, due_dates],
-          label="Example",
-          examples_per_page=1,
-          cache_examples=False,
-      )
-
-    with gradio.Tab("Prioritized List"):
-    # These are the outputs. We use both a dataframe (for tabular info) and a markdown box
-    # for info from the LLM
-      with gradio.Row():
-        priority_task = gradio.Textbox(label="Prioritized Task List", lines=10)
-        date = gradio.Textbox(label="Due Date", interactive=False, lines=10)
-
-    # Run the calculations when the button is clicked
-    run_btn.click(fn=reorder_tasks, inputs=[sample_tasks, due_dates], outputs=[priority_task, date]) # Add days_left to outputs
+    # Wire up
+    run_btn.click(
+        fn=reorder_tasks,
+        inputs=[sample_tasks, due_dates],
+        outputs=[priority_task, date_box, durations_box, done_boxes]
+    )
 
 if __name__ == "__main__":
     demo.launch(debug=True)