Add synthetic dataset generator matching user's schema

generate_synthetic_dataset.py

@@ -0,0 +1,432 @@
+"""
+Synthetic floorplan dataset generator for Indian residential construction.
+Produces (parametric_input, floorplan_output) pairs matching the user's ProjectCreate schema.
+"""
+import json, random, math
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional, Tuple
+from datasets import Dataset, DatasetDict
+
+ROOM_SIZES = {
+    "bedroom":       {"min_w": 2.7, "max_w": 4.2, "min_d": 3.0, "max_d": 4.8, "area_range": (10, 20)},
+    "master_bedroom":{"min_w": 3.3, "max_w": 4.5, "min_d": 3.6, "max_d": 5.4, "area_range": (14, 25)},
+    "toilet":        {"min_w": 1.2, "max_w": 1.8, "min_d": 1.8, "max_d": 2.7, "area_range": (2.5, 5)},
+    "kitchen":       {"min_w": 2.4, "max_w": 3.6, "min_d": 2.7, "max_d": 4.2, "area_range": (7, 15)},
+    "living":        {"min_w": 3.3, "max_w": 5.4, "min_d": 3.6, "max_d": 6.0, "area_range": (14, 30)},
+    "dining":        {"min_w": 2.7, "max_w": 3.6, "min_d": 3.0, "max_d": 4.5, "area_range": (9, 16)},
+    "pooja":         {"min_w": 1.2, "max_w": 1.8, "min_d": 1.5, "max_d": 2.1, "area_range": (1.8, 4)},
+    "study":         {"min_w": 2.1, "max_w": 3.0, "min_d": 2.4, "max_d": 3.6, "area_range": (5, 11)},
+    "balcony":       {"min_w": 1.2, "max_w": 2.4, "min_d": 2.4, "max_d": 4.5, "area_range": (3, 10)},
+    "parking":       {"min_w": 2.5, "max_w": 3.3, "min_d": 5.0, "max_d": 6.0, "area_range": (12, 20)},
+    "staircase":     {"min_w": 2.7, "max_w": 3.3, "min_d": 3.0, "max_d": 4.5, "area_range": (8, 15)},
+    "corridor":      {"min_w": 1.0, "max_w": 1.5, "min_d": 2.4, "max_d": 6.0, "area_range": (2.5, 9)},
+    "utility":       {"min_w": 1.5, "max_w": 2.4, "min_d": 1.8, "max_d": 3.0, "area_range": (3, 7)},
+    "store":         {"min_w": 1.2, "max_w": 2.1, "min_d": 1.5, "max_d": 2.4, "area_range": (2, 5)},
+}
+
+PLOT_SHAPES = ["rectangular", "l_shaped", "trapezoid"]
+DIRECTIONS = ["N", "S", "E", "W"]
+CITIES = ["Delhi", "Mumbai", "Bangalore", "Chennai", "Hyderabad", "Pune", "Kolkata", "Ahmedabad", "Jaipur", "other"]
+MUNICIPALITIES = ["MC", "MDA", "PMA", "BDA", "GHMC", "BBMP", "MCD", "KMC", "JDA", None]
+
+def rect_polygon(x, y, w, d):
+    return [[round(v, 2) for v in p] for p in [[x, y], [x+w, y], [x+w, y+d], [x, y+d]]]
+
+def polygon_area(poly):
+    n = len(poly)
+    area = 0.0
+    for i in range(n):
+        x1, y1 = poly[i]
+        x2, y2 = poly[(i+1)%n]
+        area += x1*y2 - x2*y1
+    return abs(area)/2.0
+
+def polygon_bbox(poly):
+    xs = [p[0] for p in poly]; ys = [p[1] for p in poly]
+    return min(xs), min(ys), max(xs), max(ys)
+
+def make_plot_boundary(params):
+    shape = params.get("plot_shape", "rectangular")
+    L, W = params["plot_length"], params["plot_width"]
+    if shape == "rectangular":
+        return rect_polygon(0, 0, L, W)
+    if shape == "l_shaped":
+        cw = params.get("cutout_width", L*0.3)
+        ch = params.get("cutout_height", W*0.3)
+        corner = params.get("cutout_corner", "NE")
+        if corner == "NE":
+            return [[0,0],[L,0],[L,W-ch],[L-cw,W-ch],[L-cw,W],[0,W]]
+        elif corner == "NW":
+            return [[0,0],[L,0],[L,W],[cw,W],[cw,W-ch],[0,W-ch]]
+        elif corner == "SE":
+            return [[0,0],[L-cw,0],[L-cw,ch],[L,ch],[L,W],[0,W]]
+        elif corner == "SW":
+            return [[cw,0],[L,0],[L,W],[0,W],[0,ch],[cw,ch]]
+        return rect_polygon(0,0,L,W)
+    if shape == "trapezoid":
+        fw = params.get("plot_front_width", L)
+        rw = params.get("plot_rear_width", L*0.8)
+        off = params.get("plot_side_offset", 0.0)
+        return [[0,0],[fw,0],[fw-off,W],[-off,W]]
+    return rect_polygon(0,0,L,W)
+
+def make_buildable_boundary(plot_poly, params):
+    sf = params.get("setback_front", 1.5)
+    sr = params.get("setback_rear", 1.0)
+    sl = params.get("setback_left", 1.0)
+    srt = params.get("setback_right", 1.0)
+    minx, miny, maxx, maxy = polygon_bbox(plot_poly)
+    if len(plot_poly) == 4 and abs((maxx-minx)*(maxy-miny) - polygon_area(plot_poly)) < 0.1:
+        return rect_polygon(minx+sl, miny+sf, maxx-minx-sl-srt, maxy-miny-sf-sr)
+    return rect_polygon(minx+sl, miny+sf, maxx-minx-sl-srt, maxy-miny-sf-sr)
+
+def distribute_width(total, n):
+    base = total/n
+    bays = []
+    remaining = total
+    for i in range(n):
+        if i == n-1:
+            bays.append(round(remaining, 2))
+        else:
+            bay = max(2.4, round(base, 1))
+            bay = min(bay, remaining - 2.4*(n-i-1))
+            bays.append(bay)
+            remaining -= bay
+    return bays
+
+def distribute_depth(total, n):
+    base = total/n
+    rows = []
+    remaining = total
+    for i in range(n):
+        if i == n-1:
+            rows.append(round(remaining, 2))
+        else:
+            d = max(2.4, round(base, 1))
+            d = min(d, remaining - 2.4*(n-i-1))
+            rows.append(d)
+            remaining -= d
+    return rows
+
+def generate_room_specs(params):
+    specs = []
+    num_bed = params["num_bedrooms"]
+    num_toi = params["toilets"]
+    has_pooja = params.get("has_pooja", False)
+    has_study = params.get("has_study", False)
+    has_balc = params.get("has_balcony", False)
+    parking = params.get("parking", False)
+    num_floors = params.get("num_floors", 1)
+    has_stilt = params.get("has_stilt", False)
+    has_basement = params.get("has_basement", False)
+    custom = params.get("custom_room_config", None) or []
+
+    def add(rtype, rid, name, zone, floor="gf", target_area=None):
+        specs.append({"id": rid, "type": rtype, "name": name, "zone": zone, "floor": floor, "target_area": target_area})
+
+    add("living", "living_1", "Living Room", "front", "gf", 18)
+    add("kitchen", "kitchen_1", "Kitchen", "mid", "gf", 9)
+    add("dining", "dining_1", "Dining Area", "front", "gf", 12)
+    add("toilet", "toilet_common", "Common Toilet", "back", "gf", 3.5)
+
+    for i in range(num_bed):
+        floor = "gf" if i < num_bed - (num_floors-1) else ("ff" if num_floors > 1 else "gf")
+        if i == 0:
+            add("master_bedroom", f"bedroom_{i+1}", "Master Bedroom", "back", floor, 16)
+        else:
+            add("bedroom", f"bedroom_{i+1}", f"Bedroom {i+1}", "back", floor, 12)
+
+    for i in range(num_toi):
+        floor = "gf" if i < num_toi - (num_floors-1) else ("ff" if num_floors > 1 else "gf")
+        add("toilet", f"toilet_{i+1}", f"Toilet {i+1}", "back", floor, 3.5)
+
+    if has_pooja: add("pooja", "pooja_1", "Pooja Room", "back", "gf", 2.5)
+    if has_study:
+        floor = "ff" if num_floors > 1 else "gf"
+        add("study", "study_1", "Study Room", "back", floor, 8)
+    if has_balc: add("balcony", "balcony_1", "Balcony", "side", "gf", 5)
+    add("staircase", "stairs_1", "Staircase", "mid", "gf", 10)
+
+    if has_stilt or parking:
+        add("parking", "parking_1", "Parking", "side", "stilt", 15)
+        add("staircase", "stairs_stilt", "Staircase (Stilt)", "mid", "stilt", 10)
+
+    if has_basement:
+        add("store", "store_base", "Storage", "back", "basement", 8)
+        add("staircase", "stairs_base", "Staircase (Basement)", "mid", "basement", 10)
+
+    if num_floors >= 2:
+        ff_beds = max(0, num_bed - 1)
+        for i in range(ff_beds):
+            add("bedroom", f"bedroom_ff_{i+1}", f"Bedroom {num_bed - ff_beds + i + 1}", "back", "ff", 12)
+        add("living", "living_ff", "Family Lounge", "front", "ff", 14)
+        add("toilet", "toilet_ff", "Common Toilet (FF)", "back", "ff", 3.5)
+        if has_study and num_floors >= 2: add("study", "study_ff", "Study Room", "back", "ff", 8)
+        if has_balc: add("balcony", "balcony_ff", "Balcony (FF)", "side", "ff", 5)
+
+    if num_floors >= 3:
+        sf_beds = max(0, num_bed - 2)
+        for i in range(sf_beds):
+            add("bedroom", f"bedroom_sf_{i+1}", f"Bedroom {num_bed - sf_beds - ff_beds + i + 1}", "back", "sf", 12)
+        add("living", "living_sf", "Terrace Lounge", "front", "sf", 12)
+        add("toilet", "toilet_sf", "Common Toilet (SF)", "back", "sf", 3.5)
+        if has_balc: add("balcony", "balcony_sf", "Balcony (SF)", "side", "sf", 5)
+
+    for i, cr in enumerate(custom):
+        rtype = cr.get("type", "room").lower().replace(" ", "_")
+        floor_pref = cr.get("floor_preference", "either")
+        floor_map = {"basement":"basement","stilt":"stilt","gf":"gf","ff":"ff","sf":"sf","either":"gf"}
+        floor = floor_map.get(floor_pref, "gf")
+        min_a = cr.get("min_area_sqm", 10)
+        add(rtype, f"custom_{i+1}", cr.get("name", f"Custom Room {i+1}"), "mid", floor, min_a)
+
+    return specs
+
+def place_rooms(buildable_poly, rooms_spec, vastu, road_side, north_dir):
+    minx, miny, maxx, maxy = polygon_bbox(buildable_poly)
+    bw, bd = maxx-minx, maxy-miny
+    placed = []
+    num_bays = max(2, min(4, int(bw/3.0)))
+    bay_widths = distribute_width(bw, num_bays)
+
+    def place_row(room_list, row_depth, y_start):
+        x_cursor = minx
+        placed_in_row = []
+        for i, room in enumerate(room_list):
+            if i >= len(bay_widths): break
+            w = bay_widths[i]
+            d = row_depth
+            target = room.get("target_area", w*d)
+            if target > 0 and w > 0:
+                adj_d = min(max(target/w, 2.4), row_depth)
+                d = round(adj_d, 2)
+            poly = rect_polygon(round(x_cursor,2), round(y_start,2), round(w,2), round(d,2))
+            area = polygon_area(poly)
+            placed_in_row.append({
+                "id": room["id"], "type": room["type"], "name": room["name"], "floor": room.get("floor","gf"),
+                "polygon": poly, "area_sqm": round(area,2),
+                "dimensions": {"width": round(w,2), "depth": round(d,2)},
+                "position": {"x": round(x_cursor+w/2,2), "y": round(y_start+d/2,2)},
+            })
+            x_cursor += w
+        return placed_in_row
+
+    all_rows = []
+    front_types = [r for r in rooms_spec if r["type"] in ("living","dining")]
+    if front_types: all_rows.append((front_types, bd*0.35))
+    mid_types = [r for r in rooms_spec if r["type"] in ("kitchen","utility","staircase","corridor","store")]
+    if mid_types: all_rows.append((mid_types, bd*0.3))
+    back_types = [r for r in rooms_spec if r["type"] in ("bedroom","master_bedroom","toilet","pooja","study")]
+    if back_types: all_rows.append((back_types, bd*0.35))
+
+    y_cursor = miny
+    for room_list, row_depth in all_rows:
+        placed.extend(place_row(room_list, row_depth, y_cursor))
+        y_cursor += row_depth
+
+    side_types = [r for r in rooms_spec if r["type"] in ("balcony","parking")]
+    for room in side_types:
+        if room["type"] == "balcony" and placed:
+            ref = placed[0] if road_side in ("N","W") else placed[-1]
+            rp = ref["polygon"]
+            minx_r, miny_r, maxx_r, maxy_r = polygon_bbox(rp)
+            bal_w = min(2.0, bw*0.15)
+            if road_side in ("N","S"):
+                if road_side == "N": poly = rect_polygon(minx_r, maxy_r, maxx_r-minx_r, bal_w)
+                else: poly = rect_polygon(minx_r, miny_r-bal_w, maxx_r-minx_r, bal_w)
+            else:
+                if road_side == "E": poly = rect_polygon(maxx_r, miny_r, bal_w, maxy_r-miny_r)
+                else: poly = rect_polygon(minx_r-bal_w, miny_r, bal_w, maxy_r-miny_r)
+            placed.append({
+                "id": room["id"], "type": "balcony", "name": room.get("name","Balcony"), "floor": room.get("floor","gf"),
+                "polygon": [[round(v,2) for v in p] for p in poly], "area_sqm": round(polygon_area(poly),2),
+                "dimensions": {"width": round(bal_w,2), "depth": round(maxx_r-minx_r,2)},
+                "position": {"x": round((minx_r+maxx_r)/2,2), "y": round((miny_r+maxy_r)/2,2)},
+            })
+        elif room["type"] == "parking":
+            poly = rect_polygon(minx, miny, min(bw, 3.0*2.5), min(bd*0.25, 6.0))
+            placed.append({
+                "id": room["id"], "type": "parking", "name": room.get("name","Parking"), "floor": room.get("floor","stilt"),
+                "polygon": [[round(v,2) for v in p] for p in poly], "area_sqm": round(polygon_area(poly),2),
+                "dimensions": {"width": round(min(bw,7.5),2), "depth": round(min(bd*0.25,6.0),2)},
+                "position": {"x": round(minx+min(bw,7.5)/2,2), "y": round(miny+min(bd*0.25,6.0)/2,2)},
+            })
+    return placed
+
+def generate_openings(rooms, road_side):
+    doors, windows = [], []
+    entrance = [r for r in rooms if r["type"] == "living" and r["floor"] == "gf"]
+    if entrance:
+        lr = entrance[0]; poly = lr["polygon"]
+        mx, my, Mx, My = polygon_bbox(poly)
+        if road_side in ("N","S"):
+            x = round((mx+Mx)/2 - 0.45, 2)
+            y = My if road_side == "N" else my
+            doors.append({"id":"door_main","type":"main_entrance","width":0.9,"from":"outside","to":lr["id"],"position":[x,y],"orientation":"horizontal"})
+        else:
+            x = Mx if road_side == "E" else mx
+            y = round((my+My)/2 - 0.45, 2)
+            doors.append({"id":"door_main","type":"main_entrance","width":0.9,"from":"outside","to":lr["id"],"position":[x,y],"orientation":"vertical"})
+
+    for i, r1 in enumerate(rooms):
+        for r2 in rooms[i+1:]:
+            if r1["floor"] != r2["floor"]: continue
+            m1x, m1y, M1x, M1y = polygon_bbox(r1["polygon"])
+            m2x, m2y, M2x, M2y = polygon_bbox(r2["polygon"])
+            share_x = not (M1x < m2x or M2x < m1x)
+            share_y = not (M1y < m2y or M2y < m1y)
+            if share_x and abs(M1y-m2y) < 0.3:
+                x = round(max(m1x,m2x)+0.3,2); y = round(M1y,2)
+                doors.append({"id":f"door_{r1['id']}_{r2['id']}","type":"internal","width":0.75,"from":r1["id"],"to":r2["id"],"position":[x,y],"orientation":"horizontal"})
+            elif share_y and abs(M1x-m2x) < 0.3:
+                x = round(M1x,2); y = round(max(m1y,m2y)+0.3,2)
+                doors.append({"id":f"door_{r1['id']}_{r2['id']}","type":"internal","width":0.75,"from":r1["id"],"to":r2["id"],"position":[x,y],"orientation":"vertical"})
+
+    for r in rooms:
+        if r["type"] in ("living","bedroom","master_bedroom","dining","kitchen","study"):
+            poly = r["polygon"]; mx, my, Mx, My = polygon_bbox(poly)
+            if (Mx-mx) >= (My-my):
+                y = round((my+My)/2,2); cx = (mx+Mx)/2
+                x = mx if abs(mx-cx) > abs(Mx-cx) else Mx
+                windows.append({"id":f"win_{r['id']}","room":r["id"],"width":1.2,"height":1.5,"position":[round(x,2),y],"orientation":"vertical"})
+            else:
+                x = round((mx+Mx)/2,2); cy = (my+My)/2
+                y = my if abs(my-cy) > abs(My-cy) else My
+                windows.append({"id":f"win_{r['id']}","room":r["id"],"width":1.5,"height":1.2,"position":[x,round(y,2)],"orientation":"horizontal"})
+    return doors, windows
+
+def generate_example(seed=None):
+    if seed is not None: random.seed(seed)
+    plot_length = round(random.uniform(8.0, 25.0), 1)
+    plot_width = round(random.uniform(7.0, 20.0), 1)
+    setback_front = round(random.uniform(1.0, 3.0), 1)
+    setback_rear = round(random.uniform(0.5, 2.0), 1)
+    setback_left = round(random.uniform(0.5, 2.0), 1)
+    setback_right = round(random.uniform(0.5, 2.0), 1)
+    road_side = random.choice(DIRECTIONS)
+    north_direction = random.choice(DIRECTIONS)
+    num_bedrooms = random.randint(1, 4)
+    toilets = random.randint(1, num_bedrooms+1)
+    parking = random.choice([True, False])
+    city = random.choice(CITIES)
+    vastu_enabled = random.choice([True, False])
+    road_width_m = round(random.uniform(6.0, 18.0), 1)
+    has_pooja = random.choice([True, False])
+    has_study = random.choice([True, False])
+    has_balcony = random.choice([True, False])
+    plot_shape = random.choice(["rectangular"]*8 + ["l_shaped"]*1 + ["trapezoid"]*1)
+    plot_front_width = plot_length if plot_shape != "trapezoid" else round(plot_length*random.uniform(0.8,1.0),1)
+    plot_rear_width = plot_length if plot_shape != "trapezoid" else round(plot_length*random.uniform(0.7,1.0),1)
+    plot_side_offset = 0.0 if plot_shape != "trapezoid" else round(random.uniform(-1.0,1.0),1)
+    cutout_corner = random.choice(["NE","NW","SE","SW"])
+    cutout_width = round(plot_length*random.uniform(0.15,0.35),1) if plot_shape=="l_shaped" else 0.0
+    cutout_height = round(plot_width*random.uniform(0.15,0.35),1) if plot_shape=="l_shaped" else 0.0
+    num_floors = random.choices([1,2,3], weights=[5,3,1])[0]
+    has_stilt = random.choice([True, False]) if num_floors > 1 else False
+    has_basement = random.choice([True, False])
+    municipality = random.choice(MUNICIPALITIES)
+
+    min_buildable = 5.0
+    if plot_length - setback_front - setback_rear < min_buildable:
+        setback_front = min(setback_front, (plot_length-min_buildable)/2)
+        setback_rear = min(setback_rear, (plot_length-min_buildable)/2)
+    if plot_width - setback_left - setback_right < min_buildable:
+        setback_left = min(setback_left, (plot_width-min_buildable)/2)
+        setback_right = min(setback_right, (plot_width-min_buildable)/2)
+
+    params = {
+        "name": f"Project_{random.randint(1000,9999)}",
+        "plot_length": plot_length, "plot_width": plot_width,
+        "setback_front": round(setback_front,1), "setback_rear": round(setback_rear,1),
+        "setback_left": round(setback_left,1), "setback_right": round(setback_right,1),
+        "road_side": road_side, "north_direction": north_direction,
+        "num_bedrooms": num_bedrooms, "toilets": toilets, "parking": parking,
+        "city": city, "vastu_enabled": vastu_enabled, "road_width_m": road_width_m,
+        "has_pooja": has_pooja, "has_study": has_study, "has_balcony": has_balcony,
+        "plot_shape": plot_shape,
+        "plot_front_width": plot_front_width if plot_shape=="trapezoid" else None,
+        "plot_rear_width": plot_rear_width if plot_shape=="trapezoid" else None,
+        "plot_side_offset": plot_side_offset if plot_shape=="trapezoid" else None,
+        "plot_corners": None,
+        "cutout_corner": cutout_corner, "cutout_width": cutout_width, "cutout_height": cutout_height,
+        "num_floors": num_floors, "has_stilt": has_stilt, "has_basement": has_basement,
+        "municipality": municipality, "custom_room_config": None, "team_id": None,
+    }
+
+    plot_boundary = make_plot_boundary(params)
+    buildable_boundary = make_buildable_boundary(plot_boundary, params)
+    room_specs = generate_room_specs(params)
+    rooms = place_rooms(buildable_boundary, room_specs, vastu_enabled, road_side, north_direction)
+    doors, windows = generate_openings(rooms, road_side)
+
+    total_area = sum(r["area_sqm"] for r in rooms if r["floor"] not in ("stilt","basement"))
+    built_up_area = sum(r["area_sqm"] for r in rooms)
+
+    floorplan = {
+        "project_name": params["name"],
+        "plot": {
+            "shape": plot_shape,
+            "outer_boundary": plot_boundary,
+            "setbacks": {"front": params["setback_front"], "rear": params["setback_rear"],
+                         "left": params["setback_left"], "right": params["setback_right"]},
+            "buildable_boundary": buildable_boundary,
+            "road_side": road_side, "north_direction": north_direction,
+            "plot_length": plot_length, "plot_width": plot_width,
+        },
+        "rooms": rooms,
+        "doors": doors,
+        "windows": windows,
+        "dimensions": {
+            "total_built_up_area_sqm": round(built_up_area,2),
+            "total_carpet_area_sqm": round(total_area,2),
+            "ground_floor_area_sqm": round(sum(r["area_sqm"] for r in rooms if r["floor"]=="gf"),2),
+            "first_floor_area_sqm": round(sum(r["area_sqm"] for r in rooms if r["floor"]=="ff"),2),
+            "second_floor_area_sqm": round(sum(r["area_sqm"] for r in rooms if r["floor"]=="sf"),2),
+            "stilt_area_sqm": round(sum(r["area_sqm"] for r in rooms if r["floor"]=="stilt"),2),
+            "basement_area_sqm": round(sum(r["area_sqm"] for r in rooms if r["floor"]=="basement"),2),
+        },
+        "meta": {"num_floors": num_floors, "has_stilt": has_stilt, "has_basement": has_basement,
+                 "vastu_enabled": vastu_enabled, "city": city, "municipality": municipality},
+    }
+
+    lines = [
+        f"Generate a floor plan for project '{params['name']}'.",
+        f"Plot dimensions: {plot_length}m x {plot_width}m, shape: {plot_shape}.",
+        f"Setbacks: front={params['setback_front']}m, rear={params['setback_rear']}m, left={params['setback_left']}m, right={params['setback_right']}m.",
+        f"Road side: {road_side}, North direction: {north_direction}.",
+        f"Requirements: {num_bedrooms} bedrooms, {toilets} toilets.",
+    ]
+    if parking: lines.append("Parking is required.")
+    if has_pooja: lines.append("Include a Pooja room.")
+    if has_study: lines.append("Include a Study room.")
+    if has_balcony: lines.append("Include a Balcony.")
+    if has_stilt: lines.append("Stilt parking required.")
+    if has_basement: lines.append("Include a basement.")
+    lines.append(f"Number of floors: {num_floors} (1=G, 2=G+1, 3=G+2).")
+    if vastu_enabled: lines.append("Vastu compliance is enabled.")
+    lines.append(f"City: {city}, Municipality: {municipality or 'N/A'}.")
+    prompt = "\n".join(lines)
+
+    return {"prompt": prompt, "completion": json.dumps(floorplan, indent=2), "params": params}
+
+def create_dataset(num_train=5000, num_val=500, num_test=500):
+    print(f"Generating {num_train} train, {num_val} val, {num_test} test examples...")
+    train = [generate_example(seed=i) for i in range(num_train)]
+    val = [generate_example(seed=100000+i) for i in range(num_val)]
+    test = [generate_example(seed=200000+i) for i in range(num_test)]
+    ds = DatasetDict({
+        "train": Dataset.from_list(train),
+        "validation": Dataset.from_list(val),
+        "test": Dataset.from_list(test),
+    })
+    return ds
+
+if __name__ == "__main__":
+    ds = create_dataset(5000, 500, 500)
+    ds.save_to_disk("/app/floorplan_synthetic_dataset")
+    print("Saved to /app/floorplan_synthetic_dataset")
+    print(f"Train: {len(ds['train'])}, Val: {len(ds['validation'])}, Test: {len(ds['test'])}")
+    print("\n--- Sample prompt ---")
+    print(ds["train"][0]["prompt"][:500])
+    print("\n--- Sample completion (truncated) ---")
+    print(ds["train"][0]["completion"][:500])