Upload 4 files

Inference_&_LLM/digital_human_in_the_loop.py

@@ -0,0 +1,211 @@
+import requests
+import json
+import re
+
+
+# 0.  HELPER FUNCTIONS
+OLLAMA_URL = ""
+DEFAULT_MODEL = "deepseek-R1"  #  run: ollama pull deepseek-v2, R1, etc.
+
+def query_llm(system_prompt: str, user_prompt: str, model: str = DEFAULT_MODEL) -> str:
+    payload = {
+        "model": model,
+        "system": system_prompt, 
+        "prompt": user_prompt,
+        "stream": False,
+        "options": {
+            "temperature": 0.2, 
+            "num_predict": 256 
+        }
+    }
+
+    try:
+        response = requests.post(OLLAMA_URL, json=payload, timeout=30)
+        response.raise_for_status()
+        data = response.json()
+        return data.get("response", "").strip()
+    except Exception as e:
+        print(f"[LLM Error]{model}: {e}")
+        return ""
+
+def parse_json_response(response_text: str) -> dict:
+
+    try:
+        # 0. Clean common LLM formatting issues
+        clean_text = re.sub(r'```json\s*', '', response_text)
+        clean_text = re.sub(r'```', '', clean_text)
+        clean_text = re.sub(r':\s*\+(\d)', r': \1', clean_text)
+        return json.loads(clean_text)
+        
+    except json.JSONDecodeError:
+        match = re.search(r'\{.*\}', response_text, re.DOTALL)
+        if match:
+            json_str = match.group(0)
+            json_str = re.sub(r':\s*\+(\d)', r': \1', json_str)
+            try:
+                return json.loads(json_str)
+            except json.JSONDecodeError:
+                pass
+    
+    # 3. Fallback
+    print(f"[Parser Error] {response_text}")
+    return {"zone_1": 0.0, "zone_2": 0.0, "zone_3": 0.0, "zone_4": 0.0, "zone_5": 0.0}
+
+
+
+# 1. THE SYSTEM PROMPT
+SYSTEM_PROMPT = """
+You are the **Digital Zone Comfort Manager** for a commercial building. 
+Your role is to simulate the **Thermal Sensation Vote (TSV)** for occupants in 5 distinct zones.
+You are NOT controlling the HVAC directly. You are a "Soft Sensor" providing feedback to the Building Controller.
+
+### 1. THE CONTEXTUAL PHYSICS
+Human comfort is not just temperature. It depends on:
+* **Metabolic Rate (MET):** High activity = generates heat = prefers cold.
+* **Clothing Insulation (CLO):** Heavy clothes = retains heat = prefers cold.
+* **Acclimatization:** * If Location is **HOT** (e.g., Dubai), occupants tolerate warmth better but are sensitive to "cold shock."
+    * If Location is **COLD** (e.g., Alaska), occupants wear heavier street clothes and tolerate cooler indoor temps better.
+* **Radiant Asymmetry:** Zones near windows feel hotter when sunny due to solar gain.
+
+### 2. THE 5 ZONE PERSONAS (Your Managers)
+Adopt the mindset of the specific occupants in each zone to cast your vote:
+
+* **Zone 1 (Core - General Office):**
+    * *Profile:* Standard Office (MET 1.1, CLO 0.7).
+    * *Mindset:* "I am the average user. I like 22-23C. I hate drafts."
+* **Zone 2 (Perimeter - Executives):**
+    * *Profile:* Formal Suits (MET 1.0, CLO 1.0). **High Insulation.**
+    * *Mindset:* "I am wearing a three-piece suit. I overheat easily. Keep it crisp and cool (20-21C)."
+* **Zone 3 (Lab - Active Work):**
+    * *Profile:* Standing/Walking (MET 1.4, CLO 0.6). **High Internal Heat.**
+    * *Mindset:* "I am moving around constantly. If it's above 21C, I start sweating. I need cooling."
+* **Zone 4 (Call Center - Sedentary):**
+    * *Profile:* Light Summer Wear (MET 1.0, CLO 0.5). **Low Insulation.**
+    * *Mindset:* "I am sitting still in a t-shirt. I freeze instantly. I need it warm (23-24C)."
+* **Zone 5 (Break Room - Transients):**
+    * *Profile:* Eating/Walking (MET 1.6, CLO 0.7). **Variable.**
+    * *Mindset:* "I'm just passing through or eating hot food. I tolerate cold well, but stuffy heat is gross."
+
+### 3. SCORING SCALE
+Vote on this integer scale based on how that *specific persona* would feel:
+* **-3 (Cold):** shivering, requesting heat immediately.
+* **-2 (Cool):** uncomfortable, distraction from work.
+* **-1 (Slightly Cool):** acceptable but noticed.
+* **0 (Neutral):** optimal, unnoticed.
+* **+1 (Slightly Warm):** acceptable but noticed.
+* **+2 (Warm):** uncomfortable, distraction from work.
+* **+3 (Hot):** sweating, requesting cooling immediately.
+
+### 4. OUTPUT RULES
+1.  **Analyze** the provided inputs (Location, Time, Weather, Indoor State).
+2.  **Simulate** the specific physics for each zone (e.g., Zone 2 is near a window on a sunny day -> add virtual heat load).
+3.  **Vote** strictly as a JSON object. If occupancy is 0, output 0.0.
+
+### OUTPUT FORMAT
+Return **ONLY** a valid JSON object. Do not use plus signs (+).
+{
+  "zone_1": <float>,
+  "zone_2": <float>,
+  "zone_3": <float>,
+  "zone_4": <float>,
+  "zone_5": <float>
+}
+"""
+
+
+# 2. THE INPUT TEMPLATE
+def create_llm_input(env_map):
+    # Extract Global Context (with defaults if missing)
+    location = env_map.get('location', 'Standard Climate')
+    time_day = env_map.get('time_of_day', 'Daytime')
+    outdoor_temp = env_map.get('outdoor_temp', 20.0)
+    weather = env_map.get('weather_condition', 'Clear')
+    
+    return f"""
+    GLOBAL CONTEXT:
+    - Location: {location} (Affects acclimatization expectations)
+    - Time of Day: {time_day}
+    - Weather: {weather} (Sunlight intensity affects window zones)
+    - Outdoor Temp: {outdoor_temp:.1f} C
+    
+    [ZONE 1 - CORE OFFICE]
+    - Indoor Air: {env_map.get('core_temp', 22.0):.1f} C, {env_map.get('core_rh', 50):.0f}% RH
+    - Occupancy: {env_map.get('core_occ_count', 0)} people
+    - Features: Interior zone, no windows.
+    
+    [ZONE 2 - EXECUTIVES (Suits)]
+    - Indoor Air: {env_map.get('perim1_temp', 22.0):.1f} C, {env_map.get('perim1_rh', 50):.0f}% RH
+    - Occupancy: {env_map.get('perim1_occ_count', 0)} people
+    - Features: Perimeter zone. **Direct Window Access.** (Sensitive to solar gain).
+    
+    [ZONE 3 - LAB (Active)]
+    - Indoor Air: {env_map.get('perim2_temp', 22.0):.1f} C, {env_map.get('perim2_rh', 50):.0f}% RH
+    - Occupancy: {env_map.get('perim2_occ_count', 0)} people
+    - Features: Perimeter zone. North facing (Less sun).
+    
+    [ZONE 4 - CALL CENTER (Light Clothes)]
+    - Indoor Air: {env_map.get('perim3_temp', 22.0):.1f} C, {env_map.get('perim3_rh', 50):.0f}% RH
+    - Occupancy: {env_map.get('perim3_occ_count', 0)} people
+    - Features: Perimeter zone. East facing.
+    
+    [ZONE 5 - BREAK ROOM]
+    - Indoor Air: {env_map.get('perim4_temp', 22.0):.1f} C, {env_map.get('perim4_rh', 50):.0f}% RH
+    - Occupancy: {env_map.get('perim4_occ_count', 0)} people
+    - Features: Perimeter zone. West facing (Afternoon sun risk).
+    """
+
+# 3. THE SENSOR CLASS
+
+class DigitalHumanSensor:
+    def __init__(self, model_name=DEFAULT_MODEL):
+        self.model_name = model_name
+        
+    def get_comfort_votes(self, obs_dict):
+        user_input = create_llm_input(obs_dict)
+        
+        print(f"   >>> Querying {self.model_name} for comfort status...")
+        raw_response = query_llm(SYSTEM_PROMPT, user_input, model=self.model_name)
+        raw_ratings = parse_json_response(raw_response)
+        
+        clean_ratings = {}
+        for zone, vote in raw_ratings.items():
+            try:
+                # Clamp between -3.0 and +3.0
+                val = float(vote)
+                clean_ratings[zone] = max(-3.0, min(3.0, val))
+            except (ValueError, TypeError):
+                clean_ratings[zone] = 0.0
+                
+        return clean_ratings
+
+# (Inference Server Simulation)
+if __name__ == "__main__":
+    mock_env = {
+        # --- GLOBAL CONTEXT ---
+        'location': 'Dubai, UAE', 
+        'time_of_day': '14:00 (Afternoon)',
+        'weather_condition': 'Sunny',
+        'outdoor_temp': 38.0,
+        
+        # --- ZONE 1---
+        'core_temp': 23.0, 'core_rh': 45.0, 'core_occ_count': 10,
+        
+        # --- ZONE 2 ---
+        'perim1_temp': 24.0, 'perim1_rh': 50.0, 'perim1_occ_count': 2,
+        
+        # --- ZONE 3  ---
+        'perim2_temp': 22.0, 'perim2_rh': 50.0, 'perim2_occ_count': 5,
+        
+        # --- ZONE 4 ) ---
+        'perim3_temp': 20.0, 'perim3_rh': 40.0, 'perim3_occ_count': 15,
+        
+        # --- ZONE 5 ---
+        'perim4_temp': 22.5, 'perim4_rh': 50.0, 'perim4_occ_count': 0, # Empty
+    }
+
+    sensor = DigitalHumanSensor(model_name="deepseek-v2") 
+    
+    votes = sensor.get_comfort_votes(mock_env)
+    
+    print("\n[Digital Human Feedback]")
+    print(json.dumps(votes, indent=2))

