🚀 FEAT: Integrated Live HF LLM (Llama-3) & Training Data Logging

inference.py

@@ -1,16 +1,94 @@
 """
-FairRecovery++ — Baseline Inference Script.
+FairRecovery++ — Advanced Inference & LLM Connectivity.
 
-Updated with Phase-Aware policies to correctly advance days.
+Integrates Hugging Face Inference API for real-time decision making
+and trajectory logging for training data generation.
 """
 
 from __future__ import annotations
-import random
+import os
+import json
+import time
+from typing import Optional, List
+from huggingface_hub import InferenceClient
 from fairrecovery_env.models import ResourceAllocation, FairRecoveryAction, FairRecoveryObservation
 from fairrecovery_env.constants import ActionType, ResourceType
 
+class TrainingLogger:
+    """Logs state-action trajectories for future RL training."""
+    def __init__(self, log_dir: str = "training_data"):
+        self.log_dir = log_dir
+        os.makedirs(log_dir, exist_ok=True)
+        self.current_session = f"session_{int(time.time())}.jsonl"
+
+    def log_step(self, obs: FairRecoveryObservation, action: FairRecoveryAction, reward: float):
+        entry = {
+            "observation": obs.model_dump(),
+            "action": action.model_dump(),
+            "reward": reward,
+            "timestamp": time.time()
+        }
+        with open(os.path.join(self.log_dir, self.current_session), "a") as f:
+            f.write(json.dumps(entry) + "\n")
+
+class HFInferencePolicy:
+    """Live LLM Agent using Hugging Face Inference API."""
+    def __init__(self, model_id: str = "meta-llama/Llama-3.2-1B-Instruct", token: Optional[str] = None):
+        self.client = InferenceClient(model=model_id, token=token)
+
+    def __call__(self, obs: FairRecoveryObservation) -> FairRecoveryAction:
+        if obs.day > 10: return FairRecoveryAction(action_type=ActionType.SUBMIT)
+
+        prompt = self._build_prompt(obs)
+        try:
+            response = self.client.chat_completion(
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=200,
+                temperature=0.1
+            )
+            content = response.choices[0].message.content
+            return self._parse_response(content, obs)
+        except Exception as e:
+            # Fallback to a simple heuristic if API fails
+            return FairRecoveryAction(action_type=ActionType.ANALYZE, reasoning=f"API Error: {str(e)}")
+
+    def _build_prompt(self, obs: FairRecoveryObservation) -> str:
+        zones_info = "\n".join([f"Zone {z.zone_id}: Damage={z.damage:.2f}, Vulnerability={z.vulnerable_ratio:.2f}, Svc={z.service_level:.2f}" for z in obs.zones])
+        return f"""
+You are an Emergency Recovery Agent. 
+Environment: {zones_info}
+Day: {obs.day}
+Budget Left: {obs.budget_left:.2f}
+
+Goal: Maximize Utility AND Fairness.
+Format your response as valid JSON:
+{{"action_type": "analyze"|"allocate"|"execute", "zone": <int>, "reasoning": "<str>"}}
+
+Choose "analyze" to scan a zone, "allocate" to send resources (MEDICAL to <zone>), or "execute" to finish the day.
+"""
+
+    def _parse_response(self, content: str, obs: FairRecoveryObservation) -> FairRecoveryAction:
+        try:
+            # Extract JSON from potential conversational filler
+            match = __import__("re").search(r"\{.*\}", content, __import__("re").DOTALL)
+            data = json.loads(match.group(0)) if match else json.loads(content)
+            
+            a_type = ActionType(data["action_type"].lower())
+            allocs = None
+            if a_type == ActionType.ALLOCATE:
+                allocs = [ResourceAllocation(zone=data.get("zone", 0), resource=ResourceType.MEDICAL)]
+            
+            return FairRecoveryAction(
+                action_type=a_type,
+                critical_zones=[data.get("zone", 0)] if a_type == ActionType.ANALYZE else None,
+                allocations=allocs,
+                reasoning=data.get("reasoning", "LLM decision.")
+            )
+        except:
+            return FairRecoveryAction(action_type=ActionType.EXECUTE, reasoning="Parse failed, auto-executing.")
+
+# Standard heuristic policies for comparison
 def _get_phase_action(obs: FairRecoveryObservation) -> ActionType:
