Upload 2 files

Dockerfile

@@ -22,5 +22,5 @@ ENV GRADIO_SERVER_NAME="0.0.0.0"
 ENV GRADIO_SERVER_PORT="7860"
 EXPOSE 7860
 
-# Run inference evaluation (Hackathon graders evaluate stdout)
-CMD ["python", "inference.py"]
+# Run the persistent web dashboard (keeps Space alive)
+CMD ["python", "app.py"]

app.py

@@ -1,116 +1,170 @@
-import gradio as gr
+"""
+MetaOCT Hackathon Web App
+Runs inference.py in background thread and serves results via a minimal web server.
+This keeps the HuggingFace Space alive permanently.
+"""
+
+import threading
 import asyncio
-from env import MetaOCTEnv, Action
+import os
+import json
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from dotenv import load_dotenv
+from env import MetaOCTEnv, Action, Observation
+from openai import OpenAI
+import torch
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from PIL import Image
+from typing import List, Optional
 
-def run_async(coro):
-    """Helper to run async code synchronously for Gradio callbacks."""
-    try:
-        loop = asyncio.get_event_loop()
-    except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-    return loop.run_until_complete(coro)
+load_dotenv()
 
-async def init_env(difficulty="medium"):
-    env = MetaOCTEnv(difficulty=difficulty)
-    obs = await env.reset()
-    budget_str = f"💲 Remaining Budget: ${obs.available_budget:.2f}"
-    log_text = "\n\n".join(obs.tool_outputs)
-    return env, budget_str, log_text, None, "", "Start interacting..."
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/hf-inference/v1/")
+MODEL_NAME = os.getenv("MODEL_NAME", "meta-llama/Meta-Llama-3-8B-Instruct")
+HF_TOKEN = os.getenv("HF_TOKEN")
+if HF_TOKEN is None and os.getenv("OPENAI_API_KEY") is None:
+    print("[WARNING] Required API keys missing.", flush=True)
+API_KEY = os.getenv("OPENAI_API_KEY") or HF_TOKEN or os.getenv("API_KEY")
 
-def ui_initialize(difficulty):
-    return run_async(init_env(difficulty))
+# Global results store
+results = {"status": "running", "logs": [], "score": None, "success": None}
 
-async def take_step(env, action_name, diagnosis_input="NORMAL"):
-    if env is None:
-        return None, "Error: Start a new patient first!", "", None, "", ""
-        
-    params = {}
-    if action_name == "submit_diagnosis":
-        # Simplified parameters for UI
-        params = {
-            "diagnosis": diagnosis_input,
-            "heatmap_coordinates": [[80,80], [150,150]],
-            "reasoning": "Human judge overriding UI input."
-        }
-        
-    result = await env.step(Action(tool_name=action_name, parameters=params))
-    
-    # Extract states
-    obs = result.observation
-    budget_str = f"💲 Remaining Budget: ${obs.available_budget:.2f}"
-    log_text = "\n\n".join(obs.tool_outputs)
-    
-    img_path = None
-    if len(obs.acquired_scans) > 0:
-        img_path = obs.acquired_scans[-1]
-        
-    # Reward tracking
-    if result.done:
-        status = f"✅ DIAGNOSIS COMPLETE! FINAL GRADE: {result.reward:.3f} / 1.0"
-    else:
-        # Micro reward or penalty
-        if result.reward < 0:
-            status = f"⚠️ Penalty! Score: {result.reward}"
-        else:
-            status = f"🔄 Valid Move. Cost applied."
-            
-    return env, budget_str, log_text, img_path, status
+# Vision Model
+print("[DEBUG] Loading Vision Model...", flush=True)
+try:
+    processor = AutoImageProcessor.from_pretrained("octava/image_classification")
+    hf_model = AutoModelForImageClassification.from_pretrained("octava/image_classification", output_attentions=True)
+except Exception as e:
+    print(f"[DEBUG] Vision model warning: {e}", flush=True)
+    processor = None
+    hf_model = None
 
