Structured agents for physical construction

1 Introduction

Humans are a “construction species”—we build forts out of couch cushions as children, pyramids in our deserts, and space stations that orbit hundreds of kilometers above our heads. What do artificial intelligence (AI) agents need to do these sorts of things? This question frames the high-level purpose of this paper: to explore a range of tasks more complex than those typically studied in AI, and to develop approaches for learning to solve them.

Physical construction involves composing multiple elements under physical dynamics and constraints to achieve rich functional objectives. We introduce a suite of simulated physical construction tasks (Fig. 1), similar in spirit to how children play with toy blocks, which involve stacking and attaching together multiple blocks in configurations that satisfy functional objectives. For example, one task requires stacking blocks around obstacles to connect target locations to the ground. Another task requires building shelters which cover up target blocks and keep them dry in the rain. These tasks are representative of real-world construction challenges: they emphasize problem-solving and functionality rather than simply replicating a given target configuration, reflecting the way human construction involves forethought and purpose.

Real-world physical construction assumes many forms and degrees of complexity, but a few basic skills are typically involved: spatial reasoning (e.g. concepts like “empty” vs “occupied”), relational reasoning (e.g. concepts like “next to” or “on top of”), knowledge of physics (e.g., predicting physical interactions among objects), and allocation of materials and resources to different parts of the structure. Our simulated task environment (Fig. 1) is designed to exercise these skills, while still being simple enough to allow careful experimental control and tractable agent training.

While classic AI studied physical reasoning extensively (Chen, 1990; Pfalzgraf, 1997)

, construction has not been well-explored using modern learning-based approaches. We draw on a number of techniques from modern AI, combining and extending them in novel ways to make them more applicable and effective for construction. Our family of deep reinforcement learning (RL) agents can support: (1) vector, sequence, image, and graph-structured representations of scenes; (2) continuous and discrete actions, in absolute or object-centric coordinates; (3) model-free learning via deep Q-learning

(Mnih et al., 2015), or actor-critic methods (Heess et al., 2015; Munos et al., 2016); and (4) planning via Monte-Carlo Tree Search (MCTS) (Coulom, 2006).

We find that graph-structured representations and reasoning, object-centric policies, and model-based planning are crucial for solving our most difficult tasks. Our results demonstrate the value of integrating rich structure and powerful learning approaches as a key path toward complex construction behavior.

Figure 1: Construction task suite. In all tasks, dark blue objects are regular blocks, light blue blocks are “sticky”, red objects are obstacles which cannot be touched, and grey circles indicate points where blocks have stuck together. The black line indicates the floor, which separates the scene above, which is subject to physics, from the blocks below which can be picked up and placed. (a) *Silhouette* task. The agent stacks blocks to match the target blocks (depicted as light green blocks). (b) *Connecting* task. The agent stacks blocks to connect the small blue target objects to the floor. (c) *Covering* task. The agent stacks blocks to shelter the obstacles from above. (d) *Covering Hard* task. Similar to *Covering*, but crucially the agent has a limited supply of movable blocks. Videos of agent behaviors in these tasks are available at https://tinyurl.com/y7wtfen9 and in Supplemental Table G.1.

2 Related Work

Physical reasoning has been of longstanding interest in AI. Early work explored physical concepts with an emphasis on descriptions that generalize across diverse settings (Winston, 1970). Geometric logical reasoning was a major topic in symbolic logic research (Chou, 1987; Arnon, 1988), leading to geometric theorem-provers (Bouma et al., 1995), rule-based geometric constraint solvers for computer-aided design (Aldefeld, 1988; Schreck et al., 2012), and logic-based optimization for open-ended objectives in robotics (Toussaint, 2015). Classic work often focused on rules and structured representations rather than learning because the sample complexity of learning was often prohibitive for contemporary computers.

Modern advances in learning-based approaches have opened new avenues for using vector and convolutional representations for physical reasoning (Wu et al., 2015, 2016, 2017; Mottaghi et al., 2016; Fragkiadaki et al., 2016; Finn et al., 2016; Agrawal et al., 2016; Lerer et al., 2016; Li et al., 2016; Groth et al., 2018; Bhattacharyya et al., 2018; Ebert et al., 2018). A common limitation, however, is that due to their relatively unstructured representations of space and objects, these approaches tend not to scale up to complex scenes, or generalize to scenes with different numbers of objects, etc.

Several recent studies have explored learning construction, including learning to stack blocks by placing them at predicted stable points (Li et al., 2017), learning to attach blocks together to stabilize an unstable stack (Hamrick et al., 2018), learning basic block-stacking by predicting shortest paths between current and goal states via a transition model (Zhang et al., 2018), and learning object representations and coarse-grained physics models for stacking blocks (Janner et al., 2019). Though promising, in these works the physical structures the agents construct are either very simple, or provided explicitly as an input rather than being designed by the agent itself. A key open challenge, which this paper begins to address, is how to learn to design and build complex structures to satisfy rich functional objectives.

A main direction we explore is object-centric representations of the scene and agent’s actions (Diuk et al., 2008; Scholz et al., 2014)

, implemented with graph neural networks

(Scarselli et al., 2009; Bronstein et al., 2017; Gilmer et al., 2017; Battaglia et al., 2018). Within the domain of physical reasoning, graph neural networks have been used as forward models for predicting future states and images (Battaglia et al., 2016; Chang et al., 2017; Watters et al., 2017; van Steenkiste et al., 2018)

, and can allow efficient learning and rich generalization. These models have also begun to be incorporated into model-free and model-based RL, in domains such as combinatorial optimization, motor control, and game playing

(Dai et al., 2017; Kool & Welling, 2018; Wang et al., 2018; Sanchez-Gonzalez et al., 2018; Zambaldi et al., 2019).

3 Physical Construction Tasks

Our simulated task environment is a continuous, procedurally-generated 2D world implemented in Unity (Juliani et al., 2018) with the Box2D physics engine (Catto, 2013). Each episode contains unmoveable obstacles, target objects, and floor, plus movable rectangular blocks which can be picked up and placed.

On each step of an episode, the agent chooses an available block (from below the floor), and places it in the scene (above the floor) by specifying its position. In all but one task (Covering Hard—see below), there is an unlimited supply of blocks of each size, so the same block can be picked up and placed multiple times. The agent may also attach objects together by assigning the property of “stickiness” to the block it is placing. Sticky objects form unbreakable, nearly rigid bonds with objects they contact. In all but one task (Connecting) the agent pays a cost to make a block sticky. After the agent places a block, the environment runs physics forward until all blocks come to rest.

An episode terminates when: (1) a movable block makes contact with an obstacle, either because it is placed in an overlapping location, or because they collide under physical dynamics; (2) a maximum number of actions is exceeded; or (3) the task-specific termination criterion is achieved (described below). The episode always yields zero reward when a movable block makes contact with an obstacle.

Silhouette task (Fig. 1a). The agent must place blocks to overlap with target blocks in the scene, while avoiding randomly positioned obstacles. The reward function is: $+ 1$ for each placed block which overlaps at least $90 %$ with a target block of the same size; and $- 0.5$ for each block set as sticky. The task-specific termination criterion is achieved when there is at least $90 %$ overlap with all targets.

This is similar to the task in Janner et al. (2019), and challenges agents to reason about physical support of complex arrangements of objects and to select, position, and attach sequences of objects accordingly. However, by fully specifying the target configuration, Silhouette does not require the agent to design a structure to satisfy a functional objective, which is an important component of our other tasks.

Connecting task (Fig. 1b). The agent must stack blocks to connect the floor to three different target locations, avoiding randomly positioned obstacles arranged in layers. The reward function is: $+ 1$ for each target whose center is touched by at least one block, and $0$ (no penalty) for each block set to sticky. The task-specific termination criterion is achieved when all targets are connected to the floor.

By not fully specifying the target configuration, the Connecting task requires the agent to design a structure with a basic function—connecting targets to the floor—rather than simply implementing it as in the Silhouette task. A wider variety of structures could achieve success in Connecting than Silhouette, and the solution space is much larger because the task is tailored so that solutions usually require many more blocks.

Covering task (Fig. 1c). The agent must build a shelter that covers all obstacles from above, without touching them. The reward function is: $+ L$ , where $L$ is the sum of the lengths of the top surfaces of the obstacles which are sheltered by blocks placed by the agent; and $- 2$ for each block set as sticky. The task-specific termination criterion is achieved when at least $99 %$ of the summed obstacle surfaces are covered. The layers of obstacles are well-separated vertically so that the agent can build structures between them.

The Covering task requires richer reasoning about function than the previous tasks: the purpose of the final construction is to provide shelter to a separate object in the scene. The task is also demanding because the obstacles may be elevated far from the floor, and the cost of stickiness essentially prohibits its use.

Covering Hard task (Fig. 1d). Similar to Covering, the agent must build a shelter, but the task is modified to encourage longer term planning: there is a finite supply of movable blocks, the distribution of obstacles is denser, and the cost of stickiness is lower ( $- 0.5$ per sticky block). It thus incorporates key challenges of the Silhouette task (reasoning about which blocks to make sticky), the Connecting task (reasoning about precise block layouts), and the Covering task (reasoning about arch-like structures). The limited number of blocks necessitates foresight in planning (e.g. reserving long blocks to cover long obstacles). The reward function and termination criterion are the same as in Covering.

