Source-linked AI summary
House-GAN: Relational Generative Adversarial Networks for Graph-constrained House Layout Generation
Nelson Nauata, Kai-Hung Chang, Chin-Yi Cheng, Greg Mori, Yasutaka Furukawa
TL;DR
House-GAN targets house layout generation from graph-structured architectural constraints, addressing an expensive and time-consuming design process. It embeds those constraints in relational generator and discriminator networks, then generates axis-aligned room boxes. Across evaluations on 117,000 real floorplan images, it produces more diverse, realistic, and compatible layouts than competing methods.
Problem
House design is an expensive, time-consuming iterative process, motivating automated generation of layouts that satisfy room-type and spatial-adjacency constraints.
Method
House-GAN uses relational generator and discriminator networks with graph constraints encoded in their structure, generating axis-aligned room rectangles from bubble diagrams.
Results
House-GAN produces more diverse, realistic, and bubble-diagram-compatible layouts than competing methods in evaluations over 117,000 real floorplan images.
Takeaways & Limitations
The paper presents graph-constrained relational GANs as an effective approach for computer-aided house layout generation.
Takeaways & Limitations
The setting assumes no room-size node properties, rectangular room shapes, and adjacency edges without door information.
Abstract
from arXiv · showhide
This paper proposes a novel graph-constrained generative adversarial network, whose generator and discriminator are built upon relational architecture. The main idea is to encode the constraint into the graph structure of its relational networks. We have demonstrated the proposed architecture for a new house layout generation problem, whose task is to take an architectural constraint as a graph (i.e., the number and types of rooms with their spatial adjacency) and produce a set of axis-aligned bounding boxes of rooms. We measure the quality of generated house layouts with the three metrics: the realism, the diversity, and the compatibility with the input graph constraint. Our qualitative and quantitative evaluations over 117,000 real floorplan images demonstrate that the proposed approach outperforms existing methods and baselines. We will publicly share all our code and data.
1 Introduction
House-GAN addresses the costly, iterative challenge of generating house layouts from graph-structured architectural constraints. Its relational GAN produces diverse, realistic, constraint-compatible layouts and outperforms competing methods on evaluations over 117,000 real floorplan images.
- Motivation: House design is expensive and time-consuming, often forcing compromises when budgets and time are limited.The standard workflow iterates between bubble diagrams, floorplans, client feedback, and refinement.
- Problem: The proposed task maps a bubble diagram graph of room types and adjacencies to axis-aligned bounding boxes representing house layouts.The system generates a diverse set of layouts compatible with the input graph.
- Method: House-GAN encodes graph constraints into relational generator and discriminator architectures using convolutional message passing networks.Feature volumes and convolutions operate in the design space, supporting higher-order layout composition and adjacency validation.
- Results: Evaluations over 117,000 real floorplan images show more diverse, realistic, and bubble-diagram-compatible layouts than competing methods.The paper evaluates realism, diversity, and compatibility with the input constraint.
2 Related work
Prior work generates layouts through handcrafted optimization, sequential data-driven models, or graph-based planning and image synthesis. House-GAN differs by embedding the input constraint directly into relational generator and discriminator graph structures.
- Procedural layout generation: Traditional procedural methods compose architectural or game layouts with handcrafted energy minimization under accessibility, aesthetics, or connectivity constraints.Examples use deformable room templates or polygonal building blocks.
- Data-driven space planning: Data-driven methods generate indoor plans sequentially, including residential floorplans built from a building footprint through room addition and post-processing.Related approaches also address indoor and outdoor scene generation.
- Graph-constrained layout generation: Graph-constrained approaches plan scenes from relation graphs, retrieve bubble diagrams, or synthesize image layouts using graph convolutional networks.These methods include iterative 3D model insertion, Bayesian retrieval, and scene-graph image synthesis.
- Graph-constrained layout generation: House-GAN introduces a relational generative adversarial network that encodes the input constraint in both relational generator and discriminator structures.The reported qualitative and quantitative evaluations demonstrate effectiveness over competing methods.
3 Graph-constrained house layout generation problem
The problem uses real floorplans converted into graph-structured bubble diagrams and evaluates generated layouts for realism, diversity, and graph compatibility. The setting includes restrictive assumptions about room properties, shapes, and adjacency semantics.
- Dataset: The dataset contains 117,587 LIFULL HOME floorplans uniformly rescaled to 256 × 256 resolution and converted into vector graphics and bubble diagrams.Room nodes carry room types, and edges connect rooms whose bounding-box Manhattan distance is less than 8 pixels.
- Dataset and evaluation: Samples are divided into five room-count groups: 1-3, 4-6, 7-9, 10-12, and 13+ rooms.The groups support evaluation across varying layout sizes.
- Metrics: Five-fold validation excludes same-group samples during training to test generalization rather than memorization.At test time, methods generate 10 samples for realism and diversity, but one for computationally expensive compatibility evaluation.
- Metrics: Compatibility is measured by graph editing distance between the input bubble diagram and the graph reconstructed from the generated layout.Realism uses average user ratings, while diversity uses generated variations and FID scoring.
- Assumptions: The setting assumes room nodes lack size properties, rooms are rectangular, and adjacency edges do not encode doors.The authors identify these extensions as future work.
4 House-GAN
House-GAN encodes a bubble-diagram graph directly into relational generator and discriminator architectures to generate graph-compatible room layouts. Its pipeline initializes room features, propagates messages through room-wise feature volumes, produces segmentation masks, and classifies generated versus real layouts.
- Architecture: House-GAN uses relational generator and discriminator networks whose graph structure encodes the input bubble-diagram constraint.Its Conv-MPN representation stores room features as volumes in design space rather than 1D latent vectors.
- Input graph: The generator takes a noise vector and room-type information for each graph node, producing one axis-aligned rectangle per room.Each node is initialized from a 128-d noise vector concatenated with a 10-d one-hot room-type vector.
- Feature propagation: Conv-MPN updates room-wise feature volumes by message passing over connected and non-connected rooms, followed by convolution and two rounds of upsampling.Features are expanded into spatial volumes and upsampled by factors of 2 using transposed convolutions.
- Output layout: A shared CNN converts each final feature volume into a 32×32×1 room mask, which is thresholded and rectangle-fitted at test time.The tightest axis-aligned rectangle around each thresholded mask forms the generated house layout.
- Discrimination: The discriminator processes room segmentation masks in reverse through room-type conditioning, convolutional downsampling, and pooling to output a real-versus-generated scalar.It receives either generated masks or real floorplan masks and aggregates room vectors before classification.
- Training objective: Training uses WGAN-GP with gradient penalty 10, interpolating pixel-wise between real and generated room masks while fixing the relational graph.The gradient penalty preserves the graph structure during interpolation.
5 Implementation Details
The implementation trains House-GAN in PyTorch with WGAN-GP and ADAM on a dual-CPU, dual-GPU workstation for 200k iterations. The generator and discriminator use learning rate 0.0001 with batch size 32.
- Optimization: The PyTorch implementation trains the model for 200k iterations using WGAN-GP and ADAM.The optimizer parameters are b1 = 0.5 and b2 = 0.999.
- Training configuration: Both generator and discriminator use learning rate 0.0001 with batch size 32.The model uses one critic and leaky-ReLUs with α=0.1 except for the generator’s final nonlinearity.
- Hardware: Training runs on a workstation with dual Xeon CPUs and dual NVIDIA Titan RTX GPUs.
6 Experimental Results
House-GAN is evaluated against baselines and competing methods on realism, diversity, and compatibility. It performs strongly across these metrics, while remaining subject to failures involving room geometry, alignment, accessibility, and non-rectangular rooms.
- Overall evaluation: House-GAN outperforms competing methods and baselines on all metrics except compatibility against GCN, where the margin is small.The evaluation uses realism, diversity, and compatibility measures across 117,587 floorplan samples grouped by room count, excluding each test group during training.
- Realism: House-GAN receives the best overall realism user score, with students and architects rating it the most realistic method aside from ground truth.The user study included 12 graduate students and 10 professional architects, who compared 75 layout pairs.
- Diversity: House-GAN achieves the best diversity scores except in the smallest room-count group, where diversity and graph-constraint effects are limited.For each group, methods generate 10 variations for 5,000 sampled bubble diagrams, evaluated using FID scores.
- Compatibility: House-GAN is the only method that maintains output variation while achieving high compatibility, and compatibility increases as graph information is added.The compatibility experiment progressively adds room count, room type, and room connectivity information, while another experiment adds room nodes sequentially with fixed noise.
- Failure analysis: Architects rate selected success examples as equally good as ground truth, but failures involve improper room sizes or shapes, misalignment, and inaccessible rooms.The paper identifies blocked room entries and disconnected or implausible room arrangements among the failure examples.
- Failure analysis: Raw segmentation outputs are often rectangular because the dataset represents rooms as axis-aligned rectangles, although original floorplans can contain non-rectangular rooms.Generating non-rectangular rooms is identified as future work.
7 Conclusion
The paper presents a graph-constrained relational generative adversarial network for house layout generation and evaluates it with realism, diversity, and compatibility metrics. It positions the system as a step toward computer-aided house-layout design and reports plans to share code and data.
- House-GAN combines a house layout generation problem with a graph-constrained relational generative adversarial network.
- The evaluation uses three metrics: realism, diversity, and compatibility, and compares the proposed system with competing methods and baselines.
- The authors describe the work as an important step toward computer-aided design of house layouts.
- The authors state that they will share their code and data and acknowledge architects and students who participated in the user study.