Inference_&_LLM/inference.py

@@ -0,0 +1,183 @@
+import gymnasium as gym
+import sinergym  # noqa: F401 (registers envs)
+import pandas as pd
+import numpy as np
+import os
+import sinergym
+import json
+import sys
+from unihvac.find_files import (
+    detect_paths,
+    find_manifest,
+    find_building_and_weather_from_manifest,
+)
+from unihvac.tables import (
+    print_monthly_tables_extra,
+    print_monthly_tables_split,
+)
+from unihvac.rollout import run_rollout_to_df
+
+
+# ============================================
+# FOR TABLE
+pd.set_option("display.max_columns", None)
+pd.set_option("display.width", 240)
+pd.set_option("display.max_colwidth", 32)
+pd.set_option("display.float_format", lambda x: f"{x:,.2f}")
+# ============================================
+
+# ==============================================================================
+#  USER CONFIGURATION
+# ==============================================================================
+TARGET_LOCATION = "Atlanta"  # Buffalo, Miami, Dubai, Fairbanks, HoChiMinh
+TARGET_THERMAL = "default"   # default, high_performance, low_performance
+TARGET_OCCUPANCY = "standard"         # standard, school, retail, etc.
+
+# Baseline-like setpoints (also used as DT seed)
+HEATING_SP = 21.0
+COOLING_SP = 24.0
+
+# Choose policy mode: "dt" or "rbc"
+POLICY_TYPE = "dt"   # change to "rbc" to match baseline runner exactly
+
+
+# ==========================================
+# PATH DISCOVERY (ROBUST)
+# ==========================================
+paths = detect_paths(outputs_dirname="baseline_results")
+manifest_path = find_manifest(paths, building="OfficeSmall", prefer_patched=True)
+output_root = str(paths.outputs_root)
+os.makedirs(output_root, exist_ok=True)
+TIME_STEP_HOURS = 900.0 / 3600.0  # 0.25 h
+
+# ==========================================
+# ACTUATORS & VARIABLES (keep identical)
+# ==========================================
+hot_actuators = {
+    "Htg_Core": ("Zone Temperature Control", "Heating Setpoint", "CORE_ZN"),
+    "Clg_Core": ("Zone Temperature Control", "Cooling Setpoint", "CORE_ZN"),
+    "Htg_P1": ("Zone Temperature Control", "Heating Setpoint", "PERIMETER_ZN_1"),
+    "Clg_P1": ("Zone Temperature Control", "Cooling Setpoint", "PERIMETER_ZN_1"),
+    "Htg_P2": ("Zone Temperature Control", "Heating Setpoint", "PERIMETER_ZN_2"),
+    "Clg_P2": ("Zone Temperature Control", "Cooling Setpoint", "PERIMETER_ZN_2"),
+    "Htg_P3": ("Zone Temperature Control", "Heating Setpoint", "PERIMETER_ZN_3"),
+    "Clg_P3": ("Zone Temperature Control", "Cooling Setpoint", "PERIMETER_ZN_3"),
+    "Htg_P4": ("Zone Temperature Control", "Heating Setpoint", "PERIMETER_ZN_4"),
+    "Clg_P4": ("Zone Temperature Control", "Cooling Setpoint", "PERIMETER_ZN_4"),
+}
+
+hot_variables = {
+    "outdoor_temp": ("Site Outdoor Air DryBulb Temperature", "Environment"),
+    "core_temp": ("Zone Air Temperature", "Core_ZN"),
+    "perim1_temp": ("Zone Air Temperature", "Perimeter_ZN_1"),
+    "perim2_temp": ("Zone Air Temperature", "Perimeter_ZN_2"),
+    "perim3_temp": ("Zone Air Temperature", "Perimeter_ZN_3"),
+    "perim4_temp": ("Zone Air Temperature", "Perimeter_ZN_4"),
+    "elec_power": ("Facility Total HVAC Electricity Demand Rate", "Whole Building"),
+    "core_occ_count": ("Zone People Occupant Count", "CORE_ZN"),
+    "perim1_occ_count": ("Zone People Occupant Count", "PERIMETER_ZN_1"),
+    "perim2_occ_count": ("Zone People Occupant Count", "PERIMETER_ZN_2"),
+    "perim3_occ_count": ("Zone People Occupant Count", "PERIMETER_ZN_3"),
+    "perim4_occ_count": ("Zone People Occupant Count", "PERIMETER_ZN_4"),
+
+    "outdoor_dewpoint": ("Site Outdoor Air Dewpoint Temperature", "Environment"),
+    "outdoor_wetbulb": ("Site Outdoor Air Wetbulb Temperature", "Environment"),
+
+    "core_rh": ("Zone Air Relative Humidity", "CORE_ZN"),
+    "perim1_rh": ("Zone Air Relative Humidity", "PERIMETER_ZN_1"),
+    "perim2_rh": ("Zone Air Relative Humidity", "PERIMETER_ZN_2"),
+    "perim3_rh": ("Zone Air Relative Humidity", "PERIMETER_ZN_3"),
+    "perim4_rh": ("Zone Air Relative Humidity", "PERIMETER_ZN_4"),
+
+    "core_ash55_notcomfortable_summer": ("Zone Thermal Comfort ASHRAE 55 Simple Model Summer Clothes Not Comfortable Time", "CORE_ZN"),
+    "core_ash55_notcomfortable_winter": ("Zone Thermal Comfort ASHRAE 55 Simple Model Winter Clothes Not Comfortable Time", "CORE_ZN"),
+    "core_ash55_notcomfortable_any": ("Zone Thermal Comfort ASHRAE 55 Simple Model Summer or Winter Clothes Not Comfortable Time", "CORE_ZN"),
+
+    "p1_ash55_notcomfortable_any": ("Zone Thermal Comfort ASHRAE 55 Simple Model Summer or Winter Clothes Not Comfortable Time", "PERIMETER_ZN_1"),
+    "p2_ash55_notcomfortable_any": ("Zone Thermal Comfort ASHRAE 55 Simple Model Summer or Winter Clothes Not Comfortable Time", "PERIMETER_ZN_2"),
+    "p3_ash55_notcomfortable_any": ("Zone Thermal Comfort ASHRAE 55 Simple Model Summer or Winter Clothes Not Comfortable Time", "PERIMETER_ZN_3"),
+    "p4_ash55_notcomfortable_any": ("Zone Thermal Comfort ASHRAE 55 Simple Model Summer or Winter Clothes Not Comfortable Time", "PERIMETER_ZN_4"),
+}
+
+
+class BaselineReward:
+    def __init__(self, *args, **kwargs):
+        pass
+    def __call__(self, obs_dict):
+        return 0.0, {}
+
+
+def run_eval_for_location(location, building_path, weather_path):
+    print("\n" + "=" * 80)
+    print(f"Running eval for location: {location}")
+    print(f" Building: {building_path}")
+    print(f" Weather: {weather_path}")
+    print(f" Policy: {POLICY_TYPE}")
+    print("=" * 80)
+
+    out_dir = os.path.join(output_root, location)
+    os.makedirs(out_dir, exist_ok=True)
+
+    # Build policy (DT or RBC) — policy state stays outside policy_fn
+    if POLICY_TYPE == "dt":
+        RUN_DIR = "Trajectories_code/run_007"  # update
+        policy = make_policy(
+            "dt",
+            ckpt_path=os.path.join(RUN_DIR, "ckpt_10.pt"),
+            model_config_path=os.path.join(RUN_DIR, "model_config.json"),
+            norm_stats_path="Trajectories_code/traj_results/norm_stats.npz",
+            context_len=24,
+            max_tokens_per_step=64,
+        )
+    else:
+        policy = make_policy("rbc", heating_sp=HEATING_SP, cooling_sp=COOLING_SP)
+
+    policy.reset()
+
+    def policy_fn(obs, info, step):
+        if step == 0:
+            print("OBS TYPE:", type(obs), "SHAPE:", getattr(obs, "shape", None))
+            if isinstance(obs, dict):
+                print("OBS KEYS SAMPLE:", list(obs.keys())[:10])
+        action, _, _ = policy.act(obs, info, step)
+        return action
+
+    df = run_rollout_to_df(
+        building_path=str(building_path),
+        weather_path=str(weather_path),
+        variables=hot_variables,
+        actuators=hot_actuators,
+        policy_fn=policy_fn,
+        location=location,
+        timestep_hours=TIME_STEP_HOURS,
+        heating_sp=HEATING_SP,   
+        cooling_sp=COOLING_SP,
+        reward=BaselineReward,
+        max_steps=None,
+        verbose=True,
+    )
+
+    print("setpoint_htg min/max:", df["setpoint_htg"].min(), df["setpoint_htg"].max())
+    print("setpoint_clg min/max:", df["setpoint_clg"].min(), df["setpoint_clg"].max())
+    print("comfort_violation min/mean/max:", df["comfort_violation_degCh"].min(),
+          df["comfort_violation_degCh"].mean(), df["comfort_violation_degCh"].max())
+
+    print_monthly_tables_extra(df, location)
+    print_monthly_tables_split(df, location, time_step_hours=TIME_STEP_HOURS)
+
+    df.to_csv(os.path.join(out_dir, "eval_timeseries.csv"), index=False)
+
+    return df
+
+
+if __name__ == "__main__":
+    bpath, wpath = find_building_and_weather_from_manifest(
+        manifest_path,
+        location=TARGET_LOCATION,
+        occupancy=TARGET_OCCUPANCY,
+        thermal=TARGET_THERMAL,
+        require_patched=True,
+    )
+
+    print("USING BUILDING FILE:", bpath)
+    run_eval_for_location(TARGET_LOCATION, str(bpath), str(wpath))