-    """Determine the correct action type based on the 3-phase cycle."""
     num_steps = len(obs.action_history)
     cycle_pos = num_steps % 3
     if cycle_pos == 0: return ActionType.ANALYZE
@@ -18,40 +96,16 @@ def _get_phase_action(obs: FairRecoveryObservation) -> ActionType:
     return ActionType.EXECUTE
 
 def greedy_policy(obs: FairRecoveryObservation) -> FairRecoveryAction:
-    """Greedy: Target zone 0 (easiest/wealthiest) regardless of vulnerability."""
     if obs.day > 10: return FairRecoveryAction(action_type=ActionType.SUBMIT)
-    
-    action_type = _get_phase_action(obs)
-    
-    if action_type == ActionType.ANALYZE:
-        return FairRecoveryAction(action_type=action_type, critical_zones=[0], reasoning="Greedy focus on Zone 0.")
-    
-    if action_type == ActionType.ALLOCATE:
-        return FairRecoveryAction(
-            action_type=action_type,
-            allocations=[ResourceAllocation(zone=0, resource=ResourceType.MEDICAL)],
-            reasoning="Maximizing utility in Zone 0."
-        )
-    
+    a_type = _get_phase_action(obs)
+    if a_type == ActionType.ANALYZE: return FairRecoveryAction(action_type=a_type, critical_zones=[0])
+    if a_type == ActionType.ALLOCATE: return FairRecoveryAction(action_type=a_type, allocations=[ResourceAllocation(zone=0, resource=ResourceType.MEDICAL)])
     return FairRecoveryAction(action_type=ActionType.EXECUTE)
 
 def fairness_aware_policy(obs: FairRecoveryObservation) -> FairRecoveryAction:
-    """Fairness-Aware: Prioritizes Zone 4 (highest vulnerability)."""
     if obs.day > 10: return FairRecoveryAction(action_type=ActionType.SUBMIT)
-    
-    action_type = _get_phase_action(obs)
-    
-    # Identify most vulnerable zone (usually Zone 4 in hard scenario)
+    a_type = _get_phase_action(obs)
     v_zone = sorted(range(len(obs.zones)), key=lambda i: obs.zones[i].vulnerable_ratio, reverse=True)[0]
-    
-    if action_type == ActionType.ANALYZE:
-        return FairRecoveryAction(action_type=action_type, critical_zones=[v_zone], reasoning=f"Prioritizing high-vulnerability Zone {v_zone}.")
-    
-    if action_type == ActionType.ALLOCATE:
-        return FairRecoveryAction(
-            action_type=action_type,
-            allocations=[ResourceAllocation(zone=v_zone, resource=ResourceType.MEDICAL)],
-            reasoning=f"Protecting vulnerable population in Zone {v_zone}."
-        )
-    
+    if a_type == ActionType.ANALYZE: return FairRecoveryAction(action_type=a_type, critical_zones=[v_zone])
+    if a_type == ActionType.ALLOCATE: return FairRecoveryAction(action_type=a_type, allocations=[ResourceAllocation(zone=v_zone, resource=ResourceType.MEDICAL)])
     return FairRecoveryAction(action_type=ActionType.EXECUTE)

server/app.py

@@ -1,28 +1,27 @@
 """
 FairRecovery++ — FastAPI Application.
 
-Updated simulation loop for phase-aware progression.
+Updated with Live LLM (Hugging Face) support and Training Data logging.
 """
 
 from __future__ import annotations
 import os, sys
 import re
-import requests
-import json
 from typing import Optional
 from fastapi import FastAPI, Request
 from fastapi.responses import RedirectResponse
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
 
-from fairrecovery_env.models import FairRecoveryAction, FairRecoveryObservation
+from fairrecovery_env.models import FairRecoveryAction
 from server.fairrecovery_environment import FairRecoveryEnvironment
-from inference import greedy_policy, fairness_aware_policy
+from inference import greedy_policy, fairness_aware_policy, HFInferencePolicy, TrainingLogger
 
 def _build_app():
     import gradio as gr
     app = FastAPI(title="FairRecovery++ RL Environment", version="2.0.0")
     _env = FairRecoveryEnvironment()
+    _logger = TrainingLogger()
 
     @app.post("/reset")
     async def reset(difficulty: str = "medium", episode_id: Optional[str] = None):