Figure 2: Summary of our construction agents’ components. Each agent is defined by an observation format, encoder, policy, learning algorithm, and output action space. Not all combinations are compatible, but we evaluated those that were, as indicated by the grey arrows. For “continuous absolute” actions, the agent picks a block from the bottom (solid green circle), and places it in the scene (empty green circle). For “continuous relative” actions, the agent picks a block from the bottom (solid green circle), and places it in the scene (empty green circle) with a relative horizontal offset from the nearest block it snaps to. “Discrete absolute” actions are similar to continuous absolute actions, except with discrete coordinates. For “discrete relative” actions, the agent picks an edge between a block at the bottom (solid green circle) and block in the scene (empty green circle), and a relative horizontal offset.

4 Agents

With our suite of construction tasks, we can now tackle the question we posed at the top of the Introduction: what would an agent need to perform complex construction behaviors? We expect agents which have explicit structured representations to perform better, due to their capacity for relational reasoning, compositionality, and combinatorial generalization. We implement seven construction agents which vary in the degree of structure in their observation types, internal representations, learning algorithms, and action specifications, as summarized in Table 1 and Fig. 2.

Agent	Observation	Encoder	Policy	Planning	Learning alg.	Action space
RNN-RS0	Object	RNN	MLP/vector	-	RS0	Continuous
CNN-RS0	Image	CNN	MLP/vector	-	RS0	Continuous
GN-RS0	Object	-	GN/graph	-	RS0	Continuous
GN-DQN	Object	-	GN/graph	-	DQN	Discrete
GN-DQN-MCTS	Object	-	GN/graph	MCTS	DQN	Discrete
CNN-GN-DQN	Seg. image	Per-object CNN	GN/graph	-	DQN	Discrete
CNN-GN-DQN-MCTS	Seg. image	Per-object CNN	GN/graph	MCTS	DQN	Discrete

Table 1: Full agent architectures. Each component is as described in Sec. 4 and also illustrated in Fig. 2. All agents can be trained with either relative or absolute actions.

4.1 Observation formats

Each construction task (Sec. 3) provides object state and/or image observations. Both types are important for construction agents to be able to handle: we ultimately want agents that can use symbolic inputs, e.g., the representations in computer-aided design programs, as well as raw sensory inputs, e.g., photographs of a construction site.

Object state: These observations contain a set of feature vectors that communicate the objects’ positions, orientations, sizes, types (e.g., obstacle, movable, sticky, etc.). Contact information between objects is also provided, as well as the order in which objects were placed in the scene (see Supplemental Sec. C).

Image: Observed images are RGB renderings of the scene, with $(x, y)$ coordinates appended as two extra channels.

Segmented images: The RGB scene image is combined with a segmentation mask for each object, thus comprising a set of segmented images (similar to Janner et al., 2019).

4.2 Encoders

Figure 3: Structure of the GN-DQN agents. The agent takes in a graph-structured representation of the scene where each object corresponds to a node in the graph, and passes this representation through a GN. The GN produces a vector of Q-values for each edge, corresponding to relative actions for picking a block (the start node of the edge) and placing it on another object (the end node of the edge) at a given offset (the edge attribute). To choose actions, the agent takes an $a r g m a x$ across all edges’ Q-values and then converts the edge and offset into $(x, y)$ positions.

We use two types of internal representations for computing policies from inputs: fixed-length vectors and directed graphs with attributes.

CNN encoder

: The convolutional neural network (CNN) embeds an input image as a vector representation.

RNN encoder

: Object state input vectors are processed sequentially with a recurrent neural network (RNN)—a gated recurrent unit (GRU)

(Cho et al., 2014)—in the order they were placed in the scene, and the final hidden state vector is used as the embedding.

Graph encoder: To convert a set of state input vectors into a graph, we create a node for each input object, and add edges either between all nodes or a subset of them that depends on their type and whether they are in contact (see Supplemental Sec. C.2).

Per-object CNN encoder: To generate a graph-based representation from images, we first split the input image into segments, and generate new images with only single objects. Each of these are passed to a CNN, and the output vectors are used as nodes in a graph, with edges added as above.

4.3 Policies

MLP policy

: Given a vector representation, we obtain a policy using a multi-layer perceptron (MLP), which outputs actions or Q-values depending on the learning algorithm.

GN policy: Given a graph-based representation from a graph encoder or a per-object CNN, we apply a stack of three graph networks (GN) (Battaglia et al., 2018) arranged in series, where the second net performs some number of recurrent steps, consistent with the “encode-process-decode” architecture described in Battaglia et al. (2018). Unless otherwise noted, we used three recurrent steps.

4.4 Actions

In typical RL and control settings that involve placing objects, the agent takes absolute actions in the frame of reference of the observation (e.g. Silver et al., 2016, 2018; Zhang et al., 2018; Ganin et al., 2018; Janner et al., 2019). We implement this approach in our “absolute action” agents, where, for example, the agent might choose to “place block D at coordinates $(5, 7)$ ”. However, learning absolute actions scales poorly as the size of the environment grows, because the agent must effectively re-learn its construction policy at every location.

To support learning compositional behaviors which are more invariant to the location in the scene (e.g. stacking one block on top of another), we develop an object-centric alternative to absolute actions which we term relative actions. With relative actions, the agent takes actions in a reference frame relative to one of the objects in the scene. This is a natural way of expressing actions, and is similar to how humans are thought to choose actions in some behavioral domains (Ballard et al., 1997; Botvinick & Plaut, 2004).

The different types of actions are shown at the bottom of Fig. 2, with details in Supplemental Sec. B.

Continuous absolute actions are 4-tuples $(X, x, y, s)$ , where $X$ is a horizontal cursor to choose a block from the available blocks at the bottom of the scene, “snapping” to the closest one, $(x, y)$ determines its placement in the scene and the sign of $s$ indicates stickiness (see Sec. 3).

Continuous relative actions are 5-tuples, $(X, x, y, Δ x, s)$ , where $X$ and $s$ are as before, $(x, y)$ is used to choose a reference block (by snapping to the closest one), and $Δ x$ determines where to place the objects horizontally relatively to the reference object, the vertical positioning being automatically adjusted.

Figure 4: Comparison of absolute and relative actions. (a) Comparison of rewards earned by agents with absolute vs relative actions, averaged across all levels of the curricula. (b) The same as in (a), but for the hardest level of each curricula. (c-d) Qualitative comparison between the best-performing absolute and relative seeds at the hardest curriculum levels in *Silhouette*, *Connecting*, and *Covering*.

Discrete absolute actions are 4-tuples $(u, i, j, s)$ where $u$ is an index over the available objects, $i, j$ indicate the discrete index at which to place the object in a grid-like 2D discretization of space, and $s$ indicates stickiness.

Absolute actions and continuous relative actions are easily implemented by any agent that outputs a single fixed-length continuous vector, such as that output by an MLP or the global output feature of a GN.

Discrete relative actions are triplets, $(e, i, s)$ , where $e := (u, v)$ is an edge in the input graph between the to-be-placed block $u$ and the selected reference block $v$ , $i$ is an index over finely discretized horizontal offsets to place the chosen block relatively to the reference block’s top surface, and $s$ is as before.

Discrete relative actions are straightforward to implement with a graph-structured internal representation: if the nodes represent objects, then the edges can represent pairwise functions over the objects, such as “place block D on top of block B” (see Fig. 3).

4.5 Learning algorithms

The internal vector and graph representations are used to produce actions either by an explicit policy or a Q-function.

RS0 learning algorithm: For continuous action outputs, we use an actor-critic learning algorithm that combines retrace with stochastic value gradients (denoted RS0) (Munos et al., 2016; Heess et al., 2015; Riedmiller et al., 2018).

DQN learning algorithm: For discrete action outputs, we use Q-learning implemented as a deep Q network (DQN) from Mnih et al. (2015), with Q-values on the edges, similar to Hamrick et al. (2018). See Sec. 4.4 and Fig. 3.

MCTS: Because the DQN agent outputs discrete actions, it is straightforward to combine it with standard planning techniques like Monte-Carlo Tree Search (Coulom, 2006; Silver et al., 2016) (see Fig. 3). We use the base DQN agent as a prior for MCTS, and use MCTS with various budgets (either only at test time, only during training, or both), thereby modifying the distribution of experience fed to the learner. As a baseline, we also perform MCTS without the model-free policy prior. In all results reported in the main text, we use the environment simulator as our model; we also explored using learned models with mixed success (see Supplemental Sec. E.3).

Figure 5: (a-d) Comparison of different training and testing budgets for the model-based GN-DQN-MCTS agents on the hardest curricula levels. The gray dashed line corresponds to a pure-planning agent with a search budget of 1000. (e-h) Representative structures built by GN-DQN-MCTS agents, chosen from a set of 10 random episodes for each task. The *Silhouette* and *Connecting* agents use training budgets of 0 and test budgets of 50; the *Covering* agent uses a training budget of 0 and test budget of 5, and the *Covering Hard* agent uses a train and test budget of 10. An example of sub-optimal behavior has been chosen for the third row when available. The entire set of random episodes are shown in Supplemental Sec. H.

5 Experiments and results

We ran experiments to evaluate the effectiveness of different agent architectures (see Table 1) on our construction tasks. We focused on quantifying the effect of structured actions (Sec. 5.1), the effect of planning both during training and at decision time (Sec. 5.2), zero-shot generalization performance on larger and more complex scenes (Sec. 5.3). In all experiments, we report results for 10 randomly initialized agents (termed “seeds”) which were trained until convergence. Each seed is evaluated on 10,000 scenes, and in all figures we report median performance across seeds as well as errorbars indicating worst and best seed performance.