Inference_&_LLM/inference_server.py

@@ -0,0 +1,157 @@
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional
+import numpy as np
+import torch
+import os
+import sys
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+try:
+    from unihvac.policy import DecisionTransformerPolicy5Zone
+except ImportError:
+    from policy import DecisionTransformerPolicy5Zone
+
+# Import LLM Sensor
+try:
+    from LLM_part.digital_human_manager import DigitalHumanSensor
+except ImportError:
+    print(" LLM features disabled.")
+    DigitalHumanSensor = None
+
+app = FastAPI()
+
+# --- 2. CONFIGURATION ---
+BASE_PATH = "gen_hvac"
+CKPT_PATH = os.path.join(BASE_PATH, "training-runs/run_001/last.pt") 
+MODEL_CONFIG = os.path.join(BASE_PATH, "training-runs/run_001/model_config.json")
+NORM_STATS = "TrajectoryData_from_docker/norm_stats_v4_topk.npz"
+
+FIXED_ENERGY_TARGET = -40000.0  
+COMFORT_RELAXED = -1000.0 
+COMFORT_STRICT  = -1000.0  
+
+class SafetyCheck:
+    def __init__(self):
+        self.current_comfort_target = COMFORT_RELAXED
+        self.ema_alpha = 0.3 
+        self.power_limit = 12000.0
+        
+    def update(self, llm_votes: Dict[str, float], current_power_watts: float):
+        votes = list(llm_votes.values())
+        max_discomfort = max([abs(v) for v in votes]) if votes else 0.0
+
+        if max_discomfort >= 1.5: 
+            goal_target = COMFORT_STRICT
+            status = "CRITICAL COMPLAINT"
+        elif max_discomfort >= 0.5:
+            goal_target = (COMFORT_RELAXED + COMFORT_STRICT) / 2
+            status = "MILD DISCOMFORT"
+        else:
+            goal_target = COMFORT_RELAXED
+            status = "SATISFIED"
+        if current_power_watts > self.power_limit:
+            goal_target = min(goal_target, -25000.0) 
+            status += " [ENERGY LIMIT EXCEEDED]"
+
+        # D. Prevent Hallucination Spikes
+        self.current_comfort_target = (1 - self.ema_alpha) * self.current_comfort_target + \
+                                      (self.ema_alpha * goal_target)
+                                      
+        return self.current_comfort_target, status
+
+dt_policy = None
+llm_sensor = None
+governor = SafetyCheck()
+
+# Keys Mapping
+ENV_KEYS = [
+    'month', 'day_of_month', 'hour', 
+    'outdoor_temp', 'core_temp', 'perim1_temp', 'perim2_temp', 'perim3_temp', 'perim4_temp', 
+    'elec_power', 
+    'core_occ_count', 'perim1_occ_count', 'perim2_occ_count', 'perim3_occ_count', 'perim4_occ_count', 
+    'outdoor_dewpoint', 'outdoor_wetbulb', 
+    'core_rh', 'perim1_rh', 'perim2_rh', 'perim3_rh', 'perim4_rh', 
+    'core_ash55_notcomfortable_summer', 'core_ash55_notcomfortable_winter', 'core_ash55_notcomfortable_any', 
+    'p1_ash55_notcomfortable_any', 'p2_ash55_notcomfortable_any', 'p3_ash55_notcomfortable_any', 'p4_ash55_notcomfortable_any', 
+    'total_electricity_HVAC'
+]
+
+@app.on_event("startup")
+def load_model():
+    global dt_policy, llm_sensor
+    
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    
+    # 1. Load DT Policy
+    try:
+        dt_policy = DecisionTransformerPolicy5Zone(
+            ckpt_path=CKPT_PATH,
+            model_config_path=MODEL_CONFIG,
+            norm_stats_path=NORM_STATS,
+            context_len=48,
+            max_tokens_per_step=64,
+            device=device,
+            temperature=0.5,
+            target_energy=FIXED_ENERGY_TARGET,
+            target_comfort=COMFORT_RELAXED 
+        )
+        print("DT Policy Loaded.")
+    except Exception as e:
+        print(f"DT Load Error: {e}")
+
+    # 2. Load LLM
+    if DigitalHumanSensor:
+        try:
+            llm_sensor = DigitalHumanSensor(model_name="deepseek-v2")
+            print("LLM Sensor Loaded.")
+        except Exception as e:
+            print(f"LLM Error: {e}")
+
+class ObsPayload(BaseModel):
+    step: int
+    obs: List[float] 
+    info: Dict[str, Any] = {}
+
+class ResetPayload(BaseModel):
+    message: str = "reset"
+
+@app.post("/reset")
+def reset_policy(payload: ResetPayload):
+    if dt_policy:
+        dt_policy.reset()
+
+        global governor
+        governor = SafetyCheck() 
+        dt_policy.target_energy = FIXED_ENERGY_TARGET
+        dt_policy.target_comfort = COMFORT_RELAXED
+        return {"status": "success"}
+    return {"status": "error"}
+
+@app.post("/predict")
+def get_action(payload: ObsPayload):
+    global dt_policy, llm_sensor, governor
+    
+    if dt_policy is None:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+
+    obs_arr = np.array(payload.obs, dtype=np.float32)
+
+    # 1. LLM Loop (Keep existing)
+    if llm_sensor and (payload.step % 4 == 0):
+        try:
+            env_map = dict(zip(ENV_KEYS, obs_arr))
+            votes = llm_sensor.get_comfort_votes(env_map)
+            new_target, status = governor.update(votes, obs_arr[9])
+            dt_policy.target_comfort = new_target
+            print(f"[Step {payload.step}] LLM: {votes} | Status: {status} | Target: {new_target:.0f}")
+        except Exception:
+            pass
+    action, _, _ = dt_policy.act(obs_arr, payload.info, payload.step)
+
+    return {"action": action.tolist()}
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

Inference_&_LLM/llm_client

@@ -0,0 +1,17 @@
+import requests
+
+OLLAMA_URL = ""
+
+def query_llm(prompt: str, model: str = "") -> str:
+    payload = {
+        "model": model,
+        "prompt": prompt,
+        "stream": False
+    }
+    try:
+        response = requests.post(OLLAMA_URL, json=payload, timeout=60)
+        response.raise_for_status()
+        data = response.json()
+        return data.get("response", "").strip()
+    except Exception as e:
+        return f"[Error] {e}"