Venue: NAACL 2021

# Modular Networks for Compositional Instruction Following

Rodolfo Corona Daniel Fried Coline Devin Dan Klein Trevor Darrell

UC Berkeley

{rcorona,dfried,coline,klein,trevordarrell}@berkeley.edu

###### Abstract

Standard architectures used in instruction following often struggle on novel compositions of _subgoals_ (e.g. navigating to landmarks or picking up objects) observed during training. We propose a modular architecture for following natural language instructions that describe sequences of diverse subgoals. In our approach, subgoal modules each carry out natural language instructions for a specific subgoal type. A sequence of modules to execute is chosen by learning to segment the instructions and predicting a subgoal type for each segment. When compared to standard, non-modular sequence-to-sequence approaches on ALFRED Shridhar et al. (2020), a challenging instruction following benchmark, we find that modularization improves generalization to novel subgoal compositions, as well as to environments unseen in training.

## 1 Introduction

Work on grounded instruction following MacMahon et al. (2006); Vogel and Jurafsky (2010); Tellex et al. (2011); Chen and Mooney (2011); Artzi and Zettlemoyer (2013) has recently been driven by sequence-to-sequence models Mei et al. (2016); Hermann et al. (2017), which allow end-to-end grounding of linguistically-rich instructions into equally-rich visual contexts Misra et al. (2018); Anderson et al. (2018); Chen et al. (2019). These sequence-to-sequence models are _monolithic_: they consist of a single network structure which is applied identically to every example in the dataset.

Monolithic instruction following models typically perform well when evaluated on test data from the same distribution seen during training. However, they often struggle in _compositional generalization_: composing atomic parts, such as actions or goals, where the parts are seen in training but their compositions are not Lake and Baroni (2018); Ruis et al. (2020); Hill et al. (2020).

In this work, we improve compositional generalization in instruction following with _modular networks_, which have been successful in non-embodied language grounding tasks Andreas et al. (2016); Hu et al. (2017); Cirik et al. (2018); Yu et al. (2018); Mao et al. (2019); Han et al. (2019) and in following synthetic instructions or symbolic policy descriptions Andreas et al. (2017); Oh et al. (2017); Das et al. (2018). Modular networks split the decision making process into a set of neural modules. Modules are each specialized for some function, composed into a structure specific to each example, and trained jointly to complete the task.

Prior work has found that modular networks often perform well in compositional generalization

Figure 1: At evaluation time, an instruction following agent may need to generalize both to novel chains of subgoals encountered during training as well as to completely new environments. In the generalization condition above, the agent must generalize to _multiple_ pickup actions (in green) at test time, whereas only single ones were seen at training, as well as to a new house. We propose a modular architecture to handle these cases.



because of their composable structure (Devin et al., 2017; Andreas et al., 2017; Bahdanau et al., 2019; Purushwalkam et al., 2019), and that they can generalize to new environments or domains through module specialization (Hu et al., 2019; Blukis et al., 2020). However, all this work has either focused on grounding tasks without a temporal component or used a network structure which is not predicted from language.

We propose a modular architecture for embodied vision-and-language instruction following1, and find that this architecture improves generalization on unseen compositions of _subgoals_ (such as navigation, picking up objects, cleaning them, etc.). We define separate sequence-to-sequence modules per type of subgoal. These modules are strung together to execute complex high-level tasks. We train a controller to predict a sequence of subgoal types from language instructions, which determines the order in which to execute the modules.

Footnote 1: Code and dataset splits may be found at github.com/rcorona/modular_compositional_affred.

We evaluate models on the ALFRED dataset (Shridhar et al., 2020), an instruction-following benchmark containing a diverse set of household tasks. We focus on compositional generalization: carrying out instructions describing novel high-level tasks, containing novel compositions of actions (see Figure 1 for an example). We find that our modular model improves performance on average across subgoal types when compared to a standard, monolithic sequence-to-sequence architecture. Additionally, we find improved generalization to environments not seen in training.

## 2 Modular Instruction Following Networks

We focus on following instructions in embodied tasks involving navigation and complex object interactions, as shown in Figure 2.

