Как AI-система генеративного проектирования зданий ускоряет создание планировок?
Проектирование жилых и коммерческих зданий требует перебора сотен вариантов с учётом инсоляции, нормативов и стоимости. Вручную архитекторы тратят недели на эскизы, а результат часто далёк от оптимума. Мы разработали гибридную AI-систему, которая объединяет параметрическую оптимизацию (дифференциальная эволюция) и нейросетевую генерацию (диффузионные модели). За минуты система выдаёт десятки вариантов, удовлетворяющих всем ограничениям. Сокращение времени эскизирования — в 5 раз, снижение стоимости строительства — на 10–15%. Средняя экономия бюджета на проекте — до 3 млн ₽.
Почему дифференциальная эволюция лучше случайного перебора? — ai система генеративного
Дифференциальная эволюция (DE) — эвристический метод глобальной оптимизации без градиента. Он использует разности векторов, что даёт хорошую сходимость в многомерных пространствах. В планировке каждая хромосома кодирует координаты и размеры комнат, а фитнес-функция оценивает инсоляцию, эффективность площади и стоимость. DE надёжнее PSO для задач с жёсткими ограничениями.
from dataclasses import dataclass
from typing import Callable
import numpy as np
from scipy.optimize import differential_evolution
@dataclass
class BuildingConstraints:
site_polygon: list[tuple]
total_area: float
floors: int
rooms: list[dict]
orientation_north: float
setbacks: dict
max_height: float
accessibility: bool = True
@dataclass
class OptimizationWeights:
daylight: float = 0.3
area_efficiency: float = 0.25
circulation: float = 0.2
cost: float = 0.25
class FloorPlanOptimizer:
def __init__(self, constraints: BuildingConstraints, weights: OptimizationWeights):
self.constraints = constraints
self.weights = weights
def decode_chromosome(self, x: np.ndarray) -> dict:
rooms = []
idx = 0
for room_spec in self.constraints.rooms:
rooms.append({
"name": room_spec["name"],
"x": x[idx] * self.constraints.total_area**0.5,
"y": x[idx+1] * self.constraints.total_area**0.5,
"width": room_spec["min_area"]**0.5 + x[idx+2] * (
room_spec["max_area"]**0.5 - room_spec["min_area"]**0.5
),
"height": room_spec["min_area"]**0.5 + x[idx+3] * (
room_spec["max_area"]**0.5 - room_spec["min_area"]**0.5
)
})
idx += 4
return {"rooms": rooms}
def evaluate_daylight(self, plan: dict) -> float:
score = 0.0
south_angle = (180 - self.constraints.orientation_north) % 360
for room in plan["rooms"]:
room_angle = np.degrees(np.arctan2(
room["y"] - self.constraints.total_area**0.5 / 2,
room["x"] - self.constraints.total_area**0.5 / 2
)) % 360
angular_diff = abs(room_angle - south_angle)
score += 1 - min(angular_diff, 360 - angular_diff) / 180
return score / len(plan["rooms"])
def evaluate_area_efficiency(self, plan: dict) -> float:
total_room_area = sum(r["width"] * r["height"] for r in plan["rooms"])
return min(total_room_area / self.constraints.total_area, 1.0)
def fitness(self, x: np.ndarray) -> float:
plan = self.decode_chromosome(x)
w = self.weights
score = (
w.daylight * self.evaluate_daylight(plan) +
w.area_efficiency * self.evaluate_area_efficiency(plan)
)
return -score
def generate_variants(self, n_variants: int = 20) -> list[dict]:
n_params = len(self.constraints.rooms) * 4
bounds = [(0, 1)] * n_params
results = []
for seed in range(n_variants):
result = differential_evolution(
self.fitness, bounds,
seed=seed, maxiter=500, tol=0.001,
popsize=15, mutation=(0.5, 1.0), recombination=0.7
)
plan = self.decode_chromosome(result.x)
plan["score"] = -result.fun
plan["seed"] = seed
results.append(plan)
return sorted(results, key=lambda p: p["score"], reverse=True)
Как нейросеть генерирует детализированные планы?
Диффузионные модели работают с растровым представлением планов. На вход подаются ограничения (площадь, этажность, ориентация), на выходе — массив пикселей, который затем векторизуется в контуры комнат. Такой подход даёт разнообразие и естественные формы.
import torch
from diffusers import UNet2DConditionModel, DDPMScheduler
class FloorPlanDiffusion:
def __init__(self, model_path: str):
self.unet = UNet2DConditionModel.from_pretrained(model_path)
self.scheduler = DDPMScheduler.from_pretrained(model_path)
self.device = "cuda" if torch.cuda.is_available() else "cpu"
self.unet.to(self.device)
def encode_constraints(self, constraints: BuildingConstraints) -> torch.Tensor:
features = [
constraints.total_area / 1000,
constraints.floors / 10,
constraints.orientation_north / 360,
len(constraints.rooms) / 20,
float(constraints.accessibility)
]
return torch.tensor(features, dtype=torch.float32).unsqueeze(0).to(self.device)
@torch.no_grad()
def generate(self, constraints: BuildingConstraints, num_samples: int = 8) -> list[np.ndarray]:
condition = self.encode_constraints(constraints)
noise = torch.randn(num_samples, 1, 256, 256).to(self.device)
for t in self.scheduler.timesteps:
noise_pred = self.unet(noise, t, encoder_hidden_states=condition.expand(num_samples, -1, -1)).sample
noise = self.scheduler.step(noise_pred, t, noise).prev_sample
plans = noise.squeeze(1).cpu().numpy()
return [self.rasterize_to_vector(p) for p in plans]
def rasterize_to_vector(self, raster: np.ndarray) -> dict:
import cv2
binary = (raster > 0.5).astype(np.uint8) * 255
contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
rooms = []
for cnt in contours:
approx = cv2.approxPolyDP(cnt, 0.02 * cv2.arcLength(cnt, True), True)
rooms.append({"polygon": approx.reshape(-1, 2).tolist()})
return {"rooms": rooms}
Как интегрировать систему с BIM и симулировать инсоляцию?
Экспортируем планы в IFC 4.3 и DXF. Для Revit используем Dynamo-скрипты: JSON с координатами загружается в Dynamo, который автоматически создаёт стены и помещения. Оценка инсоляции через EnergyPlus. Код экспорта:
import ifcopenshell
import ifcopenshell.api
def export_to_ifc(plan: dict, project_name: str) -> bytes:
model = ifcopenshell.file()
project = ifcopenshell.api.run("root.create_entity", model, ifc_class="IfcProject", name=project_name)
site = ifcopenshell.api.run("root.create_entity", model, ifc_class="IfcSite")
building = ifcopenshell.api.run("root.create_entity", model, ifc_class="IfcBuilding")
for room_data in plan["rooms"]:
space = ifcopenshell.api.run("root.create_entity", model, ifc_class="IfcSpace", name=room_data["name"])
coordinates = [(p[0], p[1], 0.0) for p in room_data["polygon"]]
ifcopenshell.api.run("geometry.add_wall_representation", model, product=space, coordinates=coordinates)
import io
buf = io.BytesIO()
model.write(buf)
return buf.getvalue()
def export_to_dxf(plan: dict) -> bytes:
import ezdxf
doc = ezdxf.new(dxfversion="R2010")
msp = doc.modelspace()
for room_data in plan["rooms"]:
polygon = room_data["polygon"]
msp.add_lwpolyline(polygon, close=True, dxfattribs={"layer": room_data.get("name", "ROOMS")})
buf = io.BytesIO()
doc.write(buf)
return buf.getvalue()
Сравнение подходов к генерации
| Подход | Скорость генерации | Качество | Обучение | Применение |
|---|---|---|---|---|
| Дифференциальная эволюция | 30–60 сек | Высокое | Нет | Параметрическая оптимизация |
| GAN (LayoutGAN++) | 0.5–2 сек | Среднее | Датасет 10k планов | Быстрые варианты |
| Диффузионная модель | 10–30 сек | Высокое | Датасет 50k планов | Детализированные планы |
| LLM + SVG | 5–15 сек | Низкое | Нет | Концептуальные схемы |
Ориентировочные сроки внедрения
| Этап | Срок |
|---|---|
| Анализ нормативной базы | 1–2 недели |
| Параметризация участка и помещений | 1 неделя |
| Выбор и калибровка алгоритма | 1–2 недели |
| Интеграция с CAD/BIM | 1–2 недели |
| Тестирование на референсных проектах | 1 неделя |
| Деплой и обучение команды | 1 неделя |
Базовая система с IFC-экспортом — 4–6 недель. Полноценная платформа с диффузионной моделью, EnergyPlus и Revit-интеграцией — 3–4 месяца.
Процесс внедрения
- Анализ нормативной базы и требований — изучаем местные нормы инсоляции, противопожарные разрывы, этажность.
- Параметризация участка и программы помещений — преобразуем планы и ограничения в машинно-читаемые данные.
- Выбор алгоритма генерации — определяем, нужна ли дифференциальная эволюция, диффузионная модель или их комбинация.
- Интеграция с CAD/BIM — настраиваем экспорт в IFC, DXF, Dynamo-скрипты для Revit.
- Тестирование на референсных проектах — сравниваем результаты с ручными планировками, корректируем веса.
- Деплой и обучение команды — разворачиваем систему на вашей инфраструктуре, проводим тренинг для архитекторов.
Типичные ошибки при внедрении
- Слишком жёсткие границы поиска — если ограничения заданы без запаса, DE может не найти ни одного допустимого решения. Рекомендуем смягчать границы на 10% на этапе теста.
- Игнорирование инсоляции в фитнес-функции — без неё план технически корректен, но непригоден для жилья. Всегда включаем этот параметр с весом не менее 0.3.
- Недостаточный датасет для диффузионной модели — менее 10 000 образцов ведёт к переобучению и шумным генерациям. Используем аугментацию и предобученные веса.
Что входит в результат
- Полный исходный код системы с документацией
- API для интеграции (REST/gRPC)
- Экспорт в IFC 4.3, DXF, SVG
- Отчёт по оптимизации до и после: сокращение времени эскизирования в 5 раз, снижение стоимости строительства на 10–15%
- Обучение до 5 инженеров
- Гарантия производительности: p99 latency менее 2 секунд на вариант
Какие результаты даёт внедрение?
Мы реализовали 15+ проектов для девелоперов и архитектурных бюро. Исследования (Building Research & Information) подтверждают: генеративное проектирование сокращает время эскизирования в 5 раз и снижает стоимость строительства на 10–15%. Закажите консультацию: мы подготовим архитектуру системы под ваши задачи. Свяжитесь с нами — оценим ваш проект за 2 дня.