-def ui_step_scan(env): return run_async(take_step(env, "request_oct_scan"))
-def ui_step_enhance(env): return run_async(take_step(env, "enhance_contrast"))
-def ui_step_measure(env): return run_async(take_step(env, "measure_fluid_thickness"))
-def ui_step_diagnose(env, diag): return run_async(take_step(env, "submit_diagnosis", diag))
+def get_vision_prediction(image_path: str):
+    diagnosis = "NORMAL"
+    heatmap = [[0,0],[0,0]]
+    if hf_model is not None:
+        try:
+            image = Image.open(image_path).convert("RGB")
+            inputs = processor(images=image, return_tensors="pt")
+            with torch.no_grad():
+                outputs = hf_model(**inputs)
+            idx = outputs.logits.argmax(-1).item()
+            label = hf_model.config.id2label[idx].upper()
+            if "CNV" in label: diagnosis = "CNV"
+            elif "DME" in label: diagnosis = "DME"
+            elif "DRUSEN" in label: diagnosis = "DRUSEN"
+            attentions = outputs.attentions
+            avg_attention = attentions[-1].mean(dim=1).squeeze(0)
+            cls_attention = avg_attention[0, 1:]
+            grid = cls_attention.reshape(14,14)
+            max_idx = torch.argmax(grid).item()
+            y, x = max_idx // 14, max_idx % 14
+            p = 16
+            heatmap = [[max(0,(x-1)*p), max(0,(y-1)*p)], [min(224,(x+2)*p), min(224,(y+2)*p)]]
+        except Exception as e:
+            print(f"[DEBUG] Vision error: {e}", flush=True)
+    return diagnosis, heatmap
 
-# Construct Gradio Theme
-custom_theme = gr.themes.Soft(
-    primary_hue="blue",
-    secondary_hue="indigo",
-    neutral_hue="slate"
-)
+def get_heuristic_action(step: int, obs, client) -> Action:
+    if step == 1: return Action(tool_name="request_oct_scan", parameters={})
+    elif step == 2: return Action(tool_name="enhance_contrast", parameters={})
+    elif step == 3: return Action(tool_name="measure_fluid_thickness", parameters={})
+    else:
+        image_path = obs.acquired_scans[-1] if obs.acquired_scans else "dummy.jpg"
+        diagnosis, heatmap = get_vision_prediction(image_path)
+        reasoning = "Clinical biomarkers align with diagnosis based on retinal morphology."
+        try:
+            prompt = f"You are an expert ophthalmologist. Diagnose: {diagnosis}. Give 1-sentence reasoning."
+            completion = client.chat.completions.create(model=MODEL_NAME, messages=[{"role":"user","content":prompt}], max_tokens=80)
+            reasoning = completion.choices[0].message.content.strip()
+        except Exception as e:
+            print(f"[DEBUG] LLM error: {e}", flush=True)
+        return Action(tool_name="submit_diagnosis", parameters={"diagnosis": diagnosis, "heatmap_coordinates": heatmap, "reasoning": reasoning})
 
-with gr.Blocks(theme=custom_theme, title="MetaOCT Virtual Clinic") as demo:
-    gr.Markdown("# 👁️ MetaOCT: Virtual Medical Clinic (POMDP)")
-    gr.Markdown("Prove your diagnostic efficiency. You have a limited budget. Perform necessary scans before extracting the final diagnosis! Made for the Meta OpenEnv Challenge.")
+async def run_inference():
+    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    global_rewards = []
+    global_steps = 0
+    difficulties = ["easy", "medium", "hard"]
     
-    # Stores the environment instance
-    env_state = gr.State(None)
+    log_line = f"[START] task=MetaOCT_POMDP env=meta_oct model={MODEL_NAME}"
+    print(log_line, flush=True)
+    results["logs"].append(log_line)
     
-    with gr.Row():
-        # LEFT COLUMN (Visuals & Economics)
-        with gr.Column(scale=1):
-            difficulty_radio = gr.Radio(["easy", "medium", "hard"], value="medium", label="Task Difficulty")
-            btn_start = gr.Button("🏥 Accept New Patient", variant="primary")
-            
-            budget_display = gr.Markdown("### 💲 Remaining Budget: --")
-            scan_image = gr.Image(label="Optical Coherence Tomography (OCT)", type="filepath", interactive=False)
-            status_box = gr.Textbox(label="Evaluation Status", interactive=False)
-            
-        # RIGHT COLUMN (Interactions & Output)
-        with gr.Column(scale=1):
-            gr.Markdown("### 🛠️ Clinical Tools")
-            btn_tool_1 = gr.Button("🔍 Tool: Request Scan (-$150)")
-            btn_tool_2 = gr.Button("✨ Tool: Enhance Contrast (-$50)")
-            btn_tool_3 = gr.Button("📏 Tool: Measure Fluid Thickness (-$200)")
-            
-            gr.Markdown("### 📋 Final Diagnosis (Terminal State)")
-            diagnosis_dropdown = gr.Dropdown(["NORMAL", "CNV", "DME", "DRUSEN"], label="Select Pathogen", value="NORMAL")
-            btn_diagnose = gr.Button("📝 Submit Final Diagnosis ($0)", variant="stop")
-            
-            clinical_log = gr.Textbox(label="Secure Clinical Record", lines=10, interactive=False)
-
-    # Wiring Buttons
-    btn_start.click(
-        fn=ui_initialize, 
-        inputs=[difficulty_radio], 
-        outputs=[env_state, budget_display, clinical_log, scan_image, status_box, status_box]
-    )
+    for diff in difficulties:
+        env = MetaOCTEnv(difficulty=diff)
+        for _ in range(min(env.max_patients, 3)):
+            obs = await env.reset()
+            episode_step = 0
+            while True:
+                episode_step += 1
+                global_steps += 1
+                action_obj = get_heuristic_action(episode_step, obs, client)
+                result = await env.step(action_obj)
+                reward = result.reward or 0.0
+                done = result.done
+                obs = result.observation
+                global_rewards.append(reward)
+                step_log = f"[STEP] step={global_steps} action=Tool({action_obj.tool_name}) reward={reward:.2f} done={str(done).lower()} error=null"
+                print(step_log, flush=True)
+                results["logs"].append(step_log)
+                if done: break
+        await env.close()
     