In training, each set of _full instructions_ (_e.g._ Turn right and cross the room ... Place the vase on the coffee table to the left of the computer.") is paired with a _demonstration_ of image observations and actions. In training, we further assume that the full instruction is segmented into _subgoal instructions_, and each subgoal instruction is labeled with one of a small number (in our work, 8) of _subgoal types_ , _e.g._ ["Walk to the coffee maker.": GoTo ], ["Pick up the dirty mug...": PickUp], ..., and paired with the corresponding segment of the demonstration.

During evaluation, the agent is given only full instructions (which are unsegmented and unlabeled), and must predict a sequence of actions to carry out the instructions, conditioning on the image observations it receives.

Our modular architecture for compositional instruction following consists of a _high-level controller_ (Figure 2, left), and _modules_ for each subgoal type (Figure 2, right). The high-level controller chooses modules to execute in sequence based on the natural language instructions, and each chosen module executes until it outputs a STOP action. The modules all share the same sequence-to-sequence architecture, which is the same as the monolithic architecture. We initialize each module's parameters with parameters from the monolithic model, and then fine-tune the parameters of each module to specialize for its subgoal.

Figure 2: Our modular approach first uses a _controller_ (left) trained with supervised learning to segment a given instruction and label segments with subgoal types (_e.g._GoTo, Pickup) to execute. These subgoal types are used to chain together _modules_ (right) to carry out instructions in the environment. Each module is a separately-parameterized sequence-to-sequence model that conditions on an attended representation of the instruction sequence, the visual observations, and the action taken at the previous timestep. Modules pass recurrent hidden states to each other.

 



### Instruction-Based Controller

Our instruction-based controller is trained to segment a full instruction into sub-instructions and predict the subgoal type for each sub-instruction. We use a linear chain CRF (Lafferty et al., 2001) that conditions on a bidirectional-LSTM encoding of the full instruction and predicts tags for each word, which determine the segmentation and sequence of subgoal types. This model is based on standard neural segmentation and labelling models (Huang et al., 2015; Lample et al., 2016).

We train the controller on the ground-truth instruction segmentations and subgoal sequence labels, and in evaluation use the model to predict segmentations and their associated subgoal sequences (Figure 2, top left). This predicted sequence of subgoals determines the order to execute the modules (Figure 2, right). We use a BIO chunking scheme to jointly segment the instruction and predict a subgoal label for each segment.

Formally, for a full instruction of length \(N\), the controller defines a distribution over subgoal tags \(s_{1:N}\) for each word given the instruction \(x_{1:N}\) as

\[p(s_{1:N}\mid x_{1:N})\propto\exp\sum_{n=1}^{N}\left(U_{s_{n}}+B_{s_{n-1},s_{ n}}\right)\]

The subgoal tag scores \(U_{s_{n}}\) for word \(n\) are given by a linear projection of bidirectional LSTM features for the word at position \(n\). The tag transition scores \(D_{s_{n-1},s_{n}}\) are learned scalar parameters.

In training, we supervise \(s_{1:N}\) using the segmentation of the instruction \(x_{1:N}\) into \(K\) subgoal instructions and the subgoal label for each instruction. To predict subgoals for a full instruction in evaluation, we obtain \(\operatorname*{arg\,max}_{s_{1:N}}p(s_{1:N}\mid x_{1:N})\) using Viterbi decoding, which provides a segmentation into sub-instructions and a subgoal label for each sub-instruction.

The controller obtains 96% exact match accuracy on subgoal sequences on validation data.

### Module Architecture

Our modularized architecture may be seen in Figure 2, right. The architecture consists of 8 independent modules, one for each of the 8 subgoals in the domain (_e.g._GoTo, PickUp). For each module, we use the same architecture as Shridhar et al. (2020)'s monolithic model. This is a sequence-to-sequence model composed of an LSTM decoder taking as input an attended embedding of the natural language instruction, pretrained ResNet-18 (He et al., 2016) features of the image observations, and the previous action's embedding. Hidden states are passed between the modules' LSTM decoders at subgoal transitions (Figure 2, right).

At each time step, each module \(M^{i}\) computes its hidden state based on the last time step's action \(a_{t-1}\), the current time step's observed image features \(o_{t}\), an attended language embedding \(\hat{x}^{i}_{t}\), and the previous hidden state \(h^{i}_{t-1}\):

\[e^{i}_{t} =[a_{t-1};o_{t};\hat{x}^{i}_{t}]\] \[h^{i}_{t} =\text{LSTM}_{i}(e^{i}_{t},h^{i}_{t-1})\]

Each module's attended language embedding \(\hat{x}^{i}_{t}\) is produced using its own attention mechanism over embeddings \(X=x_{1:N}\) of the language instruction, which are produced by a bidirectional LSTM encoder:

\[z^{i}_{t} =(W^{i}_{x}h^{i}_{t-1})^{\top}X\] \[\alpha^{i}_{t} =\text{Softmax}(z^{i}_{t})\] \[\hat{x}^{i}_{t} =(\alpha^{i}_{t})^{\top}X\]

Finally, the action \(a_{t}\) and object interaction mask \(m_{t}\) are predicted from \(h^{i}_{t}\) and \(e^{i}_{t}\) with a linear layer and a deconvolution network respectively. More details about this architecture can be found in Shridhar et al. (2020). Both the action and mask decoders, well as the language encoder, are shared across modules.2

Footnote 2: The modules’ instruction encoder is separate from the controller’s encoder (Sec. 2.1), as we found it possible to achieve high performance on the subgoal prediction task using a smaller encoder than the one used by the modules.

Our use of subgoal modules is similar to the hierarchical policy approaches of Andreas et al. (2017), Oh et al. (2017), and Das et al. (2018). However, in those approaches, the input to each module is symbolic (_e.g._find[kitchen]). In contrast, all modules in our work condition directly on natural language.

### Training

We first pre-train the monolithic model by maximizing the likelihood of the ground-truth trajectories in the training data (Shridhar et al., 2020). We train for up to 20 epochs using the Adam optimizer (Kingma and Ba, 2014) with early stopping on validation data (see Appendix A.1 for hyperparameters). We use this monolithic model to initialize the parameters of each of the modules, which have identical architecture to the monolithic model, and

fine-tune them using the same training and early stopping procedure on the same validation data,3 allowing the monolithic model's parameters to specialize for each module. Each module predicts only the actions for its segment of each trajectory; however, modules are jointly fine-tuned, passing hidden states (and gradients) from module to module.

Footnote 2: [https://github.com/google-learning/tree-master/](https://github.com/google-learning/tree-master/)

## 3 Generalization Evaluation

We evaluate models on out-of-domain generalization in two conditions (see below) using the ALFRED benchmark Shridhar et al. (2020), comparing our modular approach to their non-modular sequence-to-sequence model. ALFRED is implemented in AI2-THOR 2.0 Kolve et al. (2017), which contains a set of simulated environments with realistic indoor scene renderings and object interactions.

The dataset contains approximately 25K expert instruction-trajectory pairs, comprised of 3 instructions for each of 8K unique trajectories. The instructions include both a high level instruction and a sequence of low level instructions. In our experiments, we do not use the high level instructions, which Shridhar et al. (2020) found to produce comparable results when evaluated on generalization to unseen environments with these architectures.

Figure 1 shows two example trajectories and their associated instructions. Trajectories are composed (see Sec. 2) of sequences of eight different types of subgoals: navigation (GoTo) and a variety of object interactions (_e.g._PickUp, Clean, Heat). Each subgoal's subtrajectory is composed of a sequence of low-level discrete actions which specify commands for navigation or object interactions (which are accompanied by image segmentations to choose the object to interact with).

### Generalization Conditions

The ALFRED dataset was constructed to test generalization to novel instructions and unseen environments. However, all evaluation trajectories in the dataset correspond to sequences of subgoals that are seen during training. For example, some training and evaluation instances might both correspond to the underlying subgoal sequence GoTo, PickUp, GoTo, Put, but differ in their low-level actions, their language descriptions, and possibly also the environments they are carried out in.

Novel Tasks.We evaluate models' ability to generalize to different high-level tasks (compositions of subgoals) than seen in training. The dataset contains seven different task types, such as _Pick & Place_, as described in Appendix B.1. We hold out two task types and evaluate models on their ability to generalize to them: _Pick Two & Place_ and _Stack & Place_. These tasks are chosen because they contain subgoal types that are all individually seen in training, but typically in different sequences.

We create generalization splits _pick-2-seen_ and _pick-2-unseen_ by filtering the _seen_ and _unseen_ splits below to contain only _Pick Two & Place_ tasks, and remove all _Pick Two & Place_ tasks from the training data. We create splits _stack-seen_ and _stack-unseen_ for _Stack & Place_ similarly.

Novel Instructions and EnvironmentsThis is the standard condition defined in the original ALFRED dataset. There are two held-out validation sets: _seen_, which tests generalization to novel instructions and trajectories but through environments seen during training, and _unseen_, which tests generalization to novel environments: rooms with new layouts, object appearances, and furnishings.

### Results

We compare our modular architecture with the monolithic baseline, averaging performance over models trained from 3 random seeds. For each generalization condition, we measure success rates over full trajectories as well as over each subgoal type independently. Due to the challenging nature of the domain, subgoal evaluation provides finer-grained comparisons than full trajectories.

We use the same evaluation methods and metrics as in Shridhar et al. (2020). Success rates are weighted by path lengths to penalize successful trajectories which are longer than the ground-truth demonstration trajectory. To evaluate full trajectories, we measure path completion: the portion of subgoals completed within the full trajectories. To evaluate the subgoals independently, we advance the model along the expert trajectory up until the point where a given subgoal begins (to maintain a history of actions and observations), then require the model to carry out the subgoal from that point.

We also report results from Shridhar et al. (2020) and Singh et al. (2020). We note that the approach of Singh et al. (2020) obtains higher performance on full trajectories than the system of Shridhar et al. (2020) (which we base our approach on) 

primarily by introducing a modular object interaction architecture (shared across all subgoals) and a pre-trained object segmentation model. These techniques could also be incorporated into our approach, which uses modular components for individual subgoal types.

Novel Tasks.Table 1 shows for each split the success rates on subgoals appearing in at least 50 validation examples. The modular outperforms the monolithic model on both seen and unseen splits (Tables 2(b) and 3(c)). Full trajectory results for novel task generalization are shown in Table 2. In the double generalization condition (unseen environments for the held-out pick-2 and stack tasks) on full trajectories, neither model completes subgoals successfully. Overall, we find that modularity helps across most generalization conditions.

Generalization to novel environments.We also compare models on generalization to unseen environments. In the independent subgoal evaluation, the monolithic and modular models perform equally on average in the standard-seen split (Table 2(a), top). However, in the standard-unseen split (Table 2(a), bottom), our modular model outperforms the baseline substantially, with an average success rate of \(57\%\) compared to the monolithic model's \(46\%\). (On subgoal types not shown, the modular model still outperforms the monolithic, by margins up to 16%.) In the full trajectory results (Table 2) we see comparable performance between the monolithic and modular models on unseen environments.

## 4 Conclusions

We introduced a novel modular architecture for grounded instruction following where each module is a sequence-to-sequence model conditioned on natural language instructions. With the ALFRED dataset as a testbed, we showed that our modular model achieves better out-of-domain generalization, generalizing better at the subgoal level to novel task compositions and unseen environments than the monolithic model used in prior work. All of the module types in our model currently use separate parameterizations but identical architectures; future work might leverage the modularity of our approach by using specialized architectures, training procedures, or loss functions for each subgoal type. Furthermore, unsupervised methods for jointly segmenting instructions and trajectories without requiring labeled subgoal labels and alignments would be a valuable addition to our framework.

## Acknowledgments

This material is based upon work supported by the National Science Foundation Graduate Research Fellowship Program under Grant No. DGE 1752814, a Ford Foundation fellowship to the first author, a Google PhD fellowship to the second author, and by DARPA through the XAI program and the LwLL program.

\begin{table}

\end{table}
Table 1: Path weighted subgoal success percentages, by subgoal type, on the various generalization splits, and averaged across subgoal types _Avg._). We compare the performance of the monolithic (_Mono._) model to our modular model (_Mod._). The modular model generalizes better on average to unseen environments (standard-unseen) and to both seen and unseen environments for two held-out task types: _Pick-2_ and _Stack_. Bolded numbers show the best model between Mono and Modular, with * and ** denoting differences that are statistically significant at the \(p<0.15\) and \(p<0.05\) levels, respectively, by a one-tailed t-test. S+ gives results from Shridhar et al. (2020) and MOCA from Singh et al. (2020).

\begin{table}
\begin{tabular}{l c c c c c c|c}  & Model & Standard & Stack & Pick-2 & Stack \\ Model & seen & unseen & seen & seen & seen \\ \hline S+ & 9.4 (5.7) & 7.4 (4.7) & — & — & — \\ MOCA & 28.5 (22.3) & 13.4 (8.3) & — & — & — \\ Mono. & **10.9 (7.0)** & **7.1 (4.9)** & 1.3 (1.6) & 1.3 (0.3) \\ Mod. & 9.1 (6.6) & 7.0 (**5.5)** & **1.5 (1.6)** & **1.5 (0.4)** \\ \hline \end{tabular}
\end{table}
Table 2: We compare performance of the monolithic and modular models on full trajectories, reporting the percentages of subgoals correctly completed. Numbers in parentheses weight these percentages by path length. S+ gives results from Shridhar et al. (2020), and MOCA from Singh et al. (2020).

 



## References

* Anderson et al. (2018) Peter Anderson, Qi Wu, Damien Teney, Jake Bruce, Mark Johnson, Niko Sunderhauf, Ian Reid, Stephen Gould, and Anton van den Hengel. 2018. Vision-and-language navigation: Interpreting visually-grounded navigation instructions in real environments. In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)_. Andreas et al. (2017) Jacob Andreas, Dan Klein, and Sergey Levine. 2017. Modular multitask reinforcement learning with policy sketches. In _Proceedings of the International Conference on Machine Learning (ICML)_, pages 166-175. Andreas et al. (2016) Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. 2016. Neural module networks. In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)_, pages 39-48. Artzi and Zettlemoyer (2013) Yoav Artzi and Luke Zettlemoyer. 2013. Weakly supervised learning of semantic parsers for mapping instructions to actions. _Transactions of the Association for Computational Linguistics (TACL)_, 1(1):49-62. Bahdanau et al. (2019) Dzmitry Bahdanau, Shikhar Murty, Michael Noukhovitch, Thien Huu Nguyen, Harm de Vries, and Aaron Courville. 2019. Systematic generalization: what is required and can it be learned? In _Proceedings of the International Conference on Learning Representations (ICLR)_. Blukis et al. (2020) Valts Blukis, Yannick Terme, Eyvind Niklasson, Ross A. Knepper, and Yoav Artzi. 2020. Learning to map natural language instructions to physical quadcopter control using simulated flight. volume 100 of _Proceedings of Machine Learning Research_, pages 1415-1438. PMLR. Chen and Mooney (2011) David L. Chen and Raymond J. Mooney. 2011. Learning to interpret natural language navigation instructions from observations. In _Proceedings of the Conference on Artificial Intelligence (AAAI)_. Chen et al. (2019) Howard Chen, Alane Shir, Dipendra Misra, Noah Snavely, and Yoav Artzi. 2019. Touchdown: Natural language navigation and spatial reasoning in visual street environments. In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)_. Cirik et al. (2018) Volkan Cirik, Taylor Berg-Kirkpatrick, and Louis-Phillippe Morency. 2018. Using syntax to ground referring expressions in natural images. In _Proceedings of the Conference on Artificial Intelligence (AAAI)_. Das et al. (2018) Abhishek Das, Georgia Gkioxari, Stefan Lee, Devi Parikh, and Dhruv Batra. 2018. Neural modular control for embodied question answering. In _Proceedings of the Conference on Robot Learning (CoRL)_. Devin et al. (2017) Coline Devin, Abhishek Gupta, Trevor Darrell, Pieter Abbeel, and Sergey Levine. 2017. Learning modular neural network policies for multi-task and multirobot transfer. In _Proceedings of the IEEE International Conference on Robotics and Automation (ICRA)_, pages 2169-2176. Han et al. (2019) Chi Han, Jiayuan Mao, Chuang Gan, Josh Tenenbaum, and Jiajun Wu. 2019. Visual concept-metaconcept learning. In _Advances in Neural Information Processing Systems (NIPS)_, pages 5002-5013. He et al. (2016) Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2016. Deep residual learning for image recognition. In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)_, pages 770-778. Hermann et al. (2017) Karl Moritz Hermann, Felix Hill, Simon Green, Fumin Wang, Ryan Faulkner, Hubert Soyer, David Szepesvari, Wojciech Marian Czarnecki, Max Jaderberg, Denis Teplyashin, Marcus Wainwright, Chris Apps, Demis Hassabis, and Phil Blunsom. 2017. Grounded language learning in a simulated 3d world. _CoRR_, abs/1706.06551. Hill et al. (2020) Felix Hill, Andrew Lampinen, Rosalia Schneider, Stephen Clark, Matthew Botvinick, James L McClelland, and Adam Santoro. 2020. Environmental drivers of systematicity and generalization in a situated agent. In _Proceedings of the International Conference on Learning Representations (ICLR)_. Hu et al. (2017) Ronghang Hu, Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Kate Saenko. 2017. Learning to reason: End-to-end module networks for visual question answering. In _Proceedings of the IEEE International Conference on Computer Vision (ICCV)_, pages 804-813. Hu et al. (2019) Ronghang Hu, Daniel Fried, Anna Rohrbach, Dan Klein, Trevor Darrell, and Kate Saenko. 2019. Are you looking? grounding to multiple modalities in vision-and-language navigation. In _Proceedings of the 57th Conference of the Association for Computational Linguistics, ACL 2019, Florence, Italy, July 28- August 2, 2019, Volume 1: Long Papers_, pages 6551-6557. Association for Computational Linguistics. Huang et al. (2015) Zhiheng Huang, Wei Xu, and Kai Yu. 2015. Bidirectional LSTM-CRF models for sequence tagging. _arXiv preprint arXiv:1508.01991_. Kingma and Ba (2014) Diederik P Kingma and Jimmy Ba. 2014. Adam: A method for stochastic optimization. In _Proceedings of the International Conference on Learning Representations (ICLR)_. Kolve et al. (2017) Eric Kolve, Roozbeh Mottaghi, Winson Han, Eli VanderBilt, Luca Weihs, Alvaro Herrasti, Daniel Gordon, Yuke Zhu, Abhinav Gupta, and Ali Farhadi. 2017. AI2-THOR: An interactive 3D environment for visual AI. _arXiv preprint arXiv:1712.05474_