@@ -34,48 +33,65 @@ def _build_app():
         action = FairRecoveryAction(**payload)
         return _env.step(action).model_dump()
 
-    def run_simulation(policy_type: str):
+    def run_simulation(policy_type: str, hf_token: str):
         env = FairRecoveryEnvironment()
         obs = env.reset(task_id="multi_disaster_hard")
         
         logs = []
-        logs.append(f"### 🚨 SCENARIO: {policy_type.upper()}")
+        logs.append(f"### 🚀 LIVE SESSION: {policy_type.upper()}")
         
-        done = False
-        policy_fn = greedy_policy if policy_type == "Baseline (Greedy)" else fairness_aware_policy
+        # Policy Selection
+        if policy_type == "Live LLM (Llama-3)":
+            if not hf_token:
+                return "### ❌ Error\nPlease provide a Hugging Face Token to use the Live LLM.", ""
+            policy_fn = HFInferencePolicy(token=hf_token)
+        elif policy_type == "Baseline (Greedy)":
+            policy_fn = greedy_policy
+        else:
+            policy_fn = fairness_aware_policy
         
+        done = False
         while not done:
             action = policy_fn(obs)
+            prev_obs = obs # For logging
             obs = env.step(action)
             
+            # Log for training
+            _logger.log_step(prev_obs, action, obs.reward)
+            
             if action.action_type == "execute":
                 logs.append(f"✅ **Day {obs.day-1} Complete**")
-                # Show status of critical zones
                 z4 = obs.zones[4]
-                logs.append(f"  - Zone 4 (Vulnerable) Status: Damage {z4.damage:.2f}, Svc {z4.service_level:.2f}")
+                logs.append(f"  - Zone 4 Status: Damage {z4.damage:.2f}, Equity Index: {obs.fairness_score:.2f}")
+                if action.reasoning:
+                    logs.append(f"  - *AI Reasoning:* {action.reasoning}")
             
             done = obs.done
 
         res_eval = "🟢 **EQUITY ACHIEVED**" if obs.fairness_score > 0.8 else "🔴 **NEGLECT DETECTED**"
-        result_text = f"### 🏆 FINAL OUTCOME\n- **Reward Score:** {obs.cumulative_reward:.3f}\n- **Equity Index:** {obs.fairness_score:.3f}\n\n{res_eval}"
+        result_text = f"### 🏆 FINAL OUTCOME\n- **Reward Score:** {obs.cumulative_reward:.3f}\n- **Equity Index:** {obs.fairness_score:.3f}\n\n{res_eval}\n\n*Trajectory saved to training_data/ for RL refinement.*"
         return "\n".join(logs), result_text
 
     with gr.Blocks(title="FairRecovery++", theme=gr.themes.Soft()) as gradio_app:
-        gr.Markdown("# 🏗️ FairRecovery++: Disaster Response Simulator")
+        gr.Markdown("# 🏗️ FairRecovery++: Real-time LLM Simulator")
         with gr.Tabs():
             with gr.Tab("Simulation"):
-                policy = gr.Dropdown(choices=["Baseline (Greedy)", "Trained LLM (Fairness Aware)"], value="Baseline (Greedy)")
-                btn = gr.Button("Run Simulation", variant="primary")
+                with gr.Row():
+                    policy = gr.Dropdown(
+                        choices=["Baseline (Greedy)", "Fairness Aware (Heuristic)", "Live LLM (Llama-3)"], 
+                        value="Baseline (Greedy)",
+                        label="Agent Strategy"
+                    )
+                    hf_token = gr.Textbox(label="Hugging Face Token (optional for Live LLM)", type="password")
+                
+                btn = gr.Button("Run Live Simulation", variant="primary")
                 logs = gr.Markdown()
                 results = gr.Markdown()
-                btn.click(run_simulation, inputs=[policy], outputs=[logs, results])
+                btn.click(run_simulation, inputs=[policy, hf_token], outputs=[logs, results])
             with gr.Tab("README"):
                 readme_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "README.md")
                 with open(readme_path, "r", encoding="utf-8") as f:
-                    content = f.read()
-                    if content.startswith("---"):
-                        content = re.sub(r"^---.*?---", "", content, flags=re.DOTALL)
-                    gr.Markdown(content)
+                    gr.Markdown(f.read())
 
     @app.get("/")
     async def root(): return RedirectResponse(url="/ui/")