DONKEY13479/ForestFireFIghting_plan

Forest Fire Fighting UAV Mission Planning

An instruction-tuning dataset for multi-UAV forest-fire fighting mission planning. Each example gives a model a complete situational prompt — the drone command API, the available UAV fleet, and the zone/fire-point layout of the fire scene — and asks it to emit an executable Python mission chain that dispatches the fleet: extinguishing drones bomb every fire point and then sweep their zones, surveillance drones cover the remaining zones, payload limits are respected with resupply sorties, and every drone returns to base.

The target outputs are pure-ASCII Python using a fixed set of mission primitives (takeoff, fly_to_point, hover_and_wait, drop_water_bomb, SearchArea, return_to_base, land, resupply), so the dataset is directly usable for code-generation SFT and for evaluating whether a model can satisfy a dense set of hard spatial/logistical constraints simultaneously.

Dataset Details

• Size: 9,932 rows (9,000 unique instruction + output pairs)
• Format: Alpaca-style (instruction / input / output)
• Language: English, ASCII-only
• Total file size: 116.9 MB

The task

Every instruction is one self-contained prompt with the same five-part layout:

1. Format rules — the output must start with #, be pure ASCII, and contain no markdown fences or prose.
2. Core rules (1–13) — the constraint set the generated mission must satisfy. Rule 13 is the single soft objective; the rest are hard constraints.
3. Command API reference — Python stubs with docstrings for the eight mission primitives listed above.
4. UAV RESOURCES: — a JSON line per available drone, giving type (extinguishing_drone or surveillance_drone), location, battery, and capabilities (max_fire_extinguisher, current_payload, max_speed, sensor_range).
5. ZONES (JSON): — the scene as a JSON array of zones, each with id, risk_level (High / Low / Monitor), normalized polygon coordinates in [0, 1], and a fire_points list (always empty for Monitor zones).

The key constraints the target code must jointly respect:

• Each fire point is assigned to exactly one extinguishing drone, and fire points are spread across drones for parallel execution.
• An extinguishing drone bombs no more fire points than its current_payload; running out mid-task forces a return_to_base -> land -> resupply -> takeoff cycle.
• Every fly_to_point velocity must be <= that UAV's max_speed, and all flight altitudes are the constant 100.0.
• Hover time is risk-level dependent: High = 15 s, Low = 10 s.
• Per zone: bomb its fire point(s), then exactly one SearchArea per drone for that zone, then move on. Every zone must be searched at least once; Monitor zones are search-only.
• SearchArea always takes a single-UAV list (['UAV_02']), never a multi-UAV list, and the same drone must not repeat SearchArea on the same zone_id.

Data splits

Split	Examples	File
train	9,932	firefighting_train.json

Dataset Structure

Fields

Field	Type	Description
instruction	string	Full prompt: format rules, core rules, command API, UAV resources, zone JSON, and the closing Now output the mission code: cue. 8,748–10,425 characters.
input	string	Always the empty string. Present so the records stay compatible with the standard Alpaca instruction/input/output template.
output	string	The reference mission chain: per-UAV Python blocks with # Sortie N markers and # ==== UAV_xx mission chain ==== headers. 375–2,328 characters.

Example record

{
  "instruction": "You are a Python code generator. Output ONLY the mission code, nothing else.\n\nFORMAT RULES (violations will be rejected):\n- First output character MUST be #\n...\nUAV RESOURCES:\nUAV_02 = {\"id\": \"UAV_02\", \"type\": \"extinguishing_drone\", \"location\": [0.0, 0.0], \"battery\": 100.0, \"capabilities\": {\"max_fire_extinguisher\": 1, \"current_payload\": 1, \"max_speed\": 15.0, \"sensor_range\": 0.2}, \"description\": \"1\"}\nUAV_01 = {\"id\": \"UAV_01\", \"type\": \"surveillance_drone\", ... }\n\nZONES (JSON):\n[{\"id\": \"zone_1\", \"risk_level\": \"High\", \"coordinates\": [[0.0, 0.0], ...], \"fire_points\": [[0.288, 0.142]]}, ...]\n\nNow output the mission code:",
  "input": "",
  "output": "# =========================\n# UAV_02 mission chain\n# =========================\n# Sortie 1\ntakeoff('UAV_02', 100.0)\nfly_to_point('UAV_02', 0.042, 0.961, 100.0, 15.0)\nhover_and_wait('UAV_02', 15.0)\ndrop_water_bomb('UAV_02')\nreturn_to_base('UAV_02')\nland('UAV_02')\nresupply('UAV_02')\n# Sortie 2\ntakeoff('UAV_02', 100.0)\nfly_to_point('UAV_02', 0.905, 0.968, 100.0, 15.0)\nhover_and_wait('UAV_02', 15.0)\ndrop_water_bomb('UAV_02')\nSearchArea(['UAV_02'], 'zone_0')\nreturn_to_base('UAV_02')\nland('UAV_02')\n"
}

Usage

from datasets import load_dataset

ds = load_dataset("DONKEY13479/ForestFireFIghting_plan", split="train")
print(ds)
# Dataset({
#     features: ['instruction', 'input', 'output'],
#     num_rows: 9932
# })

print(ds[0]["output"])

Training with the standard Alpaca prompt template:

def format_example(ex, with_input=True):
    if with_input and ex["input"].strip():
        return f"{ex['instruction']}\n\n### Input:\n{ex['input']}"
    return ex["instruction"]

prompt = format_example(ds[0])
completion = ds[0]["output"]

The file can also be read directly without the datasets library, since it is a plain JSON array of objects:

import json

with open("firefighting_train.json", encoding="utf-8") as f:
    rows = json.load(f)

Generation and Provenance

• The prompts are generated from randomized fire-scene configurations: a fleet definition (drone count, per-drone type, payload capacity, and max speed) and a zone layout (zone count, risk levels, polygons, and fire-point placements).
• The reference mission chains are produced by the planning/generation pipeline for this project and are checked against the core rules before being included.
• Scene coordinates are normalized to the unit square [0, 1]; altitudes are in metres AGL and speeds in m/s.

Citation

@misc{forestfirefighting_uav_mission_planning,
  title  = {Forest Fire Fighting UAV Mission Planning},
  author = {DONKEY13479},
  year   = {2026},
  url    = {https://huggingface.co/datasets/DONKEY13479/ForestFireFIghting_plan}
}

Considerations for Using This Dataset

• Constraint satisfaction, not plausibility. Reference outputs are valid under the prompt's rule set. If you evaluate generated code, parse the mission chains and check the hard rules directly — surface-form similarity to the reference is a weak proxy, since many distinct assignments satisfy the constraints.
• Single dominant prompt template. All 9,932 rows share the same format rules, API reference, and rule text; only the UAV RESOURCES and ZONES (JSON) blocks vary. A model trained here will learn this specific prompt layout, not general instruction following.
• Near-duplicate prompts. 9,932 rows reduce to 9,000 unique (instruction, output) pairs. Deduplicate if your evaluation must be leakage-free.
• Empty input field. Drop the column if your template does not use it.
• No real-world or imagery data. Everything is abstract normalized geometry and simulated fleet state — there is no sensor, satellite, or geographic content.

License

Released under the Apache License 2.0. See LICENSE for the full text.