John Lafferty, Andrew McCallum, and Fernando CN Pereira. 2001. Conditional random fields: Probabilistic models for segmenting and labeling sequence data. In _Proceedings of the International Conference on Machine Learning (ICML)_.
* Lake and Baroni [2018] Brenden M Lake and Marco Baroni. 2018. Generalization without systematicity: On the compositional skills of sequence-to-sequence recurrent networks. _Proceedings of the International Conference on Machine Learning (ICML)_.
* Lample et al. [2016] Guillaume Lample, Miguel Ballesteros, Sandeep Subramanian, Kazuya Kawakami, and Chris Dyer. 2016. Neural architectures for named entity recognition. In _Proceedings of the Conference of the North American Chapter of the Association for Computational Linguistics (NAACL)_.
* MacMahon et al. [2006] Matt MacMahon, Brian Stankiewicz, and Benjamin Kuipers. 2006. Walk the talk: Connecting language, knowledge, and action in route instructions. In _Proceedings of the Conference on Artificial Intelligence (AAAI)_.
* Mao et al. [2019] Jiayuan Mao, Chuang Gan, Pushmeet Kohli, Joshua B Tenenbaum, and Jiajun Wu. 2019. The neuro-symbolic concept learner: Interpreting scenes, words, and sentences from natural supervision. In _Proceedings of the International Conference on Learning Representations (ICLR)_.
* Mei et al. [2016] Hongyuan Mei, Mohit Bansal, and Matthew Walter. 2016. Listen, attend, and walk: Neural mapping of navigational instructions to action sequences. In _Proceedings of the Conference on Artificial Intelligence (AAAI)_.
* Misra et al. [2018] Dipendra Misra, Andrew Bennett, Valts Blukis, Eyvind Niklasson, Max Shatkhin, and Yoav Artzi. 2018. Mapping instructions to actions in 3D environments with visual goal prediction. In _Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP)_, pages 2667-2678.
* Volume 70_, ICML'17, page 2661-2670. JMLR.org.
* Purushwalkam et al. [2019] Senthil Purushwalkam, Maximilian Nickel, Abhinav Gupta, and Marc'Aurelio Ranzato. 2019. Task-driven modular networks for zero-shot compositional learning. In _Proceedings of the IEEE International Conference on Computer Vision (ICCV)_, pages 3593-3602.
* Ruis et al. [2020] Laura Ruis, Jacob Andreas, Marco Baroni, Diane Bouchacourt, and Brenden M Lake. 2020. A benchmark for systematic generalization in grounded language understanding. _arXiv preprint arXiv:2003.05161_.
* Shridhar et al. [2020] Mohit Shridhar, Jesse Thomason, Daniel Gordon, Yonatan Bisk, Winson Han, Roozbeh Mottaghi, Luke Zettlemoyer, and Dieter Fox. 2020. ALFRED: A benchmark for interpreting grounded instructions for everyday tasks. In _Computer Vision and Pattern Recognition (CVPR)_.
* Singh et al. [2020] Kunal Pratap Singh, Suvaansh Bhambi, Byeonghwi Kim, Roozbeh Mottaghi, and Jonghyun Choi. 2020. Moca: A modular object-centric approach for interactive instruction following. _arXiv preprint arXiv:2012.03208_.
* Tellex et al. [2011] Stefanie Tellex, Thomas Kollar, Steven Dickerson, Matthew R Walter, Ashis Gopal Banerjee, Seth J Teller, and Nicholas Roy. 2011. Understanding natural language commands for robotic navigation and mobile manipulation. In _Proceedings of the Conference on Artificial Intelligence (AAAI)_, volume 1, page 2.
* Vogel and Jurafsky [2010] Adam Vogel and Dan Jurafsky. 2010. Learning to follow navigational directions. In _Proceedings of the Annual Meeting of the Association for Computational Linguistics (ACL)_, pages 806-814. Association for Computational Linguistics.
* Yu et al. [2018] Licheng Yu, Zhe Lin, Xiaohui Shen, Jimei Yang, Xin Lu, Mohit Bansal, and Tamara L Berg. 2018. Matnet: Modular attention network for referring expression comprehension. In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)_.

 