For efficient training, we found it was important to apply a curriculum which progressively increases the complexity of the task across training episodes. In Silhouette, the curriculum increases the number of targets. In Connecting, it increases the elevation of the targets. In the Covering tasks, it increases the elevation of the obstacles. Details are available in Supplemental Sec. A.2. In our analysis, we evaluated each seed on scenes generated either uniformly at random across all difficulty levels, or only at the hardest difficulty level for each task.

5.1 Relative versus absolute actions

We find that agents which use relative actions consistently outperform those which use absolute actions. Across tasks, almost every relative action agent converges at a similar or higher median performance level (see Fig. 4a), and the best relative agents achieve up to 1.7 times more reward than the best absolute agents when averaging across all curriculum levels. When considering only the most advanced level, the differences are larger with factors of up to 2.4 (Fig. 4b).

Fig. 4c shows examples of the best absolute agents’ constructions (at episode termination) in the most advanced level. These outcomes are qualitatively worse than the best relative agents’ (Fig. 4d). The absolute agents do not anticipate the long term consequences of their actions as well, sometimes failing to make blocks sticky when necessary, or failing to place required objects at the base of a structure, as in Fig. 4c’s Silhouette example. They also fall into poor local minima, building stacks of blocks on the sides of the scene which fail to reach or cover objects in the center, as in Fig. 4c’s Connecting and Covering examples.

By contrast, the best relative agents (which, across all tasks, were GN-DQN) construct more economical solutions (e.g., Fig. 4d, Connecting) and discover richer strategies, such as building arches (Fig. 4d, Covering). The GN-DQN agent’s superior performance suggests that structured representations and relative, object-centric actions are powerful tools for construction. Our qualitative results suggest that these tools provide invariance to dimensions such as spatial location, which can be seen in cases where the GN-DQN agent re-uses local block arrangements at different heights and locations, such as the T structures in Fig. 4g.

Most agents achieve similar levels of performance of Covering Hard: GN-RS0 has the best median performance, while GN-DQN has the best overall seed. But inspecting the qualitative results (Fig. 4), even the best relative agent does not give very strong performance. Though Covering Hard involves placing fewer blocks than other tasks because of their limited supply, reasoning about the sequence of blocks to use, which to make sticky, etc. is indeed a challenge, which we will address in the next section with our planning agent.

Interestingly, the GN-RS0 and GN-DQN agents have markedly different performance despite both using the same structured GN policy. There are a number of subtle differences, but notably, the object-centric information contained in the graph of the GN-RS0 agent must be pooled and passed through the global attribute to produce actions, while the GN-DQN agent directly outputs actions via the graph’s edges. This may allow its policy to be more analogous to the actual structure of the problem than the GN-RS0 agent.

The CNN-RS0 agent’s performance is generally poorer than the GN-based agents’, but the observation formats are also different: the CNN agent must learn to encode images, and it does not receive distinct, parsed objects. To better control for this, we train a GN-based agent from pixels, labelled CNN-GN-DQN, described in Sec. 4. The CNN-GN-DQN agent achieves better performance than the CNN-RS0 agent (see SM Fig. C.2). This suggests that parsing images into objects is valuable, and should be investigated further in future work.

5.2 Model-based versus model-free

Generally, complex construction should require longer-term planning, rather than simply reactive decision-making. Given a limited set of blocks, for example, it may be crucial to reserve certain blocks for roles they uniquely satisfy in the future. We thus augment our GN-DQN agent with a planning mechanism based on MCTS (see Sec. 4.5) and evaluate its performance in several conditions, varying the search budget at training and testing time independently (a search budget of 0 corresponds to no planning).

Our results (Fig. 5) show that planning is generally helpful, especially in Connecting and Covering Hard. In Connecting, planning with a train budget of 10 and test budget of 100 improves the agent’s median reward from 2.17 to 2.72 on the hardest scenes, or from 72.5% to 90.6% of the optimal reward of 3. In Covering Hard, planning with a train and test budget of 10 improves the agent’s median reward from 3.60 to 4.61. Qualitatively, the planning agent appears to be close to ceiling (Fig. 5h). Note that a pure-planning agent (Fig. 5a-d, gray dashed line) with a budget of 1000 still performs poorly compared to learned policies, underscoring the difficulty of the combinatorially large search space in construction. In Supplemental Sec. E, we discuss of the trade-offs of planning during training, testing, or both.

Figure 6: Zero-shot generalization performance of various agents. In all cases, asterisks indicate values seen during training. (a) In *Silhouette*, we varied the number of targets from 8 to 16. (b) In *Connecting*, we first varied the location of the target locations to be either on the same level or on different levels. (c) In *Connecting*, we also varied the number of obstacle layers from three to four. (d-f) Examples of the GN-DQN-MCTS generalizing to new scenes. In each case, the agent has a train budget of 0 and a test budget of 50. (d) An example of the agent matching 16 targets in *Silhouette*. (e) *Connecting* agent generalizing to multi-level targets; during training, all three targets were always at the same level and above the obstacles. (f) *Connecting* agent solving scenes with 4 layers of obstacles and higher targets; during training, there were only up to 3 layers of obstacles.

5.3 Generalization

One of the most striking features of human construction is how we innovate new things. We next ask: how do our agents generalize to conditions beyond those on which they were trained? In Silhouette, our agents only experience 1-8 targets during training, so we test them on 9 and 16 targets. In Connecting, agents always experience targets at the same elevation within one scene during training, so we test them on targets appearing at multiple different levels in the same scene (in one condition) and all at a higher elevation than experienced during training.

We find that the GN-DQN and especially GN-DQN-MCTS agents with relative actions generalize substantially better than others. In Silhouette, the GN-DQN-* agents cover nearly twice as many targets as seen during training, while the other agents’ performances plateau or fall off dramatically (Fig. 6a). In Connecting with targets at multiple different levels, the GN-DQN and GN-DQN-MCTS agents’ performances drops only slightly, while other agents’ performance drops to near 0 (Fig. 6b). With increased numbers of obstacle layers in Connecting, both agents’ performances drop moderately but remain much better than the less structured agents (Fig. 6c). Fig. 6d-f show the qualitative generalization behavior of the GN-DQN-MCTS agent. Overall, these generalization results provide evidence that structured agents are more robust to scenarios which are more complex than those in their training distribution. This is likely a consequence of their ability to recognize structural similarity and re-use learned strategies.

5.4 Iterative relational reasoning

Recurrent GNs support iterative relational reasoning by propagating information across the scene graph. We vary the number of recurrent steps in our GN-DQN agent to understand how this measure of its relational reasoning capacity affects its task performance.

We find that increasing the number of propagation steps from 1 to 3 to 5 generally improves performance, to a point, across all tasks: in Silhouette, the median rewards were 3.75, 4.04 and 4.06; in Connecting, 2.49, 2.84, and 2.81; in Covering, 3.41, 3.96, and 4.01; and in Covering Hard, 2.62, 3.03, and 3.02, respectively.

6 Discussion

We introduced a suite of representative physical construction challenges, and a family of RL agents to solve them. Our results suggest that graph-structured representations, model-based planning under model-free search policies, and object-relative actions are valuable ingredients for achieving strong performance and effective generalization. We believe this work is the first to demonstrate agents that can learn rich construction behaviors in complex settings with large numbers of objects (up to 40-50 in some cases), and can satisfy challenging functional objectives that go beyond simply matching a pre-specified goal configuration.

Given the power of object-centric policies, future work should seek to integrate methods for detecting and segmenting objects from computer vision with learned relational reasoning. Regarding planning, this work only scratches the surface, and future efforts should explore learned models and more sophisticated search strategies, perhaps using policy improvement

(Silver et al., 2018) and gradient-based optimization via differentiable world models (Sanchez-Gonzalez et al., 2018). Finally, procedurally generating problem instances that require complex construction solutions is challenging, and adversarial or other learned approaches may be promising future directions.

Our work is only a first step toward agents which can construct complex, functional structures. However we expect approaches that combine rich structure and powerful learning will be key making fast, durable progress.

7 Acknowledgements

We would like to thank Yujia Li, Hanjun Dai, Matt Botvinick, Andrea Tacchetti, Tobias Pfaff, Cédric Hauteville, Thomas Kipf, Andrew Bolt, and Piotr Trochim for helpful input and feedback on this work.

References

