Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,13 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+environments/wildfire_detection/sample_frames/fire_000.jpg filter=lfs diff=lfs merge=lfs -text
+environments/wildfire_detection/sample_frames/fire_001.jpg filter=lfs diff=lfs merge=lfs -text
+environments/wildfire_detection/sample_frames/fire_002.jpg filter=lfs diff=lfs merge=lfs -text
+environments/wildfire_detection/sample_frames/fire_003.jpg filter=lfs diff=lfs merge=lfs -text
+environments/wildfire_detection/sample_frames/fire_004.jpg filter=lfs diff=lfs merge=lfs -text
+environments/wildfire_detection/sample_frames/fire_005.jpg filter=lfs diff=lfs merge=lfs -text
+environments/wildfire_detection/sample_frames/no_fire_008.jpg filter=lfs diff=lfs merge=lfs -text
+environments/wildfire_detection/sample_frames/no_fire_009.jpg filter=lfs diff=lfs merge=lfs -text
+environments/wildfire_detection/sample_frames/smoke_006.jpg filter=lfs diff=lfs merge=lfs -text
+environments/wildfire_detection/sample_frames/smoke_007.jpg filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+# Wildfire Detection OpenEnv Environment
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+COPY . /app/env
+
+WORKDIR /app/env
+
+# Install dependencies directly
+RUN pip install --no-cache-dir -e .
+
+EXPOSE 8000
+
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]

FirenetCNN1.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3bc11fdafb36cf0e43ea1af44015097a62a67118b43d27f0badd2b5867c8525
+size 25352336

Meta OpenEnv Hackathon_ Guidelines.md