## Appendix A Implementation Details

### Model and Training Hyperparameters

We list the hyperparameters used for all models in Table 3, we refer the reader to Shridhar et al. (2020) for more details on the usage of each hyperparameter. Submodules are each structured identically to the monolithic baseline (e.g. each one had a 512 dimensional hidden state).

### Hardware and Training Times

Models were trained on a Quadro RTX 6000 24GB GPU running on a machine with a 14 core Intel Xeon Gold 5120 CPU, with a runtime of approximately 14 hours. Evaluation was done on a V100 16GB GPU on a machine with a 4-core CPU. Subgoal evaluation took approximately 8 hours per split, and full trajectory evaluation approximately 1 hour.

### Evaluation

We evaluate our model using the evaluation code provided by Shridhar et al. (2020).4

Footnote 4: [https://github.com/askforalrefd/alfred](https://github.com/askforalrefd/alfred)

## Appendix B ALFRED Dataset Details

In ALFRED, the agent observes a first person view, navigates with discrete grid movement, and uses objects by outputting a segmentation mask over its image observation. The dataset contains approximately 25K expert instruction-trajectory pairs, pertaining to about 8K unique trajectories.

### Task Types

The dataset contains demonstrations for 7 different kinds of tasks.

Pick & PlaceThe agent must pickup a specified object, bring it to a destination, and place it. For example, "Pick up a vase, place it on the coffee table."

Examine in LightThe agent must pickup an object and bring it to a light source. For example, "Examine the remote control under the light of the floor lamp ."

Heat & PlaceThe agent must pickup an object, put it in the microwave, togle the microwave, take the object out of the microwave, and finally place the heated object at a specified location. For example: "Put a heated apple next to the lettuce on the middle shelf in the refrigerator."

Cool & PlaceThis is the same as above, but with a refrigerator instead of a microwave. For example, "Drop a cold potato slice in the sink."

Clean & PlaceThe agent must put an object into the sink and turn on the water to clean the object. Then, it must be placed at a specified location. For example, "Put a washed piece of lettuce on the counter by the sink."

Stack & PlaceThe agent must pick up an object, place it into a receptacle, and then bring the stacked objects to a specified location and place them. For example, "Move the pan on the stove with a slice of tomato in it to the table."

Pick Two & PlaceThe agent must pickup an object, place it somewhere, then pick up another instance of that object and put it in the same place. For example, "Place two CDs in top drawer of black cabinet."

These last two task types, Stack & Place and Pick Two & Place, are the ones held out in the _Novel Tasks_ generalization experiments.

\begin{table}
\begin{tabular}{c c}
**Hyperparameter** & **Value** \\ \hline Optimizer & Adam \\ Learning Rate & 1e-4 \\ Batch Size & 8 \\ Hidden State Dim & 512 \\ Word/Action Embedding Dim & 100 \\ Zero-Goal & True \\ Zero-Instr & False \\ Lang. Dropout & 0.0 \\ Vision Dropout & 0.0 \\ Input Dropout & 0.0 \\ Attn. Dropout & 0.0 \\ Actor Dropout & 0.0 \\ LSTM Dropout & 0.3 \\ Mask Loss Wt. & 1.0 \\ Action Loss Wt. & 1.0 \\ \hline \end{tabular}
\end{table}
Table 3: Model hyperparameters. These settings largely follow the default parameters used by Shridhar et al. (2020).