-    btn_tool_1.click(fn=ui_step_scan, inputs=[env_state], outputs=[env_state, budget_display, clinical_log, scan_image, status_box])
-    btn_tool_2.click(fn=ui_step_enhance, inputs=[env_state], outputs=[env_state, budget_display, clinical_log, scan_image, status_box])
-    btn_tool_3.click(fn=ui_step_measure, inputs=[env_state], outputs=[env_state, budget_display, clinical_log, scan_image, status_box])
+    max_total = float(len(global_rewards))
+    total_score = sum(global_rewards) / max_total if max_total > 0 else 0.0
+    success = total_score >= 0.7
+    end_log = f"[END] success={str(success).lower()} steps={global_steps} score={total_score:.3f} rewards={','.join(f'{r:.2f}' for r in global_rewards)}"
+    print(end_log, flush=True)
+    results["logs"].append(end_log)
+    results["status"] = "complete"
+    results["score"] = total_score
+    results["success"] = success
+
+def run_inference_thread():
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    loop.run_until_complete(run_inference())
+
+# Simple Web Server - Serves the results as HTML
+class ResultsHandler(BaseHTTPRequestHandler):
+    def log_message(self, format, *args): pass  # Suppress access logs
     
-    btn_diagnose.click(fn=ui_step_diagnose, inputs=[env_state, diagnosis_dropdown], outputs=[env_state, budget_display, clinical_log, scan_image, status_box])
+    def do_GET(self):
+        self.send_response(200)
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+        
+        status_color = "#00ff88" if results["status"] == "complete" else "#ffaa00"
+        score_display = f"{results['score']:.3f}" if results["score"] is not None else "Running..."
+        
+        html = f"""<!DOCTYPE html>
+<html><head>
+<title>MetaOCT Virtual Clinic</title>
+<meta http-equiv="refresh" content="5">
+<style>
+body{{background:#0d1117;color:#e6edf3;font-family:monospace;padding:40px;}}
+h1{{color:#58a6ff;}} .status{{color:{status_color};font-size:1.4em;}} 
+pre{{background:#161b22;padding:20px;border-radius:8px;overflow-x:auto;font-size:13px;max-height:500px;overflow-y:auto;}}
+.score{{font-size:2em;color:#f0883e;}} .badge{{background:#238636;padding:4px 12px;border-radius:20px;}}
+</style></head>
+<body>
+<h1>👁️ MetaOCT: Virtual Medical Clinic (POMDP)</h1>
+<p>Multi-Step Reinforcement Learning Environment | Meta OpenEnv Hackathon</p>
+<p class="status">Status: {results["status"].upper()}</p>
+<p class="score">Score: {score_display}</p>
+<pre>{"<br>".join(results["logs"][-30:])}</pre>
+<p><span class="badge">OpenEnv Compliant</span> &nbsp; Built with PyTorch + LLaMA-3 + OctaVA Vision</p>
+</body></html>"""
+        self.wfile.write(html.encode())
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    # Start inference in background
+    thread = threading.Thread(target=run_inference_thread, daemon=True)
+    thread.start()
+    
+    # Start web server on port 7860 (HuggingFace required)
+    port = int(os.getenv("GRADIO_SERVER_PORT", "7860"))
+    print(f"[INFO] Starting MetaOCT Dashboard on port {port}", flush=True)
+    server = HTTPServer(("0.0.0.0", port), ResultsHandler)
+    server.serve_forever()