@@ -0,0 +1,158 @@
+## **🚀 Hackathon Submission Guidelines (OpenEnv RL Challenge)**
+
+### **1\. Project Structure**
+
+* Your inference script **must** be named inference.py  
+* It **must be located in the root directory** of your project
+
+---
+
+### **2\. LLM Usage Requirements**
+
+* You **must use the OpenAI Client** for all LLM calls  
+* Do **not** use alternative SDKs or direct HTTP calls
+
+---
+
+### **3\. Required Environment Variables**
+
+Your inference.py must read the following environment variables:
+
+* API\_BASE\_URL  
+  * Description: API endpoint for the LLM  
+  * Requirement: **Must include a default value**  
+* MODEL\_NAME  
+  * Description: Model identifier used for inference  
+  * Requirement: **Must include a default value**  
+* HF\_TOKEN  
+  * Description: Hugging Face API token  
+  * Requirement: **Mandatory (no default required)**
+
+**4\. INFERENCE OUTPUT FORMAT**
+
+The script must emit exactly three line types to stdout, in this order:  
+    \[START\] task=\<task\_name\> env=\<benchmark\> model=\<model\_name\>  
+    \[STEP\]  step=\<n\> action=\<action\_str\> reward=\<0.00\> done=\<true|false\> error=\<msg|null\>  
+    \[END\]   success=\<true|false\> steps=\<n\> rewards=\<r1,r2,...,rn\>
+
+  Rules:  
+    \- One \[START\] line at episode begin.  
+    \- One \[STEP\] line per step, immediately after env.step() returns.  
+    \- One \[END\] line after env.close(), always emitted (even on exception).  
+    \- reward and rewards are formatted to 2 decimal places.  
+    \- done and success are lowercase booleans: true or false.  
+    \- error is the raw last\_action\_error string, or null if none.  
+    \- All fields on a single line with no newlines within a line.  
+  Example:  
+    \[START\] task=click-test env=miniwob model=Qwen3-VL-30B  
+    \[STEP\] step=1 action=click('123') reward=0.00 done=false error=null  
+    \[STEP\] step=2 action=fill('456','text') reward=0.00 done=false error=null  
+    \[STEP\] step=3 action=click('789') reward=1.00 done=true error=null  
+    \[END\] success=true steps=3 rewards=0.00,0.00,1.00
+
+#### **✅ Example (inference.py)**
+
+```py
+import os
+from openai import OpenAI
+
+# Read environment variables with defaults where required
+API_BASE_URL = os.getenv("API_BASE_URL", "https://api.openai.com/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "gpt-4.1-mini")
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+if HF_TOKEN is None:
+    raise ValueError("HF_TOKEN environment variable is required")
+
+# Initialize OpenAI client
+client = OpenAI(
+    base_url=API_BASE_URL,
+    api_key=HF_TOKEN
+)
+
+def run_inference(prompt: str):
+    response = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+    response = response.choices[0].message.content
+    # Print output based on above given format
+
+
+if __name__ == "__main__":
+    print(run_inference("Hello from OpenEnv!"))
+```
+
+---
+
+### **4\. Hugging Face Space Guidelines**
+
+* Building a Hugging Face Space can take significant time, especially if multiple spaces are active  
+* To avoid delays:  
+  * Turn off all unnecessary spaces  
+  * Keep only your primary submission space running
+
+---
+
+### **5\. Submission Validation Rules**
+
+* The system will **check if your Hugging Face Space is live**  
+* If your space is **not in a running state**, your submission will **fail automatically**
+
+Before submitting:
+
+* Ensure your space is fully built  
+* Confirm it is in the **“Running”** state
+
+---
+
+### **6\. Hardware Requirements**
+
+* Your solution will be executed inside a Docker container with limited resources  
+* It **must run within the following constraints**:  
+  * **2 vCPU**  
+  * **8 GB RAM**
+
+👉 Ensure your model, dependencies, and runtime fit within these limits. Submissions exceeding these constraints may fail during evaluation.
+
+---
+
+### **6\. Resubmissions**
+
+* You are allowed to **resubmit your project multiple times**  
+* If your submission fails validation, you can:  
+  * Fix the issues  
+  * Ensure your Hugging Face Space is running  
+  * Submit again
+
+👉 There is **no penalty for resubmitting**, so iterate until your submission passes all checks.
+
+---
+
+### **⚠️ Common Failure Cases (Avoid These)**
+
+* inference.py not in root directory  
+* Missing default values for API\_BASE\_URL or MODEL\_NAME  
+* Missing HF\_TOKEN  
+* Hugging Face Space still building during submission  
+* Space stopped due to multiple active deployments
+
+### **🚀  Reference projects to guide you**
+
+Here are some strong examples from the San Francisco edition to help you understand how to structure your environment:
+
+* Calendar Environment Server  
+  [https://github.com/meta-pytorch/OpenEnv/tree/main/envs/calendar\_env](https://github.com/meta-pytorch/OpenEnv/tree/main/envs/calendar_env)  
+* Reasoning Gym Environment Server  
+  [https://github.com/meta-pytorch/OpenEnv/tree/main/envs/reasoning\_gym\_env](https://github.com/meta-pytorch/OpenEnv/tree/main/envs/reasoning_gym_env)  
+* TB2 Environment Server  
+  [https://github.com/meta-pytorch/OpenEnv/tree/main/envs/tbench2\_env](https://github.com/meta-pytorch/OpenEnv/tree/main/envs/tbench2_env)  
+* CARLA Environment Server  
+  [https://github.com/meta-pytorch/OpenEnv/tree/main/envs/carla\_env](https://github.com/meta-pytorch/OpenEnv/tree/main/envs/carla_env)  
+* REPL Environment Server  
+  [https://github.com/meta-pytorch/OpenEnv/tree/main/envs/repl\_env](https://github.com/meta-pytorch/OpenEnv/tree/main/envs/repl_env)
+
+Use these as direction, not as templates. Focus on understanding structure and approach.
+

README.md

@@ -1,11 +1,189 @@
 ---
-title: Multipen RL OpenEnv
-emoji: 🐠
-colorFrom: green
-colorTo: indigo
+title: Wildfire Detection Environment
+emoji: 🔥
+colorFrom: red
+colorTo: yellow
 sdk: docker
 pinned: false
-license: apache-2.0
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+  - wildfire-detection
+  - reinforcement-learning
+  - firenet-cnn
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Wildfire Detection RL Environment
+
+An OpenEnv-compatible reinforcement learning environment for autonomous wildfire patrol using the FirenetCNN model. The agent receives sequential camera observations, runs inference, and decides actions to detect fire or smoke as early as possible.
+
+## Features
+
+- **Exact FirenetCNN Inference** - Uses the original model from the Forest-Fire-Detection-Using-FirenetCNN-and-XAI-Techniques repository
+- **Grad-CAM XAI** - Explainable AI with heatmap visualization for model decisions
+- **Sequential Decision Making** - Agent processes multiple frames and learns from context
+- **Reward-based Learning** - Optimizes for early detection while minimizing false alarms
+
+## Quick Start
+
+### Using the Docker Image
+
+```bash
+# Pull and run the pre-built image
+docker run -p 8000:8000 wildfire-detection
+```
+
+### Building from Source
+
+```bash
+# Build the Docker image
+docker build -t wildfire-detection .
+
+# Run the container
+docker run -p 8000:8000 wildfire-detection
+```
+
+### Local Development
+
+```bash
+# Install dependencies
+pip install -e .
+
+# Run the server
+python run_server.py
+```
+
+## API Usage
+
+### Reset Environment
+
+```bash
+curl -X POST http://localhost:8000/reset
+```
+
+### Take Action
+
+```bash
+curl -X POST http://localhost:8000/step \
+  -H "Content-Type: application/json" \
+  -d '{"action": "Alert"}'
+```
+
+### Get Schema
+
+```bash
+curl http://localhost:8000/schema
+```
+
+Access the interactive API docs at http://localhost:8000/docs
+
+## Inference Script
+
+The `inference.py` script runs an LLM agent that makes decisions:
+
+```bash
+# Set API key (injected by judges at evaluation)
+export API_KEY=your_huggingface_token
+
+# Run inference
+python inference.py
+```
+
+### Environment Variables
+
+| Variable | Default | Required |
+|----------|---------|----------|
+| `API_BASE_URL` | `https://router.huggingface.co/v1` | No |
+| `MODEL_NAME` | `Qwen/Qwen2.5-3B-Instruct` | No |
+| `API_KEY` | - | Yes |
+
+### Output Format
+
+The script follows the hackathon output format:
+
+```
+[START] task=wildfire_detection env=wildfire_detection model=Qwen/Qwen2.5-3B-Instruct
+[STEP] step=1 action=Alert reward=-1.00 done=false error=null
+[STEP] step=2 action=Scan reward=0.50 done=false error=null
+[END] success=true steps=16 rewards=-1.00,0.50,2.00,...
+```
+
+## Actions
+
+| Action | Description |
+|--------|-------------|
+| `Alert` | Raise immediate alert if fire/smoke detected |
+| `Scan` | Continue scanning/observing the current frame |
+| `Ignore` | No action needed, clear conditions |
+| `Deploy` | Deploy resources to the detected location |
+
+## Reward Structure
+
+| Reward | Condition |
+|--------|-----------|
+| +2.00 | Correct detection with confidence ≥ 0.85 and clear Grad-CAM alignment |
+| +1.00 | Correct class but lower confidence |
+| +0.50 | Partial credit (right class, weak XAI) |
+| -0.75 | False positive (Alert/Deploy on no_fire) |
+| -1.00 | False negative (missed fire/smoke) |
+| -0.50 | Inaction ("Ignore") when fire/smoke is present |
+| -2.00 | Terminal failure (too many missed detections) |
+
+## Grading
+
+The grader evaluates each episode:
+- **Success**: All fire/smoke frames correctly alerted with zero false positives
+- **Score**: Normalized 0.0-1.0 based on cumulative reward
+
+## Project Structure
+
+```
+multipen/
+├── inference.py                      # LLM agent inference script
+├── wildfire_env.py                   # RL environment (Gym-compatible)
+├── firenet_inference.py              # FirenetCNN + Grad-CAM
+├── models.py                         # Action/Observation models
+├── openenv.yaml                      # OpenEnv configuration
+├── pyproject.toml                    # Dependencies
+├── Dockerfile                        # Container definition
+├── server/
+│   ├── app.py                        # FastAPI server
+│   └── wildfire_environment.py       # OpenEnv wrapper
+└── environments/
+    └── wildfire_detection/
+        ├── wildfire_env.py           # Environment implementation
+        ├── firenet_inference.py      # Model inference
+        └── sample_frames/            # Test images (16 frames)
+```
+
+## Deployment to Hugging Face Spaces
+
+```bash
+# Push to Hugging Face
+openenv push
+
+# Or with options
+openenv push --namespace my-org --private
+```
+
+## Testing
+
+```bash
+# Test environment directly
+python test_env.py
+
+# Test API
+curl http://localhost:8000/health
+curl http://localhost:8000/schema
+```
+
+## Model
+
+Uses FirenetCNN (MobileNetV2-based) from:
+https://github.com/OpelSpeedster/Forest-Fire-Detection-Using-FirenetCNN-and-XAI-Techniques
+
+The model classifies images into:
+- `no_fire` - No fire detected
+- `fire` - Fire detected
+- `smoke` - Smoke detected

__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Multipen Environment."""
+
+from .client import MultipenEnv
+from .models import MultipenAction, MultipenObservation
+
+__all__ = [
+    "MultipenAction",
+    "MultipenObservation",
+    "MultipenEnv",
+]

client.py

@@ -0,0 +1,99 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Multipen Environment Client."""
+
+from typing import Dict
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+from .models import MultipenAction, MultipenObservation
+
+
+class MultipenEnv(
+    EnvClient[MultipenAction, MultipenObservation, State]
+):
+    """
+    Client for the Multipen Environment.
+
+    This client maintains a persistent WebSocket connection to the environment server,
+    enabling efficient multi-step interactions with lower latency.
+    Each client instance has its own dedicated environment session on the server.
+
+    Example:
+        >>> # Connect to a running server
+        >>> with MultipenEnv(base_url="http://localhost:8000") as client:
+        ...     result = client.reset()
+        ...     print(result.observation.echoed_message)
+        ...
+        ...     result = client.step(MultipenAction(message="Hello!"))
+        ...     print(result.observation.echoed_message)
+
+    Example with Docker:
+        >>> # Automatically start container and connect
+        >>> client = MultipenEnv.from_docker_image("multipen-env:latest")
+        >>> try:
+        ...     result = client.reset()
+        ...     result = client.step(MultipenAction(message="Test"))
+        ... finally:
+        ...     client.close()
+    """
+
+    def _step_payload(self, action: MultipenAction) -> Dict:
+        """
+        Convert MultipenAction to JSON payload for step message.
+
+        Args:
+            action: MultipenAction instance
+
+        Returns:
+            Dictionary representation suitable for JSON encoding
+        """
+        return {
+            "message": action.message,
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[MultipenObservation]:
+        """
+        Parse server response into StepResult[MultipenObservation].
+
+        Args:
+            payload: JSON response data from server
+
+        Returns:
+            StepResult with MultipenObservation
+        """
+        obs_data = payload.get("observation", {})
+        observation = MultipenObservation(
+            echoed_message=obs_data.get("echoed_message", ""),
+            message_length=obs_data.get("message_length", 0),
+            done=payload.get("done", False),
+            reward=payload.get("reward"),
+            metadata=obs_data.get("metadata", {}),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> State:
+        """
+        Parse server response into State object.
+
+        Args:
+            payload: JSON response from state request
+
+        Returns:
+            State object with episode_id and step_count
+        """
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

debug_env.py

@@ -0,0 +1,35 @@
+import sys
+import os
+import numpy as np
+
+sys.path.insert(0, r"C:\Users\ASUS\OneDrive\Desktop\RL\multipen")
+
+from environments.wildfire_detection.wildfire_env import WildfireDetectionEnv
+
+env = WildfireDetectionEnv()
+actions = ["Alert", "Scan", "Ignore", "Deploy"]
+
+print("=== Analyzing Environment ===")
+
+for episode in range(2):
+    print(f"\n--- Episode {episode + 1} ---")
+    obs = env.reset()
+
+    for step in range(3):
+        gt = obs["ground_truth"]
+        if hasattr(gt, "__len__") and gt.ndim > 0:
+            gt_idx = int(gt[0])
+        else:
+            gt_idx = int(gt)
+        gt_label = ["fire", "smoke", "no_fire"][gt_idx]
+
+        print(f"Step {step + 1}: GT={gt_label}, Pred={obs['prediction']}")
+
+        for a_idx, a_name in enumerate(actions):
+            obs2, r, done, info = env.step(a_idx)
+            print(f"  {a_name}: reward={r:.2f}")
+
+        if step < 2:
+            obs = obs2
+
+env.close()

environments/wildfire_detection/__init__.py

@@ -0,0 +1,11 @@
+"""Wildfire Detection OpenEnv Environment
+
+This package provides a minimal OpenEnv-compatible RL environment
+that follows the WildfireDetection skill specification. It is designed
+to be extended with the exact FirenetCNN inference pipeline from the
+opposed GitHub repo without modifying that repository.
+"""
+
+from .wildfire_env import WildfireDetectionEnv
+
+__all__ = ["WildfireDetectionEnv"]

environments/wildfire_detection/firenet_inference.py

@@ -0,0 +1,187 @@
+"""
+FirenetCNN Inference Module
+
+This module provides the exact inference and Grad-CAM implementation
+from the Forest-Fire-Detection-Using-FirenetCNN-and-XAI-Techniques repository.
+No modifications to the original repo code.
+"""
+
+import os
+import cv2
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import load_model, Model
+from typing import Tuple, Dict, Any, Optional
+
+
+MODEL_PATH = os.getenv("FIRENET_MODEL_PATH", "FirenetCNN1.h5")
+TARGET_SIZE = (224, 224)
+CLASS_LABELS = ["no_fire", "fire", "smoke"]
+LAST_CONV_LAYER_NAME = "out_relu"
+
+
+def make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index):
+    """Creates a Grad-CAM heatmap."""
+    grad_model = Model(
+        [model.inputs], [model.get_layer(last_conv_layer_name).output, model.output]
+    )
+
+    with tf.GradientTape() as tape:
+        last_conv_layer_output, preds = grad_model(img_array)
+        class_channel = preds[:, pred_index]
+
+    grads = tape.gradient(class_channel, last_conv_layer_output)
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+
+    last_conv_layer_output = last_conv_layer_output[0]
+    heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis]
+    heatmap = tf.squeeze(heatmap)
+
+    heatmap = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap)
+    return heatmap.numpy()
+
+
+def overlay_heatmap(original_img, heatmap, alpha=0.4):
+    """Applies the heatmap to the original image."""
+    heatmap = cv2.resize(heatmap, (original_img.shape[1], original_img.shape[0]))
+    heatmap = np.uint8(255 * heatmap)
+    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+    superimposed_img = heatmap * alpha + original_img
+    superimposed_img = np.clip(superimposed_img, 0, 255).astype(np.uint8)
+    return superimposed_img
+
+
+class FirenetInference:
+    """Wrapper class for FirenetCNN inference with Grad-CAM."""
+
+    def __init__(self, model_path: Optional[str] = None):
+        self.model_path = model_path or MODEL_PATH
+        self.model = None
+        self._load_model()
+
+    def _load_model(self):
+        """Load the FirenetCNN model."""
+        if os.path.exists(self.model_path):
+            self.model = load_model(self.model_path, compile=False)
+        else:
+            raise FileNotFoundError(f"Model not found: {self.model_path}")
+
+    def predict(self, image: np.ndarray) -> Dict[str, Any]:
+        """
+        Run inference on an image and return prediction + Grad-CAM info.
+
+        Args:
+            image: BGR image (from cv2.imread) or RGB image
+
+        Returns:
+            dict with keys:
+                - label: 'fire', 'smoke', or 'no_fire'
+                - confidence: float (0.0-1.0)
+                - class_idx: int (0=no_fire, 1=fire, 2=smoke)
+                - heatmap: numpy array or None
+                - gradcam_summary: str describing heatmap location
+        """
+        original_image = image.copy()
+
+        if image.shape[:2] != TARGET_SIZE[::-1]:
+            image = cv2.resize(image, TARGET_SIZE)
+
+        input_image_scaled = image.astype(np.float32) / 255.0
+        input_image_batch = np.expand_dims(input_image_scaled, axis=0)
+
+        preds = self.model.predict(input_image_batch, verbose=0)
+        confidence = float(np.max(preds[0]))
+        class_idx = int(np.argmax(preds[0]))
+        label = CLASS_LABELS[class_idx]
+
+        heatmap = None
+        gradcam_summary = "N/A"
+
+        if label != "no_fire":
+            heatmap = make_gradcam_heatmap(
+                input_image_batch, self.model, LAST_CONV_LAYER_NAME, class_idx
+            )
+            gradcam_summary = self._summarize_heatmap(heatmap)
+
+        return {
+            "label": label,
+            "confidence": confidence,
+            "class_idx": class_idx,
+            "heatmap": heatmap,
+            "gradcam_summary": gradcam_summary,
+        }
+
+    def _summarize_heatmap(self, heatmap: np.ndarray) -> str:
+        """
+        Summarize the heatmap location as center/left/right/top/bottom.
+        """
+        h, w = heatmap.shape
+        threshold = 0.5
+
+        heatmap_thresh = (heatmap > threshold).astype(np.float32)
+
+        h_half = h // 2
+        w_half = w // 2
+
+        top_region = heatmap_thresh[:h_half, :].sum()
+        bottom_region = heatmap_thresh[h_half:, :].sum()
+        left_region = heatmap_thresh[:, :w_half].sum()
+        right_region = heatmap_thresh[:, w_half:].sum()
+        center_region = heatmap_thresh[h // 4 : 3 * h // 4, w // 4 : 3 * w // 4].sum()
+
+        total = heatmap_thresh.sum()
+        if total == 0:
+            return "no significant hotspot"
+
+        regions = {
+            "center": center_region,
+            "top": top_region,
+            "bottom": bottom_region,
+            "left": left_region,
+            "right": right_region,
+        }
+
+        dominant = max(regions, key=regions.get)
+        return f"hotspot at {dominant}"
+
+
+def load_image_for_inference(image_path: str) -> Optional[np.ndarray]:
+    """Load and preprocess an image for inference."""
+    if not os.path.exists(image_path):
+        return None
+    image = cv2.imread(image_path)
+    return image
+
+
+def extract_video_frames(video_path: str, frame_interval: int = 10) -> list:
+    """
+    Extract frames from a video at regular intervals.
+
+    Args:
+        video_path: Path to video file
+        frame_interval: Extract every N frames
+
+    Returns:
+        List of frames as numpy arrays
+    """
+    frames = []
+    if not os.path.exists(video_path):
+        return frames
+
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return frames
+
+    frame_count = 0
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        if frame_count % frame_interval == 0:
+            frames.append(frame)
+
+        frame_count += 1
+
+    cap.release()
+    return frames

environments/wildfire_detection/wildfire_env.py

@@ -0,0 +1,393 @@
+"""WildfireDetectionEnv
+OpenEnv-compatible environment for autonomous wildfire patrol.
+
+Notes:
+- Action space: ["Alert", "Scan", "Ignore", "Deploy"]
+- Uses exact FirenetCNN inference from the repo (no modifications)
+- Implements reward structure from skill description
+- Includes grader for episode evaluation
+"""
+
+from __future__ import annotations
+
+import os
+import json
+from typing import Dict, Any, Optional, Tuple, List
+import numpy as np
+from PIL import Image
+
+try:
+    import gym
+    from gym import spaces
+except Exception:
+    gym = None
+    spaces = None
+
+    class DummySpace:
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def sample(self):
+            return None
+
+    class DummyEnv:
+        pass
+
+    spaces = type(
+        "spaces", (), {"Dict": DummySpace, "Box": DummySpace, "Discrete": DummySpace}
+    )
+    gym = type("gym", (), {"Env": DummyEnv})
+
+try:
+    from .firenet_inference import FirenetInference, load_image_for_inference
+except (ModuleNotFoundError, ImportError):
+    FirenetInference = None
+    load_image_for_inference = None
+
+
+class WildfireDetectionEnv(
+    gym.Env if "gym" in globals() and gym is not None else object
+):
+    """OpenEnv environment for wildfire detection using FirenetCNN."""
+
+    ACTIONS = ["Alert", "Scan", "Ignore", "Deploy"]
+    CLASS_LABELS = ["no_fire", "fire", "smoke"]
+    MAX_MISSES = 3
+    LOG_FILE = "wildfire_episode_log.txt"
+
+    def __init__(
+        self,
+        frames_dir: Optional[str] = None,
+        model_path: Optional[str] = None,
+        frames_labels: Optional[Dict[str, str]] = None,
+    ):
+        super().__init__()
+
+        self.frames_dir = frames_dir or os.path.join(
+            os.path.dirname(__file__), "sample_frames"
+        )
+        self.model_path = model_path or os.path.join(
+            os.path.dirname(__file__),
+            "..",
+            "..",
+            "FirenetCNN1.h5",
+        )
+
+        self._frames = self._discover_frames()
+        self._max_frames = len(self._frames)
+        self._frame_idx = 0
+        self._step = 0
+        self._missed_count = 0
+        self._cumulative_reward = 0.0
+        self._episode_history: List[Dict[str, Any]] = []
+
+        self._inference = None
+        self._load_inference()
+
+        self._ground_truth_labels = frames_labels or self._load_labels()
+
+        self._frame_height = 224
+        self._frame_width = 224
+        self.observation_space = spaces.Dict(
+            {
+                "image": spaces.Box(
+                    low=0,
+                    high=255,
+                    shape=(self._frame_height, self._frame_width, 3),
+                    dtype=np.uint8,
+                ),
+                "prediction": spaces.Box(
+                    low=0.0, high=1.0, shape=(3,), dtype=np.float32
+                ),
+                "gradcam": spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32),
+                "gradcam_summary": spaces.Box(
+                    low=0, high=1, shape=(1,), dtype=np.int32
+                ),
+                "frame_id": spaces.Box(
+                    low=0, high=max(0, self._max_frames - 1), shape=(1,), dtype=np.int32
+                ),
+                "step": spaces.Box(low=0, high=1_000_000, shape=(1,), dtype=np.int32),
+                "ground_truth": spaces.Box(low=0, high=2, shape=(1,), dtype=np.int32),
+            }
+        )
+
+        self.action_space = spaces.Discrete(len(self.ACTIONS))
+        self._action_str = lambda idx: self.ACTIONS[int(idx)]
+
+    def _load_inference(self):
+        if os.path.exists(self.model_path):
+            try:
+                self._inference = FirenetInference(self.model_path)
+            except Exception:
+                self._inference = None
+        else:
+            self._inference = None
+
+    def _load_labels(self) -> Dict[str, str]:
+        labels = {}
+        for frame in self._frames:
+            if frame:
+                fname = os.path.basename(frame).lower()
+                if "fire" in fname:
+                    labels[frame] = "fire"
+                elif "smoke" in fname:
+                    labels[frame] = "smoke"
+                else:
+                    labels[frame] = "no_fire"
+        return labels
+
+    def _discover_frames(self):
+        frames = []
+        if self.frames_dir and os.path.isdir(self.frames_dir):
+            for fname in sorted(os.listdir(self.frames_dir)):
+                if fname.lower().endswith((".png", ".jpg", ".jpeg", ".bmp", ".gif")):
+                    frames.append(os.path.join(self.frames_dir, fname))
+        if not frames:
+            frames = [None]
+        return frames
+
+    def _run_inference(self, frame: np.ndarray) -> Dict[str, Any]:
+        if self._inference is not None:
+            try:
+                cv2_frame = frame[:, :, ::-1].copy() if frame.shape[-1] == 3 else frame
+                result = self._inference.predict(cv2_frame)
+                class_idx = result["class_idx"]
+                conf = result["confidence"]
+                gradcam_summary_val = (
+                    1 if "hotspot" in result.get("gradcam_summary", "") else 0
+                )
+                return {
+                    "class_idx": class_idx,
+                    "confidence": conf,
+                    "gradcam": np.array([conf], dtype=np.float32),
+                    "gradcam_summary_val": gradcam_summary_val,
+                    "label": result.get("label", self.CLASS_LABELS[class_idx]),
+                    "frame": frame,
+                }
+            except Exception:
+                pass
+
+        gray = np.mean(frame) if frame is not None else 127
+        if gray > 170:
+            class_idx = 1
+            conf = 0.92
+        elif gray > 85:
+            class_idx = 2
+            conf = 0.60
+        else:
+            class_idx = 0
+            conf = 0.40
+        return {
+            "class_idx": class_idx,
+            "confidence": conf,
+            "gradcam": np.array([conf], dtype=np.float32),
+            "gradcam_summary_val": 0,
+            "label": self.CLASS_LABELS[class_idx],
+            "frame": frame,
+        }
+
+    def _compute_reward(
+        self, action: int, inf: Dict[str, Any], ground_truth: str
+    ) -> Tuple[float, bool]:
+        action_str = self._action_str(action)
+        pred_label = inf.get("label", self.CLASS_LABELS[inf["class_idx"]])
+        confidence = inf["confidence"]
+        gradcam_strong = inf.get("gradcam_summary_val", 0) == 1
+
+        # Simplified reward - focus on action vs ground_truth, not prediction match
+        if ground_truth == "no_fire":
+            if action_str in ["Alert", "Deploy"]:
+                return -0.75, False
+            elif action_str == "Ignore":
+                return 0.1, False  # Small positive for correct inaction
+            else:  # Scan
+                return 0.0, False
+
+        if ground_truth in ["fire", "smoke"]:
+            if action_str == "Ignore":
+                self._missed_count += 1
+                return -0.50, self._missed_count >= self.MAX_MISSES
+
+            if action_str in ["Alert", "Deploy"]:
+                # Reward based on confidence regardless of exact prediction match
+                if confidence >= 0.85 and gradcam_strong:
+                    return 2.00, False
+                elif confidence >= 0.70:
+                    return 1.00, False
+                else:
+                    return 0.50, False
+
+            if action_str == "Scan":
+                # Scan is neutral - continue observing
+                return 0.0, False
+
+        return 0.0, False
+
+    def _get_ground_truth(self, frame_path: Optional[str]) -> str:
+        if frame_path and frame_path in self._ground_truth_labels:
+            return self._ground_truth_labels[frame_path]
+        if frame_path:
+            fname = os.path.basename(frame_path).lower()
+            if "fire" in fname:
+                return "fire"
+            elif "smoke" in fname:
+                return "smoke"
+        return "no_fire"
+
+    def reset(
+        self, seed: Optional[int] = None, options: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        if seed is not None:
+            np.random.seed(seed)
+        self._frame_idx = 0
+        self._step = 0
+        self._missed_count = 0
+        self._cumulative_reward = 0.0
+        self._episode_history = []
+
+        frame_path = self._frames[self._frame_idx] if self._frames else None
+        frame = self._load_frame(frame_path)
+        if frame is None:
+            frame = self._synthetic_frame()
+
+        inf = self._run_inference(frame)
+        ground_truth = self._get_ground_truth(frame_path)
+        gradcam_val = inf.get("gradcam_summary_val", 0)
+
+        obs = {
+            "image": frame,
+            "prediction": np.array(
+                [
+                    inf["confidence"] if inf["class_idx"] == 1 else 0.0,
+                    inf["confidence"] if inf["class_idx"] == 2 else 0.0,
+                    inf["confidence"] if inf["class_idx"] == 0 else 0.0,
+                ]
+            ).astype(np.float32),
+            "gradcam": inf["gradcam"],
+            "gradcam_summary": np.array([gradcam_val], dtype=np.int32),
+            "frame_id": np.array([self._frame_idx], dtype=np.int32),
+            "step": np.array([self._step], dtype=np.int32),
+            "ground_truth": np.array(
+                ["fire", "smoke", "no_fire"].index(ground_truth), dtype=np.int32
+            ),
+        }
+        return obs
+
+    def _load_frame(self, path: Optional[str]) -> Optional[np.ndarray]:
+        if path is None:
+            return None
+        try:
+            img = (
+                Image.open(path)
+                .convert("RGB")
+                .resize((self._frame_width, self._frame_height))
+            )
+            return np.asarray(img, dtype=np.uint8)
+        except Exception:
+            return None
+
+    def _synthetic_frame(self) -> np.ndarray:
+        return np.full((self._frame_height, self._frame_width, 3), 128, dtype=np.uint8)
+
+    def step(self, action: int) -> Tuple[Dict[str, Any], float, bool, Dict[str, Any]]:
+        assert 0 <= int(action) < len(self.ACTIONS), "Invalid action"
+        self._step += 1
+        self._frame_idx += 1
+
+        frame_path = (
+            self._frames[self._frame_idx]
+            if self._frame_idx < self._max_frames
+            else None
+        )
+        frame = self._load_frame(frame_path)
+        if frame is None:
+            frame = self._synthetic_frame()
+
+        inf = self._run_inference(frame)
+        ground_truth = self._get_ground_truth(frame_path)
+        gradcam_val = inf.get("gradcam_summary_val", 0)
+
+        reward, terminal_failure = self._compute_reward(action, inf, ground_truth)
+        self._cumulative_reward += reward
+
+        self._episode_history.append(
+            {
+                "step": self._step,
+                "frame_id": self._frame_idx,
+                "action": self._action_str(action),
+                "prediction": inf.get("label", self.CLASS_LABELS[inf["class_idx"]]),
+                "confidence": inf["confidence"],
+                "ground_truth": ground_truth,
+                "reward": reward,
+            }
+        )
+
+        done = terminal_failure or self._frame_idx >= self._max_frames
+
+        obs = {
+            "image": frame,
+            "prediction": np.array(
+                [
+                    inf["confidence"] if inf["class_idx"] == 1 else 0.0,
+                    inf["confidence"] if inf["class_idx"] == 2 else 0.0,
+                    inf["confidence"] if inf["class_idx"] == 0 else 0.0,
+                ]
+            ).astype(np.float32),
+            "gradcam": inf["gradcam"],
+            "gradcam_summary": np.array([gradcam_val], dtype=np.int32),
+            "frame_id": np.array([self._frame_idx], dtype=np.int32),
+            "step": np.array([self._step], dtype=np.int32),
+            "ground_truth": np.array(
+                ["fire", "smoke", "no_fire"].index(ground_truth), dtype=np.int32
+            ),
+        }
+
+        info = {
+            "action": self._action_str(action),
+            "reward": reward,
+            "cumulative_reward": self._cumulative_reward,
+            "prediction": inf.get("label", self.CLASS_LABELS[inf["class_idx"]]),
+            "ground_truth": ground_truth,
+            "confidence": inf["confidence"],
+            "terminal": terminal_failure,
+        }
+
+        if done:
+            self._save_episode_log()
+
+        return obs, reward, done, info
+
+    def _save_episode_log(self):
+        try:
+            with open(self.LOG_FILE, "a") as f:
+                f.write(f"\n=== Episode ===\n")
+                f.write(f"Total frames: {len(self._episode_history)}\n")
+                f.write(f"Cumulative reward: {self._cumulative_reward:.2f}\n")
+                f.write(f"Success: {self._is_success()}\n")
+                for entry in self._episode_history:
+                    f.write(f"  Step {entry['step']}: {entry}\n")
+        except Exception:
+            pass
+
+    def _is_success(self) -> bool:
+        for entry in self._episode_history:
+            gt = entry["ground_truth"]
+            action = entry["action"]
+            if gt in ["fire", "smoke"] and action not in ["Alert", "Deploy"]:
+                return False
+            if gt == "no_fire" and action in ["Alert", "Deploy"]:
+                return False
+        return True
+
+    def grade(self) -> float:
+        if not self._episode_history:
+            return 0.0
+        if self._is_success():
+            return 1.0
+        return max(0.0, self._cumulative_reward / 10.0)
+
+    def render(self, mode: str = "human") -> Optional[Any]:
+        return None
+
+    def close(self) -> None:
+        pass

inference.py

@@ -0,0 +1,261 @@
+"""
+Wildfire Detection Inference Script
+====================================
+For LOCAL TESTING: Uses trained RL model (no API key required)
+For SUBMISSION: Uses OpenAI client with API key injected by judges
+"""
+
+import os
+import sys
+import base64
+import pickle
+from io import BytesIO
+from typing import List, Optional, Dict, Any
+from collections import defaultdict
+
+from openai import OpenAI
+import numpy as np
+from PIL import Image
+
+# Environment variables
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-3B-Instruct")
+API_KEY = os.getenv("API_KEY")
+
+# Check if we can use LLM mode
+USE_LLM = API_KEY is not None
+
+if USE_LLM:
+    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+else:
+    client = None
+    print("NOTE: Running in LOCAL MODE (no API_KEY). Using trained RL model.")
+
+
+# RL Model class for local mode
+class TrainedQLearningAgent:
+    """Trained Q-learning agent for local inference."""
+
+    def __init__(self):
+        model_path = os.path.join(os.path.dirname(__file__), "q_model.pkl")
+        if os.path.exists(model_path):
+            with open(model_path, "rb") as f:
+                self.q_table = defaultdict(lambda: [0.0, 0.0, 0.0, 0.0], pickle.load(f))
+            print(f"Loaded RL model from: {model_path}")
+        else:
+            print("WARNING: No trained model found, using fallback!")
+            self.q_table = defaultdict(lambda: [0.0, 0.0, 0.0, 0.0])
+        self.actions = ["Alert", "Scan", "Ignore", "Deploy"]
+
+    def get_state_key(self, obs):
+        prediction = obs.get("prediction", np.zeros(3))
+        if hasattr(prediction, "tolist"):
+            p = prediction.tolist()
+        else:
+            p = list(prediction)
+        fire_high = 0 if p[0] < 0.5 else 1
+        smoke_high = 0 if p[1] < 0.5 else 1
+        return (fire_high, smoke_high)
+
+    def choose_action(self, state):
+        q_values = self.q_table.get(state, [0.0, 0.0, 0.0, 0.0])
+        if hasattr(q_values, "tolist"):
+            q_values = q_values.tolist()
+        return q_values.index(max(q_values))
+
+    def get_action_name(self, idx):
+        return self.actions[idx]
+
+
+# Import environment
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from environments.wildfire_detection.wildfire_env import WildfireDetectionEnv
+
+
+def encode_image_to_base64(image_array: np.ndarray) -> str:
+    """Convert numpy image to base64 data URI."""
+    image = Image.fromarray(image_array)
+    buffer = BytesIO()
+    image.save(buffer, format="JPEG", quality=85)
+    buffer.seek(0)
+    data = base64.b64encode(buffer.read()).decode("utf-8")
+    return f"data:image/jpeg;base64,{data}"
+
+
+def build_observation_prompt(step: int, obs: Dict[str, Any]) -> str:
+    """Build user prompt from observation."""
+    prediction = obs.get("prediction", {})
+    fire_prob = prediction[0] if hasattr(prediction, "__getitem__") else 0
+    smoke_prob = prediction[1] if hasattr(prediction, "__getitem__") else 0
+    no_fire_prob = prediction[2] if hasattr(prediction, "__getitem__") else 0
+
+    gradcam = obs.get("gradcam_summary", "N/A")
+    frame_id = (
+        obs.get("frame_id", [0])[0]
+        if hasattr(obs.get("frame_id", [0]), "__len__")
+        else 0
+    )
+
+    prompt = f"""Frame {frame_id} - Step {step}
+Prediction probabilities:
+  - Fire: {fire_prob:.2%}
+  - Smoke: {smoke_prob:.2%}
+  - No Fire: {no_fire_prob:.2%}
+  
+Grad-CAM analysis: {gradcam}
+
+What is your action? (Alert/Scan/Ignore/Deploy)
+"""
+    return prompt.strip()
+
+
+def parse_action(response_text: str) -> str:
+    """Parse LLM response to extract action."""
+    if not response_text:
+        return "Scan"
+    response = response_text.strip().lower()
+    if "alert" in response:
+        return "Alert"
+    elif "deploy" in response:
+        return "Deploy"
+    elif "ignore" in response:
+        return "Ignore"
+    return "Scan"
+
+
+def action_to_index(action: str) -> int:
+    actions = ["Alert", "Scan", "Ignore", "Deploy"]
+    return actions.index(action) if action in actions else 1
+
+
+MAX_STEPS = 20
+TEMPERATURE = 0.2
+MAX_TOKENS = 500
+
+SYSTEM_PROMPT = """You are an autonomous wildfire detection agent. You control a drone monitoring for fires and smoke.
+
+Given camera frame observations with prediction probabilities and Grad-CAM analysis, decide the best action.
+
+Actions available:
+- Alert: Raise immediate alert if fire/smoke detected with high confidence
+- Scan: Continue scanning/observing the current frame more carefully  
+- Ignore: No action needed, clear conditions
+- Deploy: Deploy resources to the detected location
+
+Output ONLY the action name: Alert, Scan, Ignore, or Deploy
+
+Consider:
+- Prediction confidence levels
+- Grad-CAM heatmap alignment (strong hotspot = more reliable detection)
+- Balance early detection vs false alarms
+- Sequential frame context
+"""
+
+
+def run_episode(env) -> Dict[str, Any]:
+    """Run a single episode and return results."""
+    rewards_list = []
+    steps_executed = 0
+
+    # Use appropriate model name based on mode
+    model_used = MODEL_NAME if USE_LLM else "trained_q_learning"
+    print(f"[START] task=wildfire_detection env=wildfire_detection model={model_used}")
+
+    # Initialize RL agent for local mode
+    rl_agent = TrainedQLearningAgent() if not USE_LLM else None
+
+    obs = env.reset()
+
+    for step in range(1, MAX_STEPS + 1):
+        steps_executed = step
+
+        if USE_LLM:
+            # LLM mode
+            user_prompt = build_observation_prompt(step, obs)
+
+            image_b64 = ""
+            if "image" in obs and obs["image"] is not None:
+                image_b64 = encode_image_to_base64(obs["image"])
+
+            messages = [
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": user_prompt},
+                        {"type": "image_url", "image_url": {"url": image_b64}}
+                        if image_b64
+                        else {"type": "text", "text": "(no image)"},
+                    ],
+                },
+            ]
+
+            try:
+                completion = client.chat.completions.create(
+                    model=MODEL_NAME,
+                    messages=messages,
+                    temperature=TEMPERATURE,
+                    max_tokens=MAX_TOKENS,
+                    stream=False,
+                )
+                response_text = completion.choices[0].message.content or ""
+            except Exception as e:
+                print(f"Model request failed: {e}. Using fallback.")
+                response_text = "Scan"
+
+            action_str = parse_action(response_text)
+        else:
+            # RL mode
+            state = rl_agent.get_state_key(obs)
+            action_idx = rl_agent.choose_action(state)
+            action_str = rl_agent.get_action_name(action_idx)
+
+        action_idx = action_to_index(action_str)
+
+        obs, reward, done, info = env.step(action_idx)
+        rewards_list.append(reward)
+
+        error_msg = "null"
+        print(
+            f"[STEP] step={step} action={action_str} reward={reward:.2f} done={str(done).lower()} error={error_msg}"
+        )
+
+        if done:
+            break
+
+    total_reward = sum(rewards_list)
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards_list)
+    success = total_reward > 0
+
+    print(
+        f"[END] success={str(success).lower()} steps={steps_executed} rewards={rewards_str}"
+    )
+
+    return {
+        "success": success,
+        "steps": steps_executed,
+        "rewards": rewards_list,
+        "total_reward": total_reward,
+    }
+
+
+def main():
+    """Main entry point."""
+    model_path = os.path.join(
+        os.path.dirname(__file__),
+        "FirenetCNN1.h5",
+    )
+
+    env = WildfireDetectionEnv(model_path=model_path)
+
+    try:
+        result = run_episode(env)
+        print(
+            f"Episode completed: success={result['success']}, steps={result['steps']}, total_reward={result['total_reward']:.2f}"
+        )
+    finally:
+        env.close()
+
+
+if __name__ == "__main__":
+    main()

inference_rl.py

@@ -0,0 +1,120 @@
+"""
+Wildfire Detection RL Inference Script
+=======================================
+Uses trained Q-learning model for decision making.
+"""
+
+import os
+import sys
+import pickle
+import numpy as np
+from collections import defaultdict
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from environments.wildfire_detection.wildfire_env import WildfireDetectionEnv
+
+
+class TrainedQLearningAgent:
+    """Trained Q-learning agent for inference."""
+
+    def __init__(self, model_path=None):
+        self.model_path = model_path or os.path.join(
+            os.path.dirname(__file__), "q_model.pkl"
+        )
+        self.q_table = None
+        self.actions = ["Alert", "Scan", "Ignore", "Deploy"]
+        self._load_model()
+
+    def _load_model(self):
+        if os.path.exists(self.model_path):
+            with open(self.model_path, "rb") as f:
+                self.q_table = defaultdict(lambda: [0.0, 0.0, 0.0, 0.0], pickle.load(f))
+            print(f"Loaded trained model from: {self.model_path}")
+            print(f"Q-table: {dict(self.q_table)}")
+        else:
+            print("WARNING: No trained model found!")
+            self.q_table = defaultdict(lambda: [0.0, 0.0, 0.0, 0.0])
+
+    def get_state_key(self, obs):
+        """Convert observation to discrete state key."""
+        prediction = obs.get("prediction", np.zeros(3))
+        if hasattr(prediction, "tolist"):
+            p = prediction.tolist()
+        elif hasattr(prediction, "__iter__"):
+            p = list(prediction)
+        else:
+            p = [0, 0, 0]
+
+        # Match training: fire_high, smoke_high
+        fire_high = 0 if p[0] < 0.5 else 1
+        smoke_high = 0 if p[1] < 0.5 else 1
+
+        return (fire_high, smoke_high)
+
+    def choose_action(self, state):
+        """Choose best action based on Q-values."""
+        q_values = self.q_table.get(state, [0.0, 0.0, 0.0, 0.0])
+        if hasattr(q_values, "tolist"):
+            q_values = q_values.tolist()
+        return q_values.index(max(q_values))
+
+    def get_action_name(self, action_idx):
+        return self.actions[action_idx]
+
+
+def run_inference():
+    """Run inference with trained RL agent."""
+    print(
+        "[START] task=wildfire_detection env=wildfire_detection model=trained_q_learning"
+    )
+
+    env = WildfireDetectionEnv()
+    agent = TrainedQLearningAgent()
+
+    rewards_list = []
+    steps_executed = 0
+
+    obs = env.reset()
+
+    for step in range(1, 21):
+        steps_executed = step
+
+        state = agent.get_state_key(obs)
+        action_idx = agent.choose_action(state)
+        action_str = agent.get_action_name(action_idx)
+
+        obs, reward, done, info = env.step(action_idx)
+        rewards_list.append(reward)
+
+        error_msg = "null"
+        print(
+            f"[STEP] step={step} action={action_str} reward={reward:.2f} done={str(done).lower()} error={error_msg}"
+        )
+
+        if done:
+            break
+
+    env.close()
+
+    total_reward = sum(rewards_list)
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards_list)
+    success = total_reward > 0
+
+    print(
+        f"[END] success={str(success).lower()} steps={steps_executed} rewards={rewards_str}"
+    )
+
+    return {
+        "success": success,
+        "steps": steps_executed,
+        "rewards": rewards_list,
+        "total_reward": total_reward,
+    }
+
+
+if __name__ == "__main__":
+    result = run_inference()
+    print(
+        f"\nResult: success={result['success']}, total_reward={result['total_reward']:.2f}"
+    )

models.py

@@ -0,0 +1,42 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Data models for the Wildfire Detection Environment.
+"""
+
+from openenv.core.env_server.types import Action, Observation
+from pydantic import Field
+from typing import Optional, Dict, Any
+
+
+class WildfireAction(Action):
+    """Action for the Wildfire Detection environment."""
+
+    action: str = Field(
+        ..., description="Action to take: Alert, Scan, Ignore, or Deploy"
+    )
+
+
+class WildfireObservation(Observation):
+    """Observation from the Wildfire Detection environment."""
+
+    image: str = Field(default="", description="Base64 encoded image or file path")
+    prediction: Dict[str, float] = Field(
+        default_factory=dict,
+        description="Prediction probabilities for fire, smoke, no_fire",
+    )
+    gradcam_summary: str = Field(default="", description="Grad-CAM heatmap summary")
+    frame_id: int = Field(default=0, description="Current frame ID")
+    step: int = Field(default=0, description="Current step")
+    ground_truth: str = Field(
+        default="", description="Ground truth label (for training)"
+    )
+    reward: float = Field(default=0.0, description="Reward for the last action")
+    done: bool = Field(default=False, description="Whether episode is done")
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict, description="Additional metadata"
+    )

openenv.yaml

@@ -0,0 +1,6 @@
+spec_version: 1
+name: wildfire_detection
+type: space
+runtime: fastapi
+app: run_server:main
+port: 8000

openenv_wildfire_detection.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: openenv-wildfire-detection
+Version: 0.1.0
+Summary: Wildfire Detection RL Environment for OpenEnv
+Requires-Python: >=3.10
+Requires-Dist: openenv-core[core]>=0.2.2
+Requires-Dist: numpy>=1.19.0
+Requires-Dist: pillow>=10.0.0
+Requires-Dist: opencv-python>=4.8.0
+Requires-Dist: tensorflow>=2.15.0
+Requires-Dist: gymnasium>=0.29.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

openenv_wildfire_detection.egg-info/SOURCES.txt

@@ -0,0 +1,30 @@
+README.md
+__init__.py
+client.py
+inference.py
+models.py
+pyproject.toml
+run_server.py
+test_env.py
+./__init__.py
+./client.py
+./debug_env.py
+./inference.py
+./inference_rl.py
+./models.py
+./run_server.py
+./test_env.py
+./train_rl.py
+environments/wildfire_detection/__init__.py
+environments/wildfire_detection/firenet_inference.py
+environments/wildfire_detection/wildfire_env.py
+openenv_wildfire_detection.egg-info/PKG-INFO
+openenv_wildfire_detection.egg-info/SOURCES.txt
+openenv_wildfire_detection.egg-info/dependency_links.txt
+openenv_wildfire_detection.egg-info/entry_points.txt
+openenv_wildfire_detection.egg-info/requires.txt
+openenv_wildfire_detection.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/multipen_environment.py
+server/wildfire_environment.py

openenv_wildfire_detection.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_wildfire_detection.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = multipen.server.app:main

openenv_wildfire_detection.egg-info/requires.txt

@@ -0,0 +1,10 @@
+openenv-core[core]>=0.2.2
+numpy>=1.19.0
+pillow>=10.0.0
+opencv-python>=4.8.0
+tensorflow>=2.15.0
+gymnasium>=0.29.0
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0

openenv_wildfire_detection.egg-info/top_level.txt

@@ -0,0 +1 @@
+multipen

push_hf.py

@@ -0,0 +1,21 @@
+import os
+
+os.environ["PYTHONIOENCODING"] = "utf-8"
+import subprocess
+
+result = subprocess.run(
+    [
+        "python",
+        "-m",
+        "openenv.cli",
+        "push",
+        "--repo-id",
+        "OpelSpeedster/Wildfire-Detection_Openenv",
+    ],
+    cwd=r"C:\Users\ASUS\OneDrive\Desktop\RL\multipen",
+    capture_output=True,
+    text=True,
+    encoding="utf-8",
+)
+print("STDOUT:", result.stdout)
+print("STDERR:", result.stderr)

pyproject.toml

@@ -0,0 +1,40 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-wildfire-detection"
+version = "0.1.0"
+description = "Wildfire Detection RL Environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime
+    "openenv-core[core]>=0.2.2",
+    # Environment dependencies
+    "numpy>=1.19.0",
+    "pillow>=10.0.0",
+    "opencv-python>=4.8.0",
+    "tensorflow>=2.15.0",
+    # RL dependencies
+    "gymnasium>=0.29.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+server = "multipen.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["multipen", "multipen.server", "multipen.environments.wildfire_detection"]
+package-dir = { "multipen" = ".", "multipen.server" = "server", "multipen.environments.wildfire_detection" = "environments/wildfire_detection" }

q_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ade681309aa444dc7029e5afe08520935fdec605afbcde5d3bc18ea3f553ee24
+size 326

requirements.txt

@@ -0,0 +1,107 @@
+aiofile==3.9.0
+aiofiles==24.1.0
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anyio==4.13.0
+attrs==26.1.0
+Authlib==1.6.9
+beartype==0.22.9
+brotli==1.2.0
+cachetools==7.0.5
+caio==0.9.25
+certifi==2026.2.25
+cffi==2.0.0
+charset-normalizer==3.4.7
+click==8.3.2
+cryptography==46.0.7
+cyclopts==4.10.1
+distro==1.9.0
+dnspython==2.8.0
+docstring_parser==0.17.0
+docutils==0.22.4
+email-validator==2.3.0
+exceptiongroup==1.3.1
+fastapi==0.135.3
+fastmcp==3.2.0
+ffmpy==1.0.0
+filelock==3.25.2
+fsspec==2026.3.0
+gradio==6.11.0
+gradio_client==2.4.0
+groovy==0.1.2
+h11==0.16.0
+hf-gradio==0.3.0
+hf-xet==1.4.3
+httpcore==1.0.9
+httpx==0.28.1
+httpx-sse==0.4.3
+huggingface_hub==1.9.2
+idna==3.11
+importlib_metadata==8.7.1
+jaraco.classes==3.4.0
+jaraco.context==6.1.2
+jaraco.functools==4.4.0
+jeepney==0.9.0
+Jinja2==3.1.6
+jiter==0.13.0
+jsonref==1.1.0
+jsonschema==4.26.0
+jsonschema-path==0.4.5
+jsonschema-specifications==2025.9.1
+keyring==25.7.0
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+mcp==1.27.0
+mdurl==0.1.2
+more-itertools==11.0.1
+numpy==2.4.4
+openai==2.30.0
+openapi-pydantic==0.5.1
+openenv-core==0.2.3
+opentelemetry-api==1.40.0
+orjson==3.11.8
+packaging==26.0
+pandas==3.0.2
+pathable==0.5.0
+pillow==12.2.0
+platformdirs==4.9.4
+py-key-value-aio==0.4.4
+pycparser==3.0
+pydantic==2.12.5
+pydantic-settings==2.13.1
+pydantic_core==2.41.5
+pydub==0.25.1
+Pygments==2.20.0
+PyJWT==2.12.1
+pyperclip==1.11.0
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.2
+python-multipart==0.0.24
+pytz==2026.1.post1
+PyYAML==6.0.3
+referencing==0.37.0
+requests==2.33.1
+rich==14.3.3
+rich-rst==1.3.2
+rpds-py==0.30.0
+safehttpx==0.1.7
+SecretStorage==3.5.0
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+sse-starlette==3.3.4
+starlette==1.0.0
+tomli==2.4.1
+tomli_w==1.2.0
+tomlkit==0.13.3
+tqdm==4.67.3
+typer==0.24.1
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+uncalled-for==0.3.1
+urllib3==2.6.3
+uvicorn==0.44.0
+watchfiles==1.1.1
+websockets==16.0
+zipp==3.23.0

run_server.py

@@ -0,0 +1,7 @@
+import uvicorn
+from server.app import app
+
+if __name__ == "__main__":
+    print("Starting Wildfire Detection OpenEnv Server...")
+    print("Server will be available at http://localhost:8000")
+    uvicorn.run(app, host="0.0.0.0", port=8000)

server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Wildfire Detection environment server components."""
+
+from .wildfire_environment import WildfireEnvironment
+
+__all__ = ["WildfireEnvironment"]

server/app.py

@@ -0,0 +1,64 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the Wildfire Detection Environment.
+
+This module creates an HTTP server that exposes the WildfireEnvironment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Endpoints:
+    - POST /reset: Reset the environment
+    - POST /step: Execute an action
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m server.app
+"""
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:
+    raise ImportError("openenv is required for the web interface.") from e
+
+try:
+    from models import WildfireAction, WildfireObservation
+except (ModuleNotFoundError, ImportError):
+    from multipen.models import WildfireAction, WildfireObservation
+
+try:
+    from server.wildfire_environment import WildfireEnvironment
+except (ModuleNotFoundError, ImportError):
+    from multipen.server.wildfire_environment import WildfireEnvironment
+
+
+app = create_app(
+    WildfireEnvironment,
+    WildfireAction,
+    WildfireObservation,
+    env_name="wildfire_detection",
+    max_concurrent_envs=1,
+)
+
+
+def main():
+    """Entry point for direct execution."""
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    main()

server/multipen_environment.py

@@ -0,0 +1,104 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Multipen Environment Implementation.
+
+A simple test environment that echoes back messages sent to it.
+Perfect for testing HTTP server infrastructure.
+"""
+
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+try:
+    from ..models import MultipenAction, MultipenObservation
+except ImportError:
+    from models import MultipenAction, MultipenObservation
+
+
+class MultipenEnvironment(Environment):
+    """
+    A simple echo environment that echoes back messages.
+
+    This environment is designed for testing the HTTP server infrastructure.
+    It maintains minimal state and simply echoes back whatever message it receives.
+
+    Example:
+        >>> env = MultipenEnvironment()
+        >>> obs = env.reset()
+        >>> print(obs.echoed_message)  # "Multipen environment ready!"
+        >>>
+        >>> obs = env.step(MultipenAction(message="Hello"))
+        >>> print(obs.echoed_message)  # "Hello"
+        >>> print(obs.message_length)  # 5
+    """
+
+    # Enable concurrent WebSocket sessions.
+    # Set to True if your environment isolates state between instances.
+    # When True, multiple WebSocket clients can connect simultaneously, each
+    # getting their own environment instance (when using factory mode in app.py).
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+        """Initialize the multipen environment."""
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._reset_count = 0
+
+    def reset(self) -> MultipenObservation:
+        """
+        Reset the environment.
+
+        Returns:
+            MultipenObservation with a ready message
+        """
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._reset_count += 1
+
+        return MultipenObservation(
+            echoed_message="Multipen environment ready!",
+            message_length=0,
+            done=False,
+            reward=0.0,
+        )
+
+    def step(self, action: MultipenAction) -> MultipenObservation:  # type: ignore[override]
+        """
+        Execute a step in the environment by echoing the message.
+
+        Args:
+            action: MultipenAction containing the message to echo
+
+        Returns:
+            MultipenObservation with the echoed message and its length
+        """
+        self._state.step_count += 1
+
+        message = action.message
+        length = len(message)
+
+        # Simple reward: longer messages get higher rewards
+        reward = length * 0.1
+
+        return MultipenObservation(
+            echoed_message=message,
+            message_length=length,
+            done=False,
+            reward=reward,
+            metadata={"original_message": message, "step": self._state.step_count},
+        )
+
+    @property
+    def state(self) -> State:
+        """
+        Get the current environment state.
+
+        Returns:
+            Current State with episode_id and step_count
+        """
+        return self._state

server/requirements.txt

@@ -0,0 +1,9 @@
+openenv-core[core]>=0.2.2
+numpy>=1.19.0
+pillow>=10.0.0
+opencv-python>=4.8.0
+tensorflow>=2.15.0
+gymnasium>=0.29.0
+fastapi>=0.104.0
+uvicorn>=0.24.0
+pydantic>=2.0.0

server/wildfire_environment.py

@@ -0,0 +1,102 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Wildfire Detection Environment Implementation.
+
+This environment uses the FirenetCNN model for wildfire detection.
+"""
+
+import os
+import base64
+from uuid import uuid4
+from io import BytesIO
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+try:
+    from ..models import WildfireAction, WildfireObservation
+except ImportError:
+    from models import WildfireAction, WildfireObservation
+
+try:
+    from environments.wildfire_detection.wildfire_env import WildfireDetectionEnv
+except ModuleNotFoundError:
+    from multipen.environments.wildfire_detection.wildfire_env import (
+        WildfireDetectionEnv,
+    )
+
+
+class WildfireEnvironment(Environment):
+    """OpenEnv environment for wildfire detection using FirenetCNN."""
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._env = None
+        self._init_env()
+
+    def _init_env(self):
+        model_path = os.path.join(
+            os.path.dirname(__file__),
+            "..",
+            "..",
+            "Forest-Fire-Detection-Using-FirenetCNN-and-XAI-Techniques",
+            "FirenetCNN1.h5",
+        )
+        self._env = WildfireDetectionEnv(model_path=model_path)
+
+    def reset(self) -> WildfireObservation:
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        obs = self._env.reset()
+
+        return self._make_observation(obs, 0.0, False)
+
+    def step(self, action: WildfireAction) -> WildfireObservation:
+        self._state.step_count += 1
+
+        action_idx = ["Alert", "Scan", "Ignore", "Deploy"].index(action.action)
+        obs, reward, done, info = self._env.step(action_idx)
+
+        return self._make_observation(obs, reward, done, info)
+
+    def _make_observation(
+        self, obs: dict, reward: float, done: bool
+    ) -> WildfireObservation:
+        img = obs.get("image")
+        img_b64 = ""
+        if img is not None:
+            from PIL import Image
+            import numpy as np
+
+            pil_img = Image.fromarray(img)
+            buffer = BytesIO()
+            pil_img.save(buffer, format="JPEG")
+            img_b64 = base64.b64encode(buffer.getvalue()).decode()
+
+        return WildfireObservation(
+            image=img_b64,
+            prediction={
+                "fire": float(obs.get("prediction", [0, 0, 0])[0]),
+                "smoke": float(obs.get("prediction", [0, 0, 0])[1]),
+                "no_fire": float(obs.get("prediction", [0, 0, 0])[2]),
+            },
+            gradcam_summary=f"Grad-CAM: {obs.get('gradcam_summary', [0])[0]}",
+            frame_id=int(obs.get("frame_id", [0])[0]),
+            step=int(obs.get("step", [0])[0]),
+            ground_truth=["fire", "smoke", "no_fire"][
+                int(obs.get("ground_truth", [2])[0])
+            ],
+            reward=reward,
+            done=done,
+            metadata={},
+        )
+
+    @property
+    def state(self) -> State:
+        return self._state

test_env.py

@@ -0,0 +1,19 @@
+import sys
+import os
+
+sys.path.insert(0, r"C:\Users\ASUS\OneDrive\Desktop\RL\multipen")
+
+from environments.wildfire_detection.wildfire_env import WildfireDetectionEnv
+
+print("Creating environment...")
+env = WildfireDetectionEnv()
+print("Environment created successfully")
+
+obs = env.reset()
+print(f"Reset successful, step: {obs['step']}")
+
+action = 0  # Alert
+obs, reward, done, info = env.step(action)
+print(f"Step taken: action={info['action']}, reward={reward}, done={done}")
+
+print("Environment test passed!")

train_rl.py

@@ -0,0 +1,209 @@
+"""
+Wildfire Detection RL Training (Fast Version)
+==============================================
+"""
+
+import os
+import sys
+import numpy as np
+from collections import defaultdict
+import pickle
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Pre-computed frame data to avoid slow TensorFlow loading
+FRAME_DATA = [
+    {"prediction": [0.9, 0.1, 0.0], "ground_truth": 0, "frame": 0},  # fire
+    {"prediction": [0.85, 0.15, 0.0], "ground_truth": 0, "frame": 1},  # fire
+    {"prediction": [0.8, 0.2, 0.0], "ground_truth": 0, "frame": 2},  # fire
+    {"prediction": [0.7, 0.25, 0.05], "ground_truth": 0, "frame": 3},  # fire
+    {"prediction": [0.6, 0.3, 0.1], "ground_truth": 0, "frame": 4},  # fire
+    {"prediction": [0.5, 0.4, 0.1], "ground_truth": 1, "frame": 5},  # smoke
+    {"prediction": [0.3, 0.6, 0.1], "ground_truth": 1, "frame": 6},  # smoke
+    {"prediction": [0.2, 0.7, 0.1], "ground_truth": 1, "frame": 7},  # smoke
+    {"prediction": [0.1, 0.8, 0.1], "ground_truth": 1, "frame": 8},  # smoke
+    {"prediction": [0.1, 0.85, 0.05], "ground_truth": 1, "frame": 9},  # smoke
+    {"prediction": [0.0, 0.1, 0.9], "ground_truth": 2, "frame": 10},  # no_fire
+    {"prediction": [0.0, 0.05, 0.95], "ground_truth": 2, "frame": 11},  # no_fire
+    {"prediction": [0.05, 0.05, 0.9], "ground_truth": 2, "frame": 12},  # no_fire
+    {"prediction": [0.0, 0.0, 1.0], "ground_truth": 2, "frame": 13},  # no_fire
+    {"prediction": [0.0, 0.0, 1.0], "ground_truth": 2, "frame": 14},  # no_fire
+    {"prediction": [0.9, 0.1, 0.0], "ground_truth": 0, "frame": 15},  # fire (repeat)
+]
+
+
+class FastEnv:
+    """Fast environment without TensorFlow."""
+
+    ACTIONS = ["Alert", "Scan", "Ignore", "Deploy"]
+    CLASS_LABELS = ["fire", "smoke", "no_fire"]
+
+    def __init__(self):
+        self.frame_idx = 0
+        self.n_frames = len(FRAME_DATA)
+
+    def reset(self):
+        self.frame_idx = 0
+        return self._get_obs()
+
+    def step(self, action):
+        frame = FRAME_DATA[self.frame_idx]
+        gt = frame["ground_truth"]
+        action_str = self.ACTIONS[action]
+
+        # Reward function
+        if gt == 2:  # no_fire
+            if action_str in ["Alert", "Deploy"]:
+                reward = -0.75
+            elif action_str == "Ignore":
+                reward = 0.1
+            else:
+                reward = 0.0
+        else:  # fire or smoke
+            if action_str == "Ignore":
+                reward = -0.50
+            elif action_str in ["Alert", "Deploy"]:
+                reward = 0.50
+            else:  # Scan
+                reward = 0.0
+
+        # Move to next frame BEFORE checking done
+        self.frame_idx += 1
+        done = self.frame_idx >= self.n_frames
+
+        # If we moved past valid frames, return last observation but mark done
+        if done:
+            obs = {
+                "prediction": np.array([0, 0, 0], dtype=np.float32),
+                "ground_truth": np.array([2], dtype=np.int32),
+                "frame_id": np.array([self.frame_idx - 1], dtype=np.int32),
+            }
+        else:
+            obs = self._get_obs()
+
+        return obs, reward, done, {"ground_truth": self.CLASS_LABELS[gt]}
+
+    def _get_obs(self):
+        frame = FRAME_DATA[self.frame_idx]
+        return {
+            "prediction": np.array(frame["prediction"], dtype=np.float32),
+            "ground_truth": np.array([frame["ground_truth"]], dtype=np.int32),
+            "frame_id": np.array([self.frame_idx], dtype=np.int32),
+        }
+
+
+class QLearningAgent:
+    def __init__(
+        self,
+        n_actions=4,
+        learning_rate=0.4,
+        discount_factor=0.9,
+        epsilon=1.0,
+        epsilon_decay=0.98,
+        epsilon_min=0.05,
+    ):
+        self.n_actions = n_actions
+        self.lr = learning_rate
+        self.gamma = discount_factor
+        self.epsilon = epsilon
+        self.epsilon_decay = epsilon_decay
+        self.epsilon_min = epsilon_min
+        self.q_table = defaultdict(lambda: np.zeros(n_actions))
+
+    def get_state_key(self, obs):
+        p = obs["prediction"]
+        fire_high = 0 if p[0] < 0.5 else 1
+        smoke_high = 0 if p[1] < 0.5 else 1
+        return (fire_high, smoke_high)
+
+    def choose_action(self, state):
+        if np.random.random() < self.epsilon:
+            return np.random.randint(self.n_actions)
+        return np.argmax(self.q_table[state])
+
+    def learn(self, state, action, reward, next_state):
+        current_q = self.q_table[state][action]
+        max_next_q = np.max(self.q_table[next_state])
+        td_target = reward + self.gamma * max_next_q
+        self.q_table[state][action] = current_q + self.lr * (td_target - current_q)
+
+    def decay_epsilon(self):
+        self.epsilon = max(self.epsilon_min, self.epsilon * self.epsilon_decay)
+
+
+def train_agent(num_episodes=200):
+    print("Initializing fast environment...")
+    env = FastEnv()
+
+    agent = QLearningAgent()
+
+    print(f"\nTraining for {num_episodes} episodes...")
+
+    for episode in range(num_episodes):
+        obs = env.reset()
+        state = agent.get_state_key(obs)
+        total_reward = 0
+        done = False
+
+        while not done:
+            action = agent.choose_action(state)
+            obs, reward, done, info = env.step(action)
+            next_state = agent.get_state_key(obs)
+
+            agent.learn(state, action, reward, next_state)
+            total_reward += reward
+            state = next_state
+
+        agent.decay_epsilon()
+
+        if (episode + 1) % 20 == 0:
+            print(
+                f"Episode {episode + 1}/{num_episodes} | Reward: {total_reward:.2f} | Epsilon: {agent.epsilon:.3f}"
+            )
+
+    # Save model
+    model_path = os.path.join(os.path.dirname(__file__), "q_model.pkl")
+    with open(model_path, "wb") as f:
+        pickle.dump(dict(agent.q_table), f)
+
+    print(f"\nTraining complete!")
+    print(f"Q-table: {dict(agent.q_table)}")
+    print(f"Model saved to: {model_path}")
+
+    return agent
+
+
+def evaluate():
+    env = FastEnv()
+
+    model_path = os.path.join(os.path.dirname(__file__), "q_model.pkl")
+    with open(model_path, "rb") as f:
+        q_table = pickle.load(f)
+
+    agent = QLearningAgent()
+    agent.q_table = defaultdict(lambda: np.zeros(4), q_table)
+    agent.epsilon = 0
+
+    print("\n=== Evaluation ===")
+
+    for ep in range(3):
+        obs = env.reset()
+        state = agent.get_state_key(obs)
+        total_reward = 0
+        done = False
+        actions = []
+
+        while not done:
+            action = agent.choose_action(state)
+            actions.append(["Alert", "Scan", "Ignore", "Deploy"][action])
+            obs, reward, done, _ = env.step(action)
+            total_reward += reward
+            state = agent.get_state_key(obs)
+
+        print(f"Episode: {actions}")
+        print(f"Reward: {total_reward:.2f}")
+
+
+if __name__ == "__main__":
+    train_agent(200)
+    evaluate()