Agrawal et al. (2016) Agrawal, P., Nair, A., Abbeel, P., Malik, J., and Levine, S. Learning to poke by poking: Experiential learning of intuitive physics. In Proceedings of the 30th Conference on Neural Information Processing Systems (NeurIPS 2016), 2016.
Aldefeld (1988) Aldefeld, B. Variation of geometries based on a geometric-reasoning method. Computer-Aided Design, 20(3):117–126, 1988.
Arnon (1988) Arnon, D. Geometric reasoning with logic and algebra. Artificial Intelligence, 37(1–3):37–60, 1988.
Azizzadenesheli et al. (2018) Azizzadenesheli, K., Yang, B., Liu, W., Lipton, E. B. Z. C., and Anandkumar, A. Surprising negative results for generative adversarial tree search. arXiv preprint arXiv:1806.05780, pp. 1–25, 2018.
Ballard et al. (1997) Ballard, D. H., Hayhoe, M. M., Pook, P. K., and Rao, R. P. Deictic codes for the embodiment of cognition. Behavioral and Brain Sciences, 20(4):723–742, 1997.
Battaglia et al. (2016) Battaglia, P., Pascanu, R., Lai, M., Rezende, D., and Kavukcuoglu, K. Interaction networks for learning about objects, relations and physics. In Proceedings of the 30th Conference on Neural Information Processing Systems (NeurIPS 2016), 2016.
Battaglia et al. (2018) Battaglia, P. W., Hamrick, J. B., Bapst, V., Sanchez-Gonzalez, A., Zambaldi, V., Malinowski, M., Tacchetti, A., Raposo, D., Santoro, A., Faulkner, R., et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261, pp. 1–38, 2018.
Bhattacharyya et al. (2018) Bhattacharyya, A., Malinowski, M., Schiele, B., and Fritz, M. Long-term image boundary prediction. In Proceedings of the 32nd AAAI Conference on Artificial Intelligence (AAAI-18), 2018.
Botvinick & Plaut (2004) Botvinick, M. and Plaut, D. C. Doing without schema hierarchies: a recurrent connectionist approach to normal and impaired routine sequential action. Psychological review, 111(2):395, 2004.
Bouma et al. (1995) Bouma, W., Fudosa, I., Hoffmann, C., Cai, J., and Paige, R. Geometric constraint solver. Computer-Aided Design, 27(6):487–501, 1995.
Bronstein et al. (2017) Bronstein, M. M., Bruna, J., LeCun, Y., Szlam, A., and Vandergheynst, P.
Geometric deep learning: going beyond euclidean data.
IEEE Signal Processing Magazine, 34(4):18–42, 2017.
Catto (2013) Catto, E. Box2D. https://box2d.org/, 2013.
Chang et al. (2017) Chang, M. B., Ullman, T., Torralba, A., and Tenenbaum, J. B. A compositional object-based approach to learning physical dynamics. In Proceedings of the 5th International Conference on Learning Representations (ICLR 2017), 2017.
Chen (1990) Chen, S.-s. Advances in Spatial Reasoning, volume 2. Intellect Books, 1990.
Cho et al. (2014) Cho, K., Van Merriënboer, B., Gulcehre, C., Bahdanau, D., Bougares, F., Schwenk, H., and Bengio, Y. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014.
Chou (1987) Chou, S.-C. Mechanical geometry theorem proving. Kluwer Academic, 1987.
Coulom (2006) Coulom, R. Efficient selectivity and backup operators in monte-carlo tree search. In International conference on computers and games, pp. 72–83. Springer, 2006.
Dai et al. (2017) Dai, H., Khalil, E., Zhang, Y., Dilkina, B., and Song, L. Learning combinatorial optimization algorithms over graphs. In Advances in Neural Information Processing Systems, pp. 6348–6358, 2017.
Diuk et al. (2008) Diuk, C., Cohen, A., and Littman, M. L. An object-oriented representation for efficient reinforcement learning. In Proceedings of the 25th international conference on Machine learning, pp. 240–247. ACM, 2008.
Ebert et al. (2018) Ebert, F., Finn, C., Dasari, S., Xie, A., Lee, A., and Levine, S. Visual foresight: Model-based deep reinforcement learning for vision-based robotic control. arXiv preprint arXiv:1812.00568, 2018.
Finn et al. (2016) Finn, C., Goodfellow, I., and Levine, S. Unsupervised learning for physical interaction through video prediction. In Proceedings of the 30th Conference on Neural Information Processing Systems (NeurIPS 2016), 2016.
Fragkiadaki et al. (2016) Fragkiadaki, K., Agrawal, P., Levine, S., and Malik, J. Learning visual predictive models of physics for playing billiards. In Proceedings of the 4th International Conference on Learning Representations (ICLR 2016), 2016.
Ganin et al. (2018) Ganin, Y., Kulkarni, T., Babuschkin, I., Eslami, S., and Vinyals, O. Synthesizing programs for images using reinforced adversarial learning. arXiv preprint arXiv:1804.01118, 2018.
Gilmer et al. (2017) Gilmer, J., Schoenholz, S. S., Riley, P. F., Vinyals, O., and Dahl, G. E. Neural message passing for quantum chemistry. arXiv preprint arXiv:1704.01212, 2017.
Groth et al. (2018) Groth, O., Fuchs, F. B., Posner, I., and Vedaldi, A. Shapestacks: Learning vision-based physical intuition for generalised object stacking. In Proceedings of the European Conference on Computer Vision (ECCV), 2018.
Guo et al. (2014) Guo, X., Singh, S., Lee, H., Lewis, R. L., and Wang, X. Deep learning for real-time atari game play using offline monte-carlo tree search planning. In Ghahramani, Z., Welling, M., Cortes, C., Lawrence, N. D., and Weinberger, K. Q. (eds.), Advances in Neural Information Processing Systems 27, pp. 3338–3346. Curran Associates, Inc., 2014.
Hamrick et al. (2017) Hamrick, J. B., Ballard, A. J., Pascanu, R., Vinyals, O., Heess, N., and Battaglia, P. W. Metacontrol for adaptive imagination-based optimization. In Proceedings of the 5th International Conference on Learning Representations (ICLR 2017), 2017.
Hamrick et al. (2018) Hamrick, J. B., Allen, K. R., Bapst, V., Zhu, T., McKee, K. R., Tenenbaum, J. B., and Battaglia, P. W. Relational inductive bias for physical construction in humans and machines. In Proceedings of the 40th Annual Conference of the Cognitive Science Society, 2018.
Heess et al. (2015) Heess, N., Wayne, G., Silver, D., Lillicrap, T., Tassa, Y., and Erez, T. Learning continuous control policies by stochastic value gradients. In Proceedings of the 29th Conference on Neural Information Processing Systems (NeurIPS 2015), 2015.
Janner et al. (2019) Janner, M., Levine, S., Freeman, W. T., Tenenbaum, J. B., Finn, C., and Wu, J. Reasoning about physical interactions with object-oriented prediction and planning. In International Conference on Learning Representations, 2019.
Juliani et al. (2018) Juliani, A., Berges, V.-P., Vckay, E., Gao, Y., Henry, H., Mattar, M., and Lange, D. Unity: A general platform for intelligent agents. arXiv preprint arXiv:1809.02627, 2018.
Kocsis & Szepesvári (2006) Kocsis, L. and Szepesvári, C. Bandit based monte-carlo planning. In Fürnkranz, J., Scheffer, T., and Spiliopoulou, M. (eds.), Machine Learning: ECML 2006, pp. 282–293, Berlin, Heidelberg, 2006. Springer Berlin Heidelberg.
Kool & Welling (2018) Kool, W. and Welling, M. Attention solves your TSP. arXiv preprint arXiv:1803.08475, 2018.
Lerer et al. (2016) Lerer, A., Gross, S., and Fergus, R. Learning physical intuition of block towers by example. In Proceedings of the 33rd International Conference on Machine Learning (ICML 2016), 2016.
Li et al. (2016) Li, W., Azimi, S., Leonardis, A., and Fritz, M. To fall or not to fall: A visual approach to physical stability prediction. arXiv preprint arXiv:1604.00066, pp. 1–20, 2016.
Li et al. (2017) Li, W., Leonardis, A., and Fritz, M. Visual stability prediction and its application to manipulation. In Proceedings of the 31st AAAI Conference on Artificial Intelligence (AAAI-17), 2017.
Mnih et al. (2015) Mnih, V., Kavukcuoglu, K., Silver, D., Rusu, A. A., Veness, J., Bellemare, M. G., Graves, A., Riedmiller, M., Fidjeland, A. K., Ostrovski, G., et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
Mottaghi et al. (2016) Mottaghi, R., Bagherinezhad, H., Rastegari, M., and Farhadi, A. Newtonian image understanding: Unfolding the dynamics of objects in static images. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR 2016)
, 2016.
Munos et al. (2016) Munos, R., Stepleton, T., Harutyunyan, A., and Bellemare, M. Safe and efficient off-policy reinforcement learning. In Advances in Neural Information Processing Systems, pp. 1054–1062, 2016.
Pascanu et al. (2017) Pascanu, R., Li, Y., Vinyals, O., Heess, N., Buesing, L., Racanière, S., Reichert, D., Weber, T., Wierstra, D., and Battaglia, P. Learning model-based planning from scratch. arXiv preprint arXiv:1707.06170, pp. 1–13, 2017.
Pfalzgraf (1997) Pfalzgraf, J. On geometric and topological reasoning in robotics. Annals of Mathematics and Artificial Intelligence, 19:279, 1997.
Riedmiller et al. (2018) Riedmiller, M., Hafner, R., Lampe, T., Neunert, M., Degrave, J., van de Wiele, T., Mnih, V., Heess, N., and Springenberg, J. T. Learning by playing solving sparse reward tasks from scratch. In Dy, J. and Krause, A. (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 4344–4353, Stockholmsmässan, Stockholm Sweden, 10–15 Jul 2018. PMLR.
Sanchez-Gonzalez et al. (2018) Sanchez-Gonzalez, A., Heess, N., Springenberg, J. T., Merel, J., Riedmiller, M., Hadsell, R., and Battaglia, P. Graph networks as learnable physics engines for inference and control. In Proceedings of the 35th International Conference on Machine Learning (ICML 2018), 2018.
Santoro et al. (2017) Santoro, A., Raposo, D., Barrett, D. G., Malinowski, M., Pascanu, R., Battaglia, P., and Lillicrap, T. A simple neural network module for relational reasoning. In Advances in neural information processing systems, pp. 4967–4976, 2017.
Scarselli et al. (2009) Scarselli, F., Gori, M., Tsoi, A., Hagenbuchner, M., and Monfardini, G. The graph neural network model. IEEE Transactions on Neural Networks, 20:61–80, 2009.
Scholz et al. (2014) Scholz, J., Levihn, M., Isbell, C., and Wingate, D. A physics-based model prior for object-oriented mdps. In International Conference on Machine Learning, pp. 1089–1097, 2014.
Schreck et al. (2012) Schreck, P., Mathis, P., and Narboux, J. Geometric construction problem solving in computer-aided learning. In Proceedings of the IEEE International Conference on Tools with Artificial Intelligence (ICTAI), volume 24, pp. 1139–1144, 2012.
Silver et al. (2016) Silver, D., Huang, A., Maddison, C. J., Guez, A., Sifre, L., van den Driessche, G., Schrittwieser, J., Antonoglou, I., Panneershelvam, V., Lanctot, M., Dieleman, S., Grewe, D., Nham, J., Kalchbrenner, N., Sutskever, I., Lillicrap, T., Leach, M., Kavukcuoglu, K., Graepel, T., and Hassabis, D. Mastering the game of Go with deep neural networks and tree search. Nature, 529:484–489, 2016.
Silver et al. (2017) Silver, D., Schrittwieser, J., Simonyan, K., Antonoglou, I., Huang, A., Guez, A., Hubert, T., Baker, L., Lai, M., Bolton, A., Chen, Y., Lillicrap, T., Hui, F., Sifre, L., van den Driessche, G., Graepel, T., and Hassabis, D. Mastering the game of Go without human knowledge. Nature, 550:354–359, 2017.
Silver et al. (2018) Silver, D., Hubert, T., Schrittwieser, J., Antonoglou, I., Lai, M., Guez, A., Lanctot, M., Sifre, L., Kumaran, D., Graepel, T., et al. A general reinforcement learning algorithm that masters chess, shogi, and go through self-play. Science, 362(6419):1140–1144, 2018.
Sutton (1991) Sutton, R. S. Dyna, an integrated architecture for learning, planning, and reacting. SIGART Bull., 2(4):160–163, July 1991. ISSN 0163-5719. doi: 10.1145/122344.122377.
Toussaint (2015) Toussaint, M. Logic-geometric programming: an optimization-based approach to combined task and motion planning. In Proceedings of the International Conference on Artificial Intelligence (IJCAI), volume 24, pp. 1930–1936, 2015.
van Steenkiste et al. (2018) van Steenkiste, S., Chang, M., Greff, K., and Schmidhuber, J.
Relational neural expectation maximization: unsupervised discovery of objects and their interactions.
In Proceedings of the 6th International Conference on Learning Representations (ICLR 2018), 2018.
Wang et al. (2018) Wang, T., Liao, R., Ba, J., and Fidler, S. Nervenet: Learning structured policy with graph neural networks. In Proceedings of the International Conference on Learning Representations (ICLR), 2018.
Watters et al. (2017) Watters, N., Tacchetti, A., Weber, T., Pascanu, R., Battaglia, P., and Zoran, D. Visual interaction networks: Learning a physics simulator from video. In Proceedings of the 31st Conference on Neural Information Processing Systems (NeurIPS 2017), 2017.
Winston (1970) Winston, P. Learning structural descriptions from examples. AI Technical Reports (1964 - 2004), 1970.
Wu et al. (2015) Wu, J., Yildirim, I., Lim, J. J., Freeman, W. T., and Tenenbaum, J. B. Galileo: Perceiving physical object properties by integrating a physics engine with deep learning. In Proceedings of the 29th Conference on Neural Information Processing Systems (NeurIPS 2015), 2015.
Wu et al. (2016) Wu, J., Lim, J. J., Zhang, H., Tenenbaum, J. B., and Freeman, W. T. Physics 101: Learning physical object properties from unlabeled videos. In Proceedings of the British Machine Vision Conference (BMVC), 2016.
Wu et al. (2017) Wu, J., Lu, E., Kohli, P., Freeman, W. T., and Tenenbaum, J. B. Learning to see physics via visual de-animation. In Proceedings of the 31st Conference on Neural Information Processing Systems (NeurIPS 2017), 2017.
Zambaldi et al. (2019) Zambaldi, V., Raposo, D., Santoro, A., Bapst, V., Li, Y., Babuschkin, I., Tuyls, K., Reichert, D., Lillicrap, T., Lockhart, E., Shanahan, M., Langston, V., Pascanu, R., Botvinick, M., Vinyals, O., and Battaglia, P. Deep reinforcement learning with relational inductive biases. In International Conference on Learning Representations, 2019.
Zhang et al. (2018) Zhang, A., Lerer, A., Sukhbaatar, S., Fergus, R., and Szlam, A. Composable planning with attributes. In Proceedings of the 35th International Conference on Machine Learning (ICML 2018), 2018.

Appendix A Tasks details

a.1 Observation formats

For each task, the agent could use either an image-based observation, an object-based observation, or a combination of both as a segmentation-masks-based observation.

Object state observations are a list of vectors (one for each block), where each vector of size 15 contains information about the corresponding block position ( $x, y$ ), orientation ( $cos (θ), sin (θ)$ ), size (width, height), linear ( $v_{x}, v_{y}$ ) and angular ( $v_{θ}$ ) velocities, whether it is sticky or not, and one-hot information about its type (available block, placed block, target or obstacle). The list is ordered by the order under which objects appeared in the scene, but this information is discarded for the graph based agents. Information about which objects are in contact is also provided and is used when constructing the input for the graph based networks (see Sec. C).

Image observations start as $128 \times 128$ RGB renders of the scenes and are re-scaled down to $64 \times 64$ by averaging $2 \times 2$ patches, with the color channels normalized to $[0, 1]$ . The $x$ and $y$ coordinate is also supplied for each point in the image and is normalized in the $[- 1, 1]$ interval. The re-scaling procedure helps preserve spatial information at a sub-pixel level as color fading at the boundaries between the objects and the background.

Segmented images observations are a list of images, one for each block. They are obtained using a segmentation of the $128 \times 128$ render that maps each pixel to zero or more blocks that may be present at that pixel. Using this segmentation, we build a $128 \times 128$ binary mask for each block, re-scale it down to $64 \times 64$ by averaging $2 \times 2$ patches, and multiply it with the unsegmented RGB render to obtain per-block renders. We also add the mask as an additional alpha channel to the masked the RGB image, as well as coordinate channels.

a.2 Full scene generation and reward specifications

The full rendered scene spans a region a size of 16 $\times$ 16 (meters, unless otherwise indicated).

At the beginning of the episode, the agent has access to 7 available blocks: three small, three medium and one large block (corresponding to respective widths of 0.7, 2.1 and 3.5, all with height 0.7).

The physics simulation is run for 20 seconds after the agent places each block to make sure that the scene is at an equilibrium position before the score is evaluated, and before the agent can place the next block.

Silhouette: Each scene is comprised of 1 to 8 targets and 0 to 6 obstacles, arranged in up to 6 layers, with a curriculum over the maximum number of targets, maximum number of obstacles, and number of layers (see Fig. H.1

). Levels are generated by (1) tessellating the scene into layers of blocks of the same sizes as the available blocks, with a small separation of 0.35, (2) sequentially (up to the required number of targets) finding the set of target candidates and sampling targets from this set (blocks in the tessellation that are directly on top of the floor or an existing target block) (3) sampling obstacles using a similar procedure. Both obstacles and targets that are further from the floor are sampled with higher probability to favor the generation of harder-to-construct towers and inverted pyramids. The average number of targets is 4.5 on the training distribution, and the number of targets goes up to 8 for the hardest levels. These numbers set an upper bound on the total reward that can be obtained. However, the average reward for an optimal agent is lower than that due to the cost of glue (silhouettes generated using this procedure are not guaranteed to be stable, thus the best possible solution may require glue).

Connecting: There are at most three vertical layers of obstacles above the floor and a layer of three targets above the highest obstacles. Each layer consists of up to three obstacles, whose lengths are uniformly and independently sampled from the interval $[0.7, 2.8]$ . The layers of obstacles separated by enough distance for one block can be placed between any two layers of obstacles. The curriculum is comprised of scenes fewer obstacle layers, while the number of targets is unchanged (see Fig. H.4 for examples). Since glue is unpenalized, the maximum reward available to the agent is exactly 3.

Covering: There are at most three vertical layers of obstacles above the floor at any location, and up to 2 obstacles in each layer, with lengths uniformly and independently sampled from the interval $[0.7, 2.8]$ . As in Connecting, these layers are well separated so that one block can be placed between any two layers of obstacles. The curriculum is comprised of scenes with obstacles only in the first two lower layers (see Fig. H.2). The total available length to cover is 5.25 on the training distribution and 7.88 for the hardest levels. This provides a tight upper-bound on the maximal reward and the agent could be expected to achieve this.

Covering Hard: There are at most two vertical layers of obstacles above the floor at any location, and up to 2 obstacles in each layer, with lengths uniformly and independently sampled in $[0.7, 3.5]$ . The curriculum is comprised of scenes with only one layer of obstacles (see Fig. H.3 for examples). The layers of obstacles are closer to each other than in they were in Connecting or Covering Hard. The maximum length that can be covered is 4.2 on the training distribution and 6.3 on the hardest levels, but this only gives a weak upper bound on the possible reward because of the cost of glue and limited supply of blocks.

Curriculum complexity: Curricula were designed to increase in complexity while preserving instances of scenes from previous points in training to avoid catastrophic forgetting. This allows us to make a distinction, for any task and curriculum level, between Hardest Scenes (scenes types that are introduced for the first time at the present level) and All Scenes (training distribution, including hardest scenes at the current level and lower level scenes). Additional details about the conditions for advancing through the curricula are given in Sec. D for the DQN agents and Sec. F for the RS0 agents.

Appendix B Implementation details of the action specification.

Continuous absolute actions are 4-tuples $(X, x, y, s)$ . $X$ is compared to the $x$ -coordinates of each of the available blocks and the closest block $c$ is chosen. A new block identical to it is then spawned with its center at location $(x, y)$ . The resulting object is sticky if and only if the continuous action $s \in [- 1, 1]$ is positive.

Discrete absolute actions are 4-tuples $(u, i, j, s)$ . $u \in {1, 2, \dots, 7}$ is an index within the set of available blocks to decide which block will be placed on the scene. $i$ , $j$ are discrete index to place this block on the scene. Specifically the scene was discretized in height $\times$ width using different sizes from $8 \times 64$ to $256 \times 256$ , finding the best results for $256 \times 256$ in Silhouette and $8 \times 64$ for the other tasks. $s$ is a discrete variable in ${- 1, 1}$ indicating whether the placed object should be made sticky or not.

Continuous relative actions are 5-tuples, $(X, x, y, Δ x, s)$ . Here $X, s$ have identical meaning to the absolute case, and $c$ is again the object selected by $X$ . The object $r$ whose center is closest to $(x, y)$ is then selected as reference. Then, the $x$ -coordinate of the placed block $x_{p}$ is determined by $Δ x \in [- 1, 1]$ , such that $x_{p} = x_{r} + Δ x (\frac{w_{r} + w_{c}}{2} + ϵ_{x})$ , where $x_{r}$ is the $x$ -coordinate of the center of $r$ , $w_{r}$ and $w_{c}$ are the widths of the objects $r$ and $c$ , and $ϵ_{x}$ is a small offset so that the objects are not touching laterally.

If $r$ is a target object centered at $(x_{r}, y_{r})$ , the $y$ -coordinate of the center of $c$ will be placed at $y_{p} = y_{r} + ϵ_{y}$ so that $c$ is vertically overlapping with $r$ (where $ϵ_{y}$ is a small offset so that the objects are not perfectly flush). If $r$ is a solid object, $c$ is placed just above $r$ , i.e. $y_{p} = y_{r} + \frac{h_{r} + h_{c}}{2} + ϵ_{y}$ , where $h_{c}$ and $h_{r}$ are the heights of the objects $c$ and $r$ , respectively. If the agent chooses an invalid edge (where $c$ is not an available block, or where $r$ is not a block in the scene), then the episode is terminated with a reward of zero. We use $ϵ_{x} = ϵ_{y} = 0.04$ throughout.

Discrete relative actions are triplets, $(e, i, s)$ , where $e := (c, r)$ is an edge in the structured observation graph between the chosen new block and the selected reference block, $i$ is an index over fine discretization of discrete horizontal offsets to place the chosen block relatively to the reference block, and $s$ is as before. If the blocks $c$ are not an available block or that the block $r$ is not a block already in the scene, then the episode is terminated with a reward of 0.

For the $x$ offsets, we use a uniform grid with $n$ bins in the range $[- \frac{w_{r} + w_{c}}{2} (1 + \frac{1}{n - 3}), \frac{w_{r} + w_{c}}{2} (1 + \frac{1}{n - 3})]$ , where $w_{r}$ and $w_{c}$ are as before (this is such that there are exactly $n$ segments in the range $[- \frac{w_{r} + w_{c}}{2}, \frac{w_{r} + w_{c}}{2}]$ ). We then pick the $i$ -th value in this grid as the relative $x$ position. The $y$ coordinate of the placed block is computed as before, but we also experimented with predicting the relative offset $Δ y$ , and varying the number of discrete offsets $n$ (see Sec. D for details).

Appendix C Architecture details

Figure C.1: Overall comparison of all agents tested, including MLP and relation network (Santoro et al., 2017) baselines, averaging across curriculum levels. Bars show median performance across seeds, and errorbars are min and max seeds.

c.1 MLP-based architectures

MLP

: The pre-processor of the MLP model consists of concatenating the list of blocks as given by the environment (blocks, available blocks, obstacles, targets) padded with zero blocks (up to the total maximum number of objects in each task with a 1 hot indicator of padding), and normalizing it with a LayerNorm layer into a fixed set 100 features. This fixed size vector is then processed by the core MLP consisting of four hidden layers of

256

units with ReLU non-linearity, and an output layer to match the required output size. We found this MLP model to have equal or worse performance to the RNN agent, and thus did not report results on it in the main text; however, Fig.

C.1 includes results for the MLP agent across the tasks.

RNN: The RNN model pre-processor uses a GRU (hidden size of 256) to sequentially process the objects in the the scene (including padding objects up to a maximum size as described in the MLP). The output of the GRU after processing the last object is then used as input for the core MLP (identical in size to the on described in the MLP model). In some generalization settings, where the total number of objects increased drastically, we found better generalization performance by clipping/ignoring some of the objects in the input, than by allowing the network to process a longer sequence of objects than used at training time.

CNN: The CNN model pre-processor passes the 64 $\times$

64 input image through a 4-layer convolution network (output channels=[16, 32, 32, 32]) followed by a ReLU activation, a linear layer on the flattened outputs into embedding size of 256, and another ReLU activation. Each layer is comprised of a 2d convolution layer (size=3, stride=1, padding=“same”) and a max pooling layer (size=3, stride=2, padding=“same”). The vector embedding of the image is then processed by and MLP core (identical in size to the on described in the MLP model, except that it uses 3 layers instead of 4).

CNN-RN: We found this CNN-RN model to have equal or worse performance to the vanilla CNN agent, and thus did not report results on it in the main text; however, Fig. C.1

includes results for the CNN-RN agent across the tasks. We use a higher-resolution convolutional feature map, using residual connections to increase depth and ease training. Each residual block with N channels consists of a N-channel (size=3, stride=1, padding=“same”) convolution and a max pool (size=3, stride=2, padding=“same”). This is followed by a N-channel convolution (size=3, stride=1, padding=“same”), a ReLU, and another N-channel convolution (size=3, stride=2, padding=“same”), the output of which is added to the max pool output to get the block output. We apply 3 such blocks with N=[16,32,8]. This gives us a vector of length 8 at every spatial location, to which we apply the standard Relation Net architecture

(Santoro et al., 2017): we contatenate each pairs of these vectors, and feed the length-16 vector into a 2-layer MLP with ReLU activations (64 and 128 units), before applying an average pool operation over all pair representations. This 128-length vector is a linear layer to produce the final embedding of size 256.

c.2 GN-based architectures

Graph pre-processing: We use the list of objects or segmentation masks to construct the graphs that are input to the RS0-GN and DQN-GN agents, only discarding the information about the order of appearance of the object in the scene.

For the RS0 agent, we then construct a sparse graph from this set of nodes by connecting (1) available objects to all other objects in the scene; (2) targets and obstacles to all blocks in the scenes; and (3) blocks that are in contact. The DQN agent takes a fully-connected graph as input but we also experimented with feeding it the sparse representation (see Sec. D.3 for details).

GN architecture: We use the encode-process-decode architecture described by Battaglia et al. (2018). comprised of an independent graph encoder, a recurrent graph core with separate MLPs as node, edge, and global functions followed by three GRUs, respectively, and finally as a decoder either a graph network (for the RS0 agent) or graph independent (for the DQN agent). In symbols, given a graph observation $o$ , we process it as

$e$	$= E (o)$	$o_{0}$	$= e o_{0}^{'} = e$
$o_{n}$	$= G ([o, o_{n - 1}, o_{n - 1}^{'}])$	$o_{n}^{'}$	$= R (o_{n - 1})$
$d$	$= D (o_{n}^{'})$		$(1 \leq n \leq n_{rec})$

where $E$ and $D$ are independent graph network (see Battaglia et al. (2018)), $G$ is a full graph network, and $R$ is a recurrent independent graph network. We use two hidden layers of $64$ units with ReLU non-linearity within all our graph networks.

For this discrete agent, the Q values are finally decoded from $d$ as

q = M ([x, d_{globals}]_{x \in d_{edges}}),

similarly to the approach of Dai et al. (2017).

For the RS0 agent we find that having more than 1 recurrent steps in the recurrent graph core did not improve performance so we use a single recurrent step, and disabled the GRU (no longer needed without recurrent steps).

Figure C.2: Comparison of object- and pixel-based agents, averaged across curriculum levels. Bars indicate median performance across seeds, and errorbars are min and max seeds. The CNN-GN-DQN agent augmented with a vision module is able to perform almost as well as its object-based counterparts, and clearly above the CNN-RS0 agent. The same holds for the CNN-GN-DQN agent trained with MCTS, which sometimes even outperforms the object based, model free DQN.

Segmented images pre-processing: In the case of the Segmented images observations, each of the nodes in the graph contains an image, which we process independently using a pre-processor similar to that of the CNN model, but smaller (three layers with [8, 16, 8] output channels, followed by two activated linear layers with sizes [64, 32]). This produces a graph with 32 embedded features for each node.

c.3 Comparison of pixel based methods with objects based methods

We compare pixel based approaches with object based approaches on Fig. C.2, emphasizing that the graphical networks that take segmented images as input fare closer to their object based graphical counterparts than to raw CNNs, making their usage an exciting avenue for future work.

We also implemented use a CNN followed by a relation network (Santoro et al., 2017), but it fared worse than the vanilla CNN in all experiments so we excluded it from the main text (see Sec.C.1 of the Supplemental).

Appendix D Further study on the GN-DQN agent

d.1 General implementation

We implement a DQN agent with a structured graph input and graph output (roughly similar to Dai et al. (2017)), but where the Q-function is defined on the edges of the graph. This agent takes a fully-connected graph as input. The actions are decoded from the edges (resp. the global features) of the network’s output in the case of the discrete relative (resp. absolute) agent. The learner pulls experience from a replay containing graphs, with a fixed replay ratio of 4. The curriculum over scene difficulty is performed on a fixed, short schedule of $4 \times 10^{4}$ learner steps. The main difference with respect to a vanilla DQN is the way we perform $ϵ$ -exploration, which we explain in more detail below.

We use a distributed setup with up to 128 actors (for the largest MCTS budgets) and 1 learner. Our setup is synchronized to keep the replay ratio constant, i.e. the learner only replays each transition a maximum number of times, and conversely actors may wait for the learner to be done processing transitions. This results in an algorithm which has similar learning dynamics to a non-distributed one.

d.2 $ϵ$ -exploration schedule

The majority of actions of the discrete agent are invalid, either because they (1) do not correspond to an edge starting from an available block and reaching to an already placed object; (2) because the resulting configuration would have overlapping objects; or (3) because the resulting scene would be unstable. This has the consequence that doing standard $ϵ$ -exploration strongly reduces the length of an episode (longer episodes are exponentially suppressed), effectively performing more exploration at the beginning of an episode than at its end. To counteract this effect, we use an adaptive $ϵ$ -schedule, where the probability of taking a random action at the $n$ -th step of an episode is given by $p_{n} = \frac{ϵ}{min (ˆ L - n, 1)}$ , where $ˆ L$

is an empirical estimate of an episodes typical length, and we use

ϵ = 0.3

throughout the paper. The final performance is mostly unchanged, but we observe that this makes learning faster and helps with model training (see Sec. E.3).

d.3 Effect of the number of propagation steps and graph connectivity in the graph network

Figure D.1: Top panel: Influence of the $n_{rec}$ parameter on the discrete agent’s performance. Bottom panel: Influence of using a sparse graph or the fully-connected graph. Results are qualitatively similar when considering the agents trained with MCTS. In all plots, solid lines are median performance across seeds and shaded regions extend between min and max seeds.

The results reported elsewhere in this text for the discrete agent were all obtained with $n_{rec} = 3$ (see Sec. C.2) and a fully-connected input graph, but we experimented with varying $n_{rec}$ and changing the graph connectivity. In Fig. D.1 we show that performance improves with the number of recurrences, but that training is also more unstable, as demonstrated by the wider shaded area around the curve. Empirically, $n_{rec} = 3$ provides the better compromise between performance and stability.

Those results were all obtained with a fully-connected graph, with a number of edges therefore equal to the number of objects squared. Many of those edges do not however correspond to valid actions or to directly actionable connections, and we experimented with removing those edges from the graph, using the same sparse graph used by the RS0 agent and described in Sec. C (note that this graph typically has about 4 times fewer edges than the fully-connected one). What we observe is that this reduces the reasoning capacities of the discrete agent and therefore decreases performance. Augmenting the number of recurrences can partially correct this effect: the best seed with a sparse graph and $n_{rec} = 7$ can get to the same level of performance as a seed of the fully-connected graph with $n_{rec} = 3$ ), but this then happens at the detriment of training stability.

d.4 Relative actions on both the x and y axes

Figure D.2: Influence of predicting both the $x$ and $y$ relative coordinates or not. Observe that best performance reaches comparable values in both cases. In all plots, solid lines are median performance across seeds and shaded regions extend between min and max seeds.

Our discrete relative agents must choose a block to place, an object to use as a reference, and an offset relative to that reference. Thus far, that offset is only in the $x$ -direction, since a small $y$ -offset above the reference block is almost always sufficient. However, what happens if we allow the agent to choose $y$ offset as well? We observe that this multiplies the size of the action space by the number of discretization points (in our case, $15$ ), therefore making learning harder. On the other hand, for seeds that manage to start learning, the final performance is equivalent that of the agent which only predicts the relative $x$ position (see Fig. D.2), despite a number of actions much larger than that of a typical discrete agent, as shown in Table D.1.

d.5 Number of discretization steps

Figure D.3: Influence of the number of discretization steps for the relative horizontal positioning of the discrete agent. In all plots, solid lines are median performance across seeds and shaded regions extend between min and max seeds.

The architecture of the GN-DQN agent naturally represents discrete quantities (i.e., choosing blocks out of a fix set), but using a discrete $x$ -offset loses precision over outputting a continuous value. In order to probe the effect of this approximation, we varied the number of discrete locations that the agent is allowed to choose as the second dimension of the action (Fig. D.3). We observe that a finer discretization of the space allows for slightly better final performance on some problems, but also implies a slower and more unstable learning. Empirically, the 15 steps of discretization used in this paper offers the best compromise. An interesting avenue for further research would be to create an agent that can produce continuous actions attached to a particular edge or vertex of the input graph.

	Silhouette	Reaching	Covering	Covering Hard
absolute	$9 10^{5}$	$7 10^{3}$	$7 10^{3}$	$7 10^{3}$
relative	$2 10^{4}$	$2 10^{4}$	$2 10^{4}$	$3 10^{3}$
relative ( $x, y$ )	$2 10^{5}$	$3 10^{5}$	$3 10^{5}$	$5 10^{4}$

Table D.1: Typical number of actions for the variations of the tasks, for the discrete agents. The first line reports the number of actions for the best performing discrete absolute agent, the second line for the main discrete relative agent, and the third line for the agents predicting both

x

and

y

relative positions.

Other parameters: In all the paper, and unless otherwise specified, we fix the learning rate of the discrete agent to $10^{- 4}$ (resp. $2 10^{- 4}$ ) for the model-free (resp. model based) agent and use the Adam optimizer. We use a batch size of 16 and a replay ratio of 4. We perform a linear curriculum over the problem difficulty over a short amount of steps ( $4 \times 10^{4}$ learner steps). We run all model free agents for $10^{7}$ learner steps, i.e. approximately $2.5 \times 10^{6}$ actor steps. Model based agent are run for up to $4 \times 10^{6}$ learner steps ( $10^{6}$ actor steps). Every experiment is run with 10 different seeds.

Appendix E Further study on the GN-DQN-MCTS agent

e.1 Details of MCTS

The efficiency of Monte-Carlo Tree Search (MCTS) (Coulom, 2006) planning in RL has recently been highlighted in (Guo et al., 2014; Silver et al., 2016, 2017, 2018). Here we combine our DQN agent with MCTS, in the spirit of Sutton (1991) and Azizzadenesheli et al. (2018). We define a state $s$ in the tree by the sequence of actions that led to it. In other words, given an episode starting with a configuration $s_{0}$ and a sequence of actions $(a_{0}, . ., a_{t})$ , we simply define $s_{t} := (a_{0}, . ., a_{t})$ (we do not try to regroup states that would correspond to the same observation if coming from different actions sequences). Each node in the tree has a value estimated as

V (s) := \frac{1}{N (s)} ⎛ ⎝ max a Q (s, a) + \sum r \in rollouts, s \in r^Q (r, s) ⎞ ⎠, N (s, a) = 1 + \sum r \in rollouts, s, a \in r 1, N (s) = \sum a N (s, a)

(1)

(observe that the resulting Monte-Carlo tree has a variable connectivity). In this expression, $^Q (r, s)$ is the standard Monte-Carlo return of a rollout after state $s$ . The left term ${max}_{a} Q (s, a)$ acts as a prior on the value of a node $s$ . It is essential to include this term to obtain learning with MCTS, even if using a large budget (see Fig. E.1). We interpret this as being due to the large number of actions stemming from each node and to the fact that many of these actions are actually invalid.

We then perform MCTS exploration by picking the action $a$ that maximizes $V (s, a)$ , where for common MCTS with UCT exploration (Kocsis & Szepesvári, 2006) one would have

\begin{matrix} V (s, a) = V ((a_{0}, \dots, a_{t}, a)) + c \sqrt{\frac{ln N (s)}{N ((a_{0}, \dots, a_{t}, a))}} \end{matrix}

Remembering that the action $a$ can be decomposed as $(α, β)$ , where $α$ represents an edge index and $β$ all the remaining dimensions of the action (relative $x$ placement, use of glue or not, ..), we instead first pick $α$ as the maximizer of

V^{'} (x, α) := max β [V ((a_{0}, \dots, a_{t}, (α, β)))] + c \sqrt{\frac{ln N (s)}{\sum_{β} N ((a_{0}, \dots, a_{t}, (α, β)))}},

and then $β$ as the maximizer of $β \to V (s, (α, β))$ . We find this approach to yield slightly better results (see Fig. E.1), and to offer better invariance to changes in the second dimension of the action (e.g. when introducing two dimensional relative placement or changing the number of discretization steps). We use a value of $c = 2$ for the UCT constant, and do not find a strong influence of this value on our results.

Figure E.1: Comparison of the learning based approaches with non-guided MCTS. Model free denotes the relative DQN agent, model based the relative DQN agent with MCTS at training time (budget of 10), Raw MCTS (10) (resp. Raw MCTS (100), Raw MCTS (1000)) denotes a pure MCTS search (without prior on an action value) with a budget of 10 (resp. 100, 1000). For each of the MCTS result, we show the result when performing the search over the actions in two stages (as described in E) or in the usual way. The non-visible bars correspond to zero reward.

We then use a transition model to deduce the observation, reward and discount obtained when transitioning from $s$ to $s^{'}$ . For the results presented in the main part of this work, we focused on using a perfect transition model, obtained from reseeding the environment every time with the initial state of an episode and reapplying the same sequence of actions. While this is impractical for the large MCTS budgets used in some other works, this provides an upper-bound on the performance that can be obtained with a learnt model and allows to separate hyper-parameters analysis. Also, as we will show in the next paragraph, it is possible to obtain significant gains even when performing the MCTS expansion only at test time.

e.2 Results with the environment simulator

We incorporate planning in two ways to our relative discrete agent. In the first variation, we only perform MCTS at test time, using an independently trained Q-network to act as a prior in our MCTS expansion (cf. Eq.(1)). We observe that this improves the results on almost all problems but for Covering. In particular, in Reaching, the fraction of the hardest scenes where the agent does not reach all three targets is decreased by a factor of 4 (from 55% down to 16%).

In the second variation, we also perform MCTS at training time: the actor generates trajectories using MCTS expansions using its current Q-function, and the resulting trajectories are then fed to the learner (which does not do any Monte-Carlo sampling). We observe that this second approach yield slightly more stable learning and higher performance on Covering Hard, the task that requires the more reasoning (see the last panel of Fig. 5). On the other hand, on other problems, it yields a similar or even decreased performance.

An interesting point to note is that, when training with a perfect simulator, the transfer into the Q-function is very imperfect, as demonstrated by the low value of the left most point on the darker curve of Fig. 5. As it turns out, the agent is relying on the model to select the best action out of the few candidates selected by the Q-function. This may explain why the performance does not necessarily increase when testing with more budget, as the Q-function does not in this case provide a good prior when doing a deeper exploration of the MCTS tree. This is, in essence, also similar to the hypothesis put forward in (Azizzadenesheli et al., 2018).

e.3 Results with a learned model

Finally, we extend the previous model-based results by performing the MCTS expansion with a learnt model rather than a perfect simulator of the environment. Using a learnt object-based model was recently put forward as an efficient method for planning in RL (Pascanu et al., 2017; Hamrick et al., 2017) and for predicting physical dynamics (Sanchez-Gonzalez et al., 2018; Janner et al., 2019). Note, however, that none of these approaches have attempted to use MCTS with a graph network-based model.

The model is an operator taking as an input a graph observation and an action, and outputting a new graph observation alongside a reward and discount for the transition:

M : O \times A \to O \times R \times [0, 1]

Given a sequence of observations $o$ , actions $a$ , rewards $r$ and discounts $γ$ belonging to a single episode, we train this model with an unrolled loss

\begin{matrix} L_{n_{unroll}} ((o_{t^{'}})_{t \leq t^{'} \leq t + n_{unroll}}, (r_{t^{'}}, a_{t^{'}}, γ_{t^{'}})_{t \leq t^{'} \leq t + n_{unroll} - 1}) := n_{unroll} - 1 \sum n = 0 l (M^{(n)} (o_{t}, (a_{t^{'}})_{t \leq t^{'} < t + n}), r_{t + n}, γ_{t + n}) \end{matrix}

where we defined the predicted observation after $n$ steps

M^{(n)} (o_{t}, (a_{t^{'}})_{t \leq t^{'} < t + n}) = M (M^{(n - 1)} (o_{t}, (a_{t^{'}})_{t \leq t^{'} < t + n - 1}), a_{t + n - 1})_{0}, M^{(0)} (o_{t}) = o_{t}

and the single step loss

l ((o, r, γ), o^{'}, r^{'}, γ^{'}) := {∥ ∥ o - o^{'} ∥ ∥}_{2}^{'} + {∥ ∥ r - r^{'} ∥ ∥}_{2}^{'} + D_{KL} ((γ, 1 - γ) | | (γ^{'}, 1 - γ^{'})) .

In practice we varied the number of unrolls $n$ between 1 and 4. The model training is slower with a larger number of unrolls, but it yields more consistent unrolls when used within the MCTS expansion (ideally, the number of unrolls should probably match the typical depth of a MCTS unroll). The model architecture is similar to the one of the main Q-network described in Sec. C.

Model pre-training: At first, we experiment with using a pretrained, learnt model to then perform Q-learning with MCTS. The setup is therefore as follows:

Train an agent model free, or with a perfect environment simulator.
Train a model on trajectories generated by this agent.
Train a second agent with the model learnt in (2)

We observe in Fig. E.2 that this allows to obtain an improved performance at the beginning of training, matching the results obtained with a perfect environment simulator. However, on longer timescales, the performance plateaus and does slightly worse than a model free agent. We interpret this as being due to the rigidity of the model on longer timescales, which is not able to generalize enough to the data distribution that would be required to obtain larger rewards.

Figure E.2: Performance of agents with pre-trained models at small number of steps. *Pretrained (a)* uses a model pre-trained on a model free agent (the continuation of the light grey curve), while *Pretrained (b)* uses a model pre-trained on a model based agent (the continuation of the dark grey curve). Observe how the pre-trained curves match the perfect model curves at short times. All these curve use a same learning rate of $2 10^{- 4}$ for fair comparison on short timescales. In all plots, solid lines are median performance across seeds and shaded regions extend between min and max seeds.

Figure E.3: Performance of agents learning a model of the environment at small number of steps. The model based agent use an MCTS budget of 5 that worked best in this setting. All these curve use a same learning rate of $2 10^{- 4}$ for fair comparison on short timescales. In all plots, solid lines are median performance across seeds and shaded regions extend between min and max seeds.

Model learnt online: Finally, we try to learn a model online. In this case the agent is trained with a model which is learnt at the same time on trajectories generated by the agent. As shown on Fig. E.3, we are able to slightly outperform the model free agent on short timescales in two of the problems (Silhouette and Covering Hard), while the noise introduced by the model is prohibitive again in Covering. On longer timescales, the imperfections of the model make the agent trained with a learnt model converge to the same rewards as the one trained without a model, rather than with a perfect model.

We believe that both in this case and when pre-training the model, understanding how to better train the model so that it generalizes better and yields sharper predictions are important areas of future research, and we see the positive results described here at the beginning of training as a strong motivation to pursue work in this direction.

Appendix F Model-free continuous agent

f.1 Rs0

We use a Retraced Stochastic Value Gradients (RS0, Heess et al. (2015); Munos et al. (2016); Riedmiller et al. (2018)

) off-policy agent, with a shared observation pre-processor and independent actor and critic core models (MLP or GN). The critic is conditioned on the actions by concatenating them with the input to the model core (either MLP input features of graph globals). The actor learns a Gaussian distribution over each of the actions by outputting parameters using a linear policy head, conditioned on the last layer of the MLP or output globals of the GN. We use a value of 0.98 for the discount and calculated the retrace loss on sequences of length 5.

f.2 Exploration

While the Gaussian policy noise is often sufficient as a source of exploration, due to the highly multi-modal nature of placing objects, we injected additional fixed $ϵ$ exploration by sampling a continuous action uniformly over the action range with probability $ϵ$ , and sampling from the Gaussian otherwise. We set $ϵ = .08$ for tasks with shorter episodes (Silhouette and Covering Hard) and $ϵ = .03$ otherwise.

f.3 Dynamic curriculum

Due to the slower training of RS0 compared to DQN, and the large variance in learning time across the different configurations, we use a dynamic curriculum, only allowing agents to progress through the curriculum once they had achieved a certain performance in the current level.

The criteria for progressing through the curriculum is to obtain at least 50% of the maximum reward in at least 50% of the episodes (Silhouette, Covering Hard) or at least 25% of the maximum reward in at least 25% of the episodes (Connecting, Covering). The threshold values were selected to ensure that the great majority of seeds would reach the maximum level of the curriculum during the allocated experiment time.

To avoid agents from progressing in the curriculum by just solving a particular type of scene, this criteria is applied independently over groups of episodes partitioned based on unique combinations of: number of targets, maximum target height, number of obstacles and maximum obstacle height, and using statistics from the last 200 episodes in each group.

f.4 Distributed setup

We run every experiment with 10 independent seeds, each of them with 8 actors, 1 learner and 1 FIFO replay (capacity= $10^{5}$ sequences). Additionally, an evaluation actor with the exploration disabled (and that did not feed data into the replay) is used to generate data to evaluate the dynamic curriculum criteria, and to monitor the overall performance in the task at maximum difficulty.

Due to the off-policy character of the algorithm, we did not set any synchronization between the actors generating the data and the learner obtaining batched of data from the replay. As a consequence, the relative number of actor steps per second and learner steps per second can vary drastically across the different architectures, depending of the relative speed differences between the forward pass (actors), and the backward pass (learner) of the models. Instead, we decided to use a wall-time criteria for terminating our experiments, stopping all experiments after one week of training, or after performance started decreasing.

Appendix G Videos

Task	Best absolute agent	Best non-GN relative agent	Best relative agent	Best model-based relative agent
Silhouette	GN-RS0	RNN-RS0	GN-DQN	GN-DQN with MCTS at test time
Gen. 16 Blocks	GN-RS0	CNN-RS0	GN-DQN	GN-DQN with MCTS at test time
Connecting	RNN-RS0	RNN-RS0	GN-DQN	GN-DQN with MCTS at test time
Gen. Diff. Locs.	RNN-RS0	RNN-RS0	GN-DQN	GN-DQN with MCTS at test time
Gen. 4 Layers	RNN-RS0	RNN-RS0	GN-DQN	GN-DQN with MCTS at test time
Covering	GN-RS0	CNN-RS0	GN-DQN	GN-DQN with MCTS at test time
Covering Hard	GN-RS0	RNN-RS0	GN-DQN	GN-DQN with MCTS at train and test time

Table G.1: Links to videos demonstrating constructing behavior for the best agents (as determined by evaluating on 10K episodes) on 10 random episodes. These episodes were taken from the hardest levels of the curriculum for each of the tasks, including Generalization (Gen.) settings where available. For each task, we used the same set of 10 random episodes across all agents to enable easy comparison. All videos are also provided here: https://tinyurl.com/y7wtfen9 .