papers/1704/1704.08792.tex

\documentclass[10pt,twocolumn,letterpaper]{article}

\usepackage{iccv}
\usepackage{times}
\usepackage{epsfig}
\usepackage{graphicx}
\usepackage{amsmath}
\usepackage{amssymb}

\usepackage{tikz}
\usetikzlibrary{fit, shapes, arrows, positioning, calc}
\usepackage{forest}
\usepackage{color}
\newcommand{\rmn}[1]{{\textcolor{blue}{\bf [{\sc rmn:} #1]}}}



\usepackage[pagebackref=true,breaklinks=true,letterpaper=true,colorlinks,bookmarks=false]{hyperref}

\iccvfinalcopy 

\def\iccvPaperID{****} \def\httilde{\mbox{\tt\raisebox{-.5ex}{\symbol{126}}}}

\begin{document}

\title{DeepArchitect: Automatically Designing and Training Deep Architectures}

\author{Renato Negrinho\\
Carnegie Mellon University\\
{\tt\small negrinho@cs.cmu.edu}
\and
Geoff Gordon\\
Carnegie Mellon University\\
{\tt\small ggordon@cs.cmu.edu}
}

\maketitle




\begin{abstract}
In deep learning, performance is strongly affected by the choice of 
architecture and hyperparameters. 
While there has been extensive work on 
automatic hyperparameter optimization 
for simple spaces, 
complex spaces such as the space of 
deep architectures remain largely unexplored. 
As a result, the choice of architecture is done manually by the human expert 
through a slow trial and error process guided mainly by intuition.
In this paper we describe 
a framework for automatically 
designing and training deep models.
We propose
an extensible and modular language 
that allows the human expert
to compactly represent complex search spaces 
over architectures and their hyperparameters.
The resulting search spaces are 
tree-structured and therefore easy to traverse.
Models can be automatically compiled to computational graphs
once values for all hyperparameters have been chosen. 
We can leverage the structure of the search space 
to introduce different model search algorithms,
such as 
random search, Monte Carlo tree search (MCTS), and 
sequential model-based optimization (SMBO).
We present experiments comparing the different 
algorithms on CIFAR-10 and 
show that MCTS and SMBO outperform 
random search. 
In addition, these experiments 
show that our framework 
can be used effectively
for model discovery,
as
it is possible 
to describe expressive search spaces 
and discover competitive models 
without much effort from the human expert. 
Code for our framework and experiments 
has been made publicly available.
\end{abstract}





\section{Introduction}
\label{sec:intro}
Deep learning has seen a surge in popularity due to
breakthroughs in applications such as 
computer vision, 
natural language processing, and
reinforcement learning~\cite{he2016deep,karpathy2015deep, silver2016mastering,sutskever2014sequence}.
An important observation in much of the recent work is that complex 
architectures are important for achieving high performance~\cite{he2016deep, mnih2013playing}.
Larger datasets and more powerful computing infrastructures are likely to 
increase our ability to effectively train larger, deeper, and more complex architectures.
However, improving the performance of a neural network is not as simple as 
adding more layers or parameters---it 
often requires clever ideas such as creating more
branches~\cite{szegedy2015going} or adding skip connections~\cite{he2016deep}.
Even popular techniques such as dropout~\cite{srivastava2014dropout} and
batch normalization~\cite{ioffe2015batch} 
do not always lead to better performance, 
and need to be judiciously applied to be helpful.

Currently, choosing appropriate values for these architectural hyperparameters
requires close supervision by a human expert, in a trial and error manual search 
process largely guided by intuition.
The expert is burdened by having to make the 
large number of choices 
involved in the specification of a deep model.
Choices interact in non-obvious ways and 
strongly impact performance.
The typical workflow has the expert specify a single model, 
train it, and 
compute a validation score. 
Based on 
the validation score, 
previous experience, and 
information gathered during training, 
the expert decides if the trained model 
is satisfactory or not.
If the model is considered unsatisfactory, 
the expert has to think about model variations
that 
may lead to better performance.


From the perspective of the expert, it would be convenient to 
search over architectures automatically, just as
we search over  
simple scalar hyperparameters, 
such as the learning rate and 
the regularization coefficient.
Ideally, the expert would have control
in setting up the search space to incorporate 
inductive biases about the task being solved and
constraints about computational resources.
Prior to this work, achieving this goal 
was hard because
expressing model search spaces 
using
general hyperparameter optimization tools 
requires the human expert to manually distill a  
set of relevant scalar architectural hyperparameters.

The main contributions of our work are 
\begin{enumerate}
    \item a modular, compositional, and extensible language 
        for compactly 
        representing expressive search spaces over models that
        \begin{enumerate} 
            \item gives control to the human expert over 
                what model variations to consider; 
            \item makes it easy to automatically search for 
                performant 
                models in the search space; 
            \item allows models to be directly compiled to 
                computational graphs 
                without the human expert 
                having to write additional code.
        \end{enumerate}
    \item model search algorithms that rely on 
        the tree-structured search spaces induced by our language   
        to systematically and efficiently 
        search for performant models; namely, we
        \begin{enumerate}
        \item show that by using the constructs 
            in our language, even
            random search can be effective;
        \item compare different  
            model search algorithms experimentally,
            and show that random search is outperformed 
            by 
            algorithms that leverage the 
            structure of the search space to
            generalize more effectively across different models.
        \end{enumerate}
\end{enumerate}


The main differences between our work and previous work are that we 
develop a modular, composable and extensible language, 
focusing on the problem of searching over deep architectures. 
This focus allows the expert to compactly set up a search space, 
search over it, 
and automatically compile models 
to their corresponding computational graphs.
Our language can be seen as an effort to combine the functionalities of
a deep model specification language 
(e.g., Tensorflow~\cite{abadi2016tensorflow}) and 
a structured hyperparameter search language 
(e.g., Hyperopt~\cite{bergstra13modelsearch}).









\section{Related Work}
\label{sec:related_work}




Model search has a long and rich history in machine learning and statistics. 
There has been a wide variety of theoretical and empirical research
in this area~\cite{agarwal2011oracle,bergstra11hyperparameter,bergstra12randomSearch,sabharwal2015selecting},
including Bayesian optimization methods~\cite{hutter2011sequential,kandasamy15addBO,snoek12practicalBO}.
However, conventional methods are primarily designed for searching over
hyperparameters living in Euclidean space.
Such methods are ill suited in today's context, 
where 
the discrete architectural choices are 
just as important
as the numerical values of the hyperparameters.
Searching over architectures using current hyperparameter optimization 
algorithms requires 
the expert to distill structural choices into 
scalar hyperparameters.
As a result, typically only a few simple global 
structural hyperparameters are considered,
e.g., the depth of the network or whether to use dropout or not.
This constrains the richness of the search space, 
preventing the expert from finding 
unexpected model variations 
leading to better performance; e.g., 
perhaps dropout is useful only after certain types of layers, or 
batch normalization only helps in the first half of the network. 

Architecture search 
has also been considered under 
the topic of neuroevolution~\cite{stanley2002evolving}, 
which uses evolutionary (i.e., genetic) strategies 
to define and search a space of models.
In classical approaches, neuroevolution attempts to 
jointly choose 
the topology and the parameters of the architecture  
using genetic algorithms. 


Architecture search has received renewed interest recently.
Wierstra \etal
\cite{wierstra2005modeling}, 
Floreano \etal \cite{floreano2008neuroevolution},
and Real \etal \cite{large2017real} 
use evolutionary
algorithms which start from an initial model and 
evolve it based on its validation performance.
Zoph and Le \cite{zoph2016neural} 
propose a reinforcement learning procedure 
based on policy gradient 
for searching for 
convolutional and 
LSTM architectures.
Baker \etal \cite{baker2016designing} 
propose a reinforcement learning procedure 
based on Q-learning 
for searching for 
convolutional architectures. 

Unfortunately all these approaches consider 
fixed hard-coded model search spaces
that do not easily allow the 
human expert to incorporate inductive biases 
about the task being solved, making them unsuitable 
as general tools for architecture search.
For example, evolutionary approaches require 
an encoding for the models in the search space
and genetic operators (e.g., mutation and crossover)
which generate encodings for new models out of 
encodings of old ones.
These aspects are handcrafted and hard-coded
so it is hard for the human expert to 
change the search space in flexible ways.
Perhaps 
different model encodings
or genetic operators can be considered, 
but these knobs give somewhat loose and indirect control over the 
model search space.
The reinforcement learning approaches considered 
suffer from similar issues---the 
search spaces are hard-coded and not easily modifiable. 
None of these approaches have
the compositionality, modularity, and extensibility properties 
of our language.

Bergstra \etal \cite{bergstra11hyperparameter} propose
Tree of Parzen Estimators (TPE), which 
can be used to search over structured hyperparameter spaces, 
and use it to tune the hyperparameters of a Deep Boltzmann Machine.
Bergstra \etal \cite{bergstra13modelsearch} use
TPE to search for values of the hyperparameters 
of a computer vision system, 
and show that it can find better values 
than the best ones previously known.


TPE 
is a general 
hyperparameter search algorithm, 
and therefore requires considerable effort to use---for 
any fixed model search space, using TPE requires 
the human expert to distill the hyperparameters 
of the search space, 
express the search space in Hyperopt~\cite{bergstra13modelsearch}
(an implementation of TPE), and write the code describing 
how values of the hyperparameters in the search space 
compile to a computational graph.
In contrast, our language is modular and composable in 
the sense that: 
\begin{enumerate}
    \item search spaces (defined through modules) 
are constructed compositionally out of 
simpler search spaces (i.e., simpler modules); 
    \item hyperparameters for 
    composite modules are derived automatically 
    from the hyperparameters of simpler modules; 
    \item once values for all hyperparameters of a module have been chosen, 
    the resulting model can be automatically mapped 
to a computational 
    graph without the human expert having to 
    write additional code.
\end{enumerate}

















\section{Roadmap to the DeepArchitect Framework}
\label{sec:roadmap}






Our framework
reduces the problem of searching over models into 
three modular components:
the \emph{model search space specification language}, 
the \emph{model search algorithm}, 
and the \emph{model evaluation algorithm}.


\paragraph{Model Search Specification Language:}
The model search space specification language is built around the concept of a 
modular \emph{computational module}.
This is akin to the concept of a module~\cite{bottou1991framework}
used in deep learning frameworks such as Torch~\cite{torch}:
by implementing the module interface,  
the internal implementation becomes irrelevant.
These modules allow one to 
express easily complex design choices such as 
whether to include a module or not, 
choose between modules of different types, 
or choose how many times to repeat a module structure.
The main insight is that 
complex modules can be created \emph{compositionally} out of simpler ones.
The behavior of complex modules
is generated automatically out of the behavior of
simpler modules. 
Furthermore, our language is extensible, 
allowing the implementation of new types of modules 
by implementing a high-level interface 
local to the module.


\paragraph{Model Search Algorithm:}
The way the model search space is explored is determined by 
the \emph{model search algorithm}. 
This part of the framework decides 
how much effort to allocate to each part 
of the search space based on 
the performance observed for previous models.
The model search algorithm typically requires a
\emph{model evaluation algorithm} that 
computes the performance of a fully specified model.
The search algorithm will then use this information to determine 
which models to try next.
The search algorithm interacts with the search space only through a 
minimal interface that allows it to traverse the space of models
and evaluate models discovered this way.
This interface is the same irrespective of the specific 
search space under consideration.
We experiment with 
different search algorithms,
such as
Monte Carlo tree search~\cite{browne2012survey} and 
Sequential Model Based Optimization~\cite{hutter2011sequential}.

\paragraph{Model Evaluation Algorithm:}
Having fully specified a model, i.e., having reached a leaf in the 
tree defined by our model search space, we can evaluate how good this model is  
according to some criterion defined by the expert.
This typically involves training the model on a training set and 
evaluating it on a validation set.
The training procedure often has multiple hyperparameters that can 
be tuned
(e.g., the choice of the 
optimization algorithm and 
its hyperparameters, 
and the learning rate schedule).
If the expert does not know how to 
write down a reasonable training procedure 
for every model in the search space,
the expert can introduce hyperparameters for the evaluation algorithm 
and search over them  
using our specification language.






\paragraph{}
Any of the above components 
can be changed, improved, or extended,
while keeping the others fixed. 
The fact that different components interact only through 
well-defined interfaces makes it possible to 
extend and reuse this framework. 
We believe that DeepArchitect will be an interesting platform 
for future research in deep learning and 
hyperparameter tuning 
for architecture search.











\section{Model Search Space Specification Language}
\label{sec:model_space_spec_lang}
\subsection{Search Space Definition}
\label{ssec:space_spec}





The \emph{computational module} is the fundamental unit 
of our model search space specification language.
We define a computational module as a function 
\begin{equation}
f : n \to 
    \left( \mathcal H \to ( \mathbb R ^p  \to (\mathbb R ^{n} \to \mathbb R ^{m} ) )
    \right),
\label{eq:module_def}
\end{equation}
where
$n$ is the dimensionality of the \emph{input},
$\mathcal H$ is the set of valid values for the \emph{hyperparameters},
$p$ is the number of \emph{parameters}, and 
$m$ is the dimensionality of the \emph{output}.
The set
$\mathcal H$ can be structured
or simply the cross product of scalar hyperparameter sets,
i.e., $\mathcal H = \mathcal H _1 \times \ldots \times \mathcal H _H$,
where $H$ is the number of scalar hyperparameters.
The set $\mathcal H$ is assumed to be discrete in both cases. 



Definition~\eqref{eq:module_def} merits some discussion. 
For conciseness 
we have not explicitly represented it, but 
\emph{the number of parameters $p$ and 
the output dimensionality $m$
can both be
functions of  
the input dimensionality $n$ 
and the chosen hyperparameter values $h \in \mathcal H$}.
For example, an affine module
with
$h$ dense hidden units
has output dimensionality $m = h$
and number of parameters 
$p = (n + 1) h$:  
 a 
weight matrix $W \in \mathbb R ^{h \times n}$
and a bias vector $b \in \mathbb R ^h$.
A similar reasoning can be carried out 
for a convolutional module:
the number of parameters
$p$ depends on 
the input dimensionality, 
the number of filters, 
and the size of the filters;
the dimensionality of the output $m$ depends on 
the input dimensionality,
the number of filters, 
the size of the filters,
the stride, 
and the padding scheme.
The fact that $p$ and $m$ are functions of
the input dimensionality
and the chosen hyperparameter values
is one of the main observations  
that allows us to do architecture search---\emph{once we 
know the input dimensionality and
have fixed values for the hyperparameters,
the structure of the computation 
performed by the module is determined},  
and this information can be propagated to other modules.
We say that a module is \emph{fully specified}
when values for all hyperparameters of the module 
have been chosen and the input dimensionality is known. 

We focus
on search spaces for architectures that have 
a \emph{single input terminal} and 
a \emph{single output terminal}.
By this, we only mean that the input and output of the 
module have to be a \emph{single} tensor of arbitrary order and dimensionality.
For example, convolutional modules take as input 
an order three tensor and 
return as output 
an order three tensor,
therefore they are
single-input single-output modules
under our definition.
We also assume that the output of a module 
is used as input to at most a single module, i.e., 
we \emph{assume no output sharing}.


These restrictions were introduced to 
simplify exposition. 
The single-input single-output case
with no sharing is simpler to develop 
and exemplifies the main ideas that 
allow us to develop a framework for automatic architecture search.
The ideas developed in this work extend naturally 
to the multiple-input multiple-output case with sharing.
Additionally, often 
we can represent modules that 
are not single-input single-output
by defining 
new modules that encapsulate many signal paths 
from input to output.
For example, a residual module~\cite{he2016deep}
can be treated in our framework 
by noting that it is single-input before 
the skip connection split
and single-output after 
the skip connection merge.
Many top performing architectures,
such as 
AlexNet~\cite{krizhevsky2012imagenet}, 
VGG~\cite{simonyan2014very}, and 
ResNet~\cite{he2016deep},
are captured in our language.




We distinguish between 
\emph{basic computational modules} and
\emph{composite computational modules}.
Basic modules 
do some well defined transformation. 
Affine, batch normalization, and dropout are examples of basic modules.
Composite modules are defined in terms of other (composite or basic) modules,
i.e., the instantiation of a composite module 
takes other modules as arguments. 
Composite modules may introduce 
hyperparameters of their own 
and inherit hyperparameters of 
the modules taken as arguments.
For example, an \texttt{Or} module 
takes a list of modules and 
chooses one of the modules
to use.
It
introduces a discrete hyperparameter 
for 
which module to use, 
and chooses values for the 
hyperparameters of the chosen module;
the hyperparameters available are conditional on
the choice of the module to use.
Most of the representational power of our language 
arises from the compositionality 
of composite and basic modules.

The ideas developed in this section are perhaps 
best illustrated with an example.
See Figure~\ref{fig:ss_program_ex} for 
the definition of an example search space
in LISP-like pseudocode that closely parallels our implementation.
The search space,
which results from the composition of several modules,
and therefore is also a module itself, 
encodes $24$ different models, corresponding 
to the different $24$ possible paths 
from the root to the leaves of the tree.
The space is defined using three composite modules 
(\texttt{Concat}, \texttt{MaybeSwap}, and \texttt{Optional})
and five basic modules 
(\texttt{Conv2D}, \texttt{BatchNormalization}, \texttt{ReLU}, \texttt{Dropout},
and \texttt{Affine}).
\texttt{Concat} introduces no additional hyperparameters, 
but it has to specify all the modules that have been delegated to it;
\texttt{MaybeSwap} introduces a binary hyperparameter that encodes 
whether to swap the order of the pair of modules or not;
\texttt{Optional} introduces a binary hyperparameter that encodes 
whether to include the module or not.
The behavior of the basic modules in Figure~\ref{fig:ss_program_ex} 
is relatively straightforward:
\texttt{Conv2D} takes lists of possible values for
the number of filters,
the size of the filters, and 
the stride;
\texttt{BatchNormalization} and \texttt{ReLU} 
have no hyperparameters;
\texttt{Dropout} takes a list for the possible values for 
the dropout probability;
\texttt{Affine} takes a list for the possible values of 
the number of hidden units.
\begin{figure}[t]
{\raggedleft 
\begin{verbatim}
(Concat 
    (Conv2D [32, 64] [3, 5] [1])
    (MaybeSwap BatchNormalization ReLU)
    (Optional (Dropout [0.5, 0.9]))
    (Affine [10]))
\end{verbatim} 
}
\caption{A simple search space with $24$ different models. 
    See Figure~\ref{fig:ss_tree_ex} for
    a path through the search space.}
\label{fig:ss_program_ex}
\end{figure}

Choosing different values for the hyperparameters 
of the composite modules may
affect the structure of the resulting architecture,
while choosing different values for the hyperparameters
of the basic modules 
only affects the structure of the corresponding local transformations.
The search space of Figure~\ref{fig:ss_program_ex} results 
from the composition of basic and composite modules;
therefore it is a module itself and 
can be characterized by its 
input, 
output, 
parameters, 
and hyperparameters.
Our set of composite modules in not minimal: 
e.g., 
given an 
\texttt{Empty} basic module, 
which 
has no hyperparameters or parameters and 
simply does the identity transformation,  
and a 
\texttt{Or} composite module,
which introduces an extra hyperparameter
encoding the choice of a specific module in its list, 
the composite modules 
\texttt{Optional} and \texttt{MaybeSwap} can be defined
as
\texttt{(Optional B) = (Or Empty B)}
and 
\texttt{(MaybeSwap B1 B2) = (Or (Concat B1 B2), (Concat B2 B1))}.


\subsection{Search Space Traversal}
\label{ssec:traversal}

Given a search space defined by a module, 
there is an underlying tree over fully specified models:
we build this tree by 
sequentially 
assigning values to each of the 
hyperparameters of the module.
Each internal node in the tree corresponds to some partial 
assignment to the hyperparameters of the module,
and each terminal node (i.e., each leaf) 
corresponds to a fully specified model.
We can also think about an internal node as corresponding to 
the state of a module 
before assigning a value to the next unassigned hyperparameter. 
The branching factor of a node corresponds to the number 
of possible values for the hyperparameter under consideration
at that node, 
and traversing a specific edge from that node to a child corresponds 
to assigning the value encoded by that edge to the 
hyperparameter under consideration.
As a tree has a single path between the root and any leaf, 
the paths from root to leaves are in one-to-one correspondence 
with fully specified models.
A leaf is reached when there are no hyperparameters left to specify. 


\begin{figure}[t]
\centering
\begin{forest}
for tree={l sep=15pt, s sep=40pt, thick}
[0,circle,draw, minimum size = 8mm, 
    [ $\vdots$ ]
    [1,circle, draw, minimum size = 8mm, 
        edge label={ node[midway,above right] {64} } 
        [2, circle, draw, minimum size = 8mm, 
            edge label={ node[midway,above left] {3} } 
            [3,circle, draw, minimum size = 8mm,
                edge label={ node[midway,above left] {BR} }  
                [4,circle, draw, minimum size = 8mm,
                    edge label={ node[midway,above left] {NoD} } ]
                [ $\vdots$ ]    
            ]
            [ $\vdots$ ]
        ]
        [ $\vdots$ ]
    ]
]
\end{forest}
\caption{A path through the 
 search space
of Figure~\ref{fig:ss_program_ex}.
The model encoded by this path has a 
convolutional module with 
$64$ filters of
size $3\times 3$, with stride $1$, 
followed by batch normalization, ReLU and affine modules.
The model does not use dropout. 
Branches encoding hyperparameters with a single choice were omitted. 
}
\label{fig:ss_tree_ex}
\end{figure}


In Figure~\ref{fig:ss_tree_ex} we have drawn a path through the 
search space of  
Figure~\ref{fig:ss_program_ex}
from the 
root (labeled node $0$), 
where all hyperparameters are unassigned,
to a terminal node (labeled node $4$), 
where all hyperparameters have been assigned values.
Each branch in the tree corresponds to the assignment of some 
value to some hyperparameter.
At node $0$, 
we are choosing between 
$32$ or $64$ filters;
at node $1$, 
we are choosing between 
filters of size $3$ or $5$;
at node $2$, we are choosing between  
applying batch normalization 
before or after ReLU;
at node $3$, we are choosing 
whether to do dropout or not.
Node $4$ is terminal and corresponds to 
a fully specified model.
Decisions at each node are conditional on 
decisions previously made.
Internal nodes with a single child
(i.e., branches for hyperparameters with a single possible value)
have been collapsed and omitted from Figure~\ref{fig:ss_program_ex}.
Other paths may have different lengths, e.g., 
picking a path through the right child of node $3$ 
corresponds to adding a \texttt{Dropout} module, 
which requires an additional hyperparameter choice for 
the dropout probability
when compared to the path from the root to node $4$. 

Search spaces arising from module composition 
have their traversal functionality 
automatically derived from the traversal 
functionality of their component modules:
a basic module knows how to 
sequentially assign values to its hyperparameters,
and a composite module knows how to 
sequentially assign values to its hyperparameters and  
call the sequential assignment functionality for its component modules.
This behavior is akin to recursive expression evaluation in programming languages.

To traverse the search space, 
i.e., to assign values to all hyperparameters 
of the module defining the 
search space, 
all that it is needed is that each module knows how to 
sequentially specify itself.
\emph{Modules resulting from the composition of modules will then be 
automatically sequentially specifiable}.
The three \emph{local} operations that a module 
needs to implement for traversal are:
\emph{to test whether it is fully specified}
(i.e., whether it has reached a leaf yet);
if it is not specified, 
\emph{to return which hyperparameter it is specifying and what are the 
possible values for it};
and given a choice for 
the current hyperparameter under consideration, 
\emph{to traverse the edge to the child of the current node 
corresponding to chosen value}.


\subsection{Compilation}
\label{ssec:compilation}

Once values for 
all hyperparameters of a module have been chosen, 
the 
fully specified model
can be
automatically 
mapped to its 
corresponding
\emph{computational graph}. 
We call this mapping
\emph{compilation}.
This operation only requires that each module knows how to locally map 
itself to a computational graph: compilation is derived recursively 
from the compilation of simpler modules.
For example, if we know how to compile 
\texttt{Conv2D}, \texttt{ReLU}, and \texttt{Or} modules, 
we will automatically be able to compile
all modules built from them.
This behavior is also similar 
to recursive expression evaluation in 
programming languages.














































\section{Model Search Algorithms}
\label{sec:model_search}

In this section, we consider different search algorithms that 
are built on top of the functionality described above.
Some of these algorithms rely on the fact that the search space is 
tree structured.
One of the challenges of our setting is that deep models are expensive to 
train, so unless we have access to extraordinary computational resources, 
only a moderate number of evaluations 
will be practical.




















\subsection{Random Search}
\label{ssec:rand_search}

Random search is the simplest algorithm that we can consider. 
At each node of the tree, we choose 
an outgoing edge uniformly at random,  
until we reach a leaf node (i.e., a model).
Even just random search is interesting,
as 
the model search space specification language allows us to 
capture expressive structural search spaces. 
Without our language, 
randomly selecting an interesting architecture to 
try would not be possible
without considerable effort from the human expert.

\subsection{Monte Carlo Tree Search}
\label{ssec:mcts_search}

Monte Carlo tree search (MCTS)~\cite{browne2012survey, kocsis2006bandit}
is an approximate planning technique that has been used 
effectively in many domains~\cite{silver2016mastering}.
Contrary to random search, MCTS uses the information gathered so far
to steer its policy towards better performing parts of the 
search space.
MCTS maintains a search tree that is  
expanded incrementally one node at a time.
MCTS uses two policies: 
a \emph{tree policy}, 
which determines 
the path to be traversed from the root 
to the frontier
of the already expanded tree; and
a \emph{rollout policy}, 
which determines
the path to be traversed from the frontier
of the already expanded tree 
until a leaf is reached.
Once a leaf is reached, the model encoded by it is 
evaluated 
(e.g., trained on the training set and 
evaluated on the validation set), 
and the resulting score is used to update the statistics of the 
nodes 
in the currently expanded tree 
in the path to the leaf.
Each node in the expanded tree keeps statistics 
about the number of times it was visited and the
average score of the models that were evaluated in the 
subtree at that node.
The rollout policy is often simple, e.g., 
the random policy described in Section~\ref{ssec:rand_search}.

The tree policy typically uses an
upper confidence bound (UCB)
approach. 
Let $n$ be the number of visits of a node $v \in \mathcal T$,
where $\mathcal T$ denotes the currently expanded tree, and 
$n _1, \ldots, n _b$ and 
$\bar X _1, \ldots, \bar X  _b$ be, respectively, 
the number of visits and 
the average scores of the $b$ children of $v$.
The tree policy at $x$ chooses to traverse 
an edge corresponding to a child maximizing the UCB score:
\begin{align}
    \max _{i \in \{1, \ldots, b \} } 
        \bar X _i + 
            2 c 
                \sqrt
                    { \frac {2 \log n } 
                    { n _i }},
\end{align}
where $c \in \mathbb R _+$ is a 
constant capturing the trade-off between 
exploration and exploitation---larger 
values of $c$ correspond to 
larger amounts of exploration.
If at node $x$, some of its children 
have not been added to the tree, there will be some 
$i \in \{1, \ldots, b \} $ for which $n _i = 0$;
in this case we define the UCB score to be infinite, 
and therefore, unexpanded children
always take precedence over 
expanded children.
If multiple unexpanded children are available, 
we expand one uniformly at random.


\subsection{Monte Carlo Tree Search with Tree Restructuring}
\label{ssec:restruct_mcts_search}

When MCTS visits 
a node in the expanded part of 
the tree, 
it has to expand all children of that node before 
expanding any children of its currently expanded children. 
This is undesirable 
when there are hyperparameters 
that can take a 
large number of related values.

We often consider
hyperparameters which take \emph{numeric} values,
and  
similar values result in similar performance.
For example, choosing between
$64$ or $80$ filters for a convolutional module 
might not have a dramatic impact 
on performance. 

A way of addressing such hyperparameters
is to restructure the branches of the 
tree by doing bisection.
Assume that the set of hyperparameters has 
a natural ordering.
At a node, 
rather than committing directly 
to a value of the 
hyperparameter, 
we commit sequentially---first we decide 
if we are choosing a value in the 
first or second half of the set of 
hyperparameters, 
and then we recurse on the chosen half
until we have narrow it down to a single value.
See an example tree in Figure~\ref{fig:tree_branch} and 
the corresponding 
restructured tree in Figure~\ref{fig:tree_bisect}.
\begin{figure}[thb]
\centering
\begin{forest}
for tree={l sep=16pt, s sep=16pt, thick}
[0,circle,draw, minimum size = 8mm, 
    [1,circle, draw, minimum size = 8mm,
        edge label={ node[midway,left] {16} } ]
    [2,circle, draw, minimum size = 8mm,
        edge label={ node[midway,left] {32} } ]
    [3,circle, draw, minimum size = 8mm,
        edge label={ node[midway,left] {48} } ]
    [4,circle, draw, minimum size = 8mm,
        edge label={ node[midway,right] {64} } ]
    [5,circle, draw, minimum size = 8mm,
        edge label={ node[midway,right] {80} } ]
]
\end{forest}
\caption{A tree encoding an hyperparameter and its five possible values.
MCTS applied to this tree is sample-inefficient 
as there is no sharing 
of information between the different child nodes. 
See also Figure~\ref{fig:tree_bisect}.
}
\label{fig:tree_branch}
\end{figure}


\begin{figure}[thb]
\centering
\begin{forest}
for tree={l sep=16pt, s sep=16pt, thick}
[0,circle,draw, minimum size = 8mm, 
    [,circle, draw, minimum size = 8mm,
            edge label={ node[midway,left] {[16, 32, 48]} }  
        [,circle, draw, minimum size = 8mm,
            edge label={ node[midway,left] {[16, 32]} } 
            [1,circle, draw, minimum size = 8mm,
                edge label={ node[midway,left] {16} } ]  
            [2,circle, draw, minimum size = 8mm,
                edge label={ node[midway,right] {32} } ]    
        ]
        [3,circle, draw, minimum size = 8mm,
            edge label={ node[midway,right] {48} } ]
    ]
    [,circle, draw, minimum size = 8mm,
            edge label={ node[midway,right] {[64, 80]} }  
        [4,circle, draw, minimum size = 8mm,
            edge label={ node[midway,left] {64} } ]
        [5,circle, draw, minimum size = 8mm,
            edge label={ node[midway,right] {80} } ]
    ]
]
\end{forest}
\caption{The result of restructuring the tree 
in Figure~\ref{fig:tree_branch} with bisection.
MCTS applied to this tree results in more sharing when compared to the 
original tree. 
For example, sampling a path reaching node~$1$ provides information about 
nodes~$1$, $2$, and $3$.
}
\label{fig:tree_bisect}
\end{figure}

Tree restructuring involves a tradeoff between depth and breadth: 
the tree in Figure~\ref{fig:tree_branch} has depth $1$, 
while the tree in Figure~\ref{fig:tree_bisect} has depth $3$.
The restructured tree can have better properties in the sense that 
there more sharing between different values of the 
hyperparameters.
We could also consider restructured trees with 
branching factors different than two,
again trading off  
depth and breadth.
If the branching factor of the restructured tree 
is larger than the number of children of the hyperparameter, 
the restructuring has no effect, i.e., 
the original and restructured trees are equal.
The restructuring operation allows MCTS 
to \emph{effectively consider
hyperparameters with a large number of possible values}.

\subsection{Sequential Model Based Optimization}
\label{ssec:smbo_search}

MCTS is tabular in the sense that 
it keeps statistics for each node in the tree.
While the restructuring operation described 
in Section~\ref{ssec:restruct_mcts_search}
increases sharing between different hyperparameter 
values, it still suffers from the problem that 
nodes have no way of 
sharing information other than through 
common ancestors.
This is problematic because differences in hyperparameter 
values at the top levels of the tree lead to little sharing between
models, even if the resulting models happen to 
be very similar.

Sequential Model Based Optimization (SMBO)~\cite{hutter2011sequential} 
allows us to address 
this problem by introducing a surrogate function which can 
be used to capture relationships between models 
and how 
promising it is to evaluate any specific model.
The surrogate function can use expressive 
features to 
capture architecture patterns that influence performance, 
e.g., features about sequences of 
basic modules that occur in the model.

The surrogate function can then be optimized to choose
which model to evaluate next.
    Exactly optimizing the surrogate function over a search space
can be difficult 
as often 
there is a combinatorially large number 
of models. 
To approximately optimize the surrogate function, we 
do some number of random rollouts from the root of the tree 
until we hit leaf nodes (i.e., models), 
we evaluate the surrogate function (i.e., we determine, according to the
surrogate function, how promising it is to evaluate that model), 
and evaluate the model that has the highest score according to the 
surrogate function.
We also introduce an exploratory component
where we flip a biased coin 
and choose between evaluating a random model
or evaluating the
best model according to the surrogate function.
The surrogate function is updated after each evaluation.

In our experiments, we use a simple surrogate function:
we train a ridge regressor to
predict model performance, 
using the models evaluated so far 
and their corresponding performances
as training data.
We only use features based on $n$-grams of sequences of 
basic modules,
disregarding the values of the hyperparameters.
More complex features, surrogate functions, and training losses 
are likely to lead to better search performance, 
but we leave these to future work.



\begin{figure*}[htp]
    \centering
\includegraphics[width=.32\linewidth]{searcher_comp_1_to_64.pdf}
    \includegraphics[width=0.32\linewidth]{searcher_comp_1_to_16.pdf}
    \includegraphics[width=0.32\linewidth]{searcher_comp_16_to_64.pdf}
\caption{Average maximum validation score achieved as a function of the number of 
        evaluation across five repetitions. The error bars indicate standard error.
        The two plots on the right have the same results as the plot on the left, 
        but are zoomed in for better visualization. }
    \label{fig:searcher_comp}
\end{figure*}



\section{Model Evaluation Algorithms}
\label{sec:model_eval}

As a reminder, once we assign values to all hyperparameters of the module 
defining the search space, 
we need to compute a score for the resulting model, 
i.e., a score for the path from the root to the corresponding leaf
encoding the model to evaluate.
The specific way to 
compute scores
is defined by the human expert,
and it typically amounts to training the model on 
a training set and evaluating the trained model on a validation set.
The score of the model is 
the resulting validation performance.
The training process often has its own hyperparameters, 
such as: 
what optimization algorithm to use and 
its corresponding hyperparameters,
the learning rate schedule 
(e.g., the initial learning rate,
the learning rate reduction multiplier, 
and how many epochs 
without improving 
the validation performance 
the algorithm waits 
before reducing the learning rate),
how many epochs without improving the validation performance
the algorithm waits before terminating 
the training process 
(i.e., early stopping), and
what 
data augmentation strategies to use and 
their corresponding hyperparameters.
The behavior of the evaluation algorithm 
with respect to the values of 
its hyperparameters is defined by the expert for the task being considered, 
so the compilation step described in Section~\ref{ssec:compilation}
for this functionality has to 
be implemented by the expert.
Nonetheless, these \emph{user hyperparameters} can be 
included in the search space and searched over in the same way as 
the architecture hyperparameters
described in Section~\ref{ssec:space_spec}.

\section{Experiments}
\label{sec:experiments}







We illustrate how our framework can be used to 
search over all hyperparameters of a model, 
i.e., both architecture and training hyperparameters, 
using only high-level insights.
We choose a search space  
of deep convolutional models
based around the 
ideas that 
depth is important, 
batch normalization helps convergence, 
and dropout is sometimes helpful.
We search over architectures and 
evaluate our models on CIFAR-10~\cite{krizhevsky2009learning}.



The training hyperparameters that we consider are
whether to use ADAM or SGD with momentum,
the initial learning rate, 
the learning rate reduction multiplier, and
the rate reduction patience, i.e., 
how many epochs without improvement to wait before reducing the 
current learning rate. 
We use standard data augmentation techniques:  
we zero pad the CIFAR-10 images 
to size $40 \times 40 \times 3$, 
randomly crop a $32 \times 32 \time 3$ portion, 
and flip horizontally at random.
We could search over these too if desired.

We compare the search algorithms described in 
Section~\ref{sec:model_search} in terms of the best model found,
according to validation performance, as a function of the 
number of evaluations. 
We run each algorithm 
$5$ times, for $64$ model evaluations each time. 
All models were trained for $30$ minutes on GeForce GTX 970
GPUs in machines with similar specifications.

On the leftmost plot of Figure~\ref{fig:searcher_comp}, 
we see that all search algorithms find 
performant solutions (around $89\%$ accuracy) after $64$ evaluations.
On the center plot of Figure~\ref{fig:searcher_comp}, we see that  
for fewer than $6$ evaluations there is considerable 
variance between the different algorithms; the more sophisticated 
model search algorithms 
are not able to outperform random search with so few evaluations. 
On the rightmost plot in Figure~\ref{fig:searcher_comp}, we see that 
both SMBO and MCTS with bisection eventually outperform random search; 
MCTS with bisection starts outperforming random search around $32$ evaluations, 
while for SMBO, it happens around $16$ evaluations.

\begin{figure}[tp]
    \centering
    \includegraphics[width=0.9\columnwidth]{quants.pdf}
    \caption{Percentage of models above a given validation threshold performance.
        MCTS with bisection and SMBO outperform random search.
        when compared to random search. 
        The error bars have size equal to the standard error.}
    \label{fig:quants}
\end{figure}

Surprisingly, MCTS without restructuring 
does not outperform random search. 
We think that this is because there are too many possible values for the
first few hyperparameters in the tree, so MCTS 
will not be able to 
identify and focus on high-performance regions of the search space 
within the number of evaluations available.
MCTS with bisection and SMBO do not suffer from these problems, and therefore
can identify and focus on 
high performance regions of the search space earlier.
In addition to achieving a higher top accuracy,
MCTS with bisection and 
SMBO evaluate a larger fraction of high-performance models when compared to 
random search, which can be seen in 
Figure~\ref{fig:quants}.










There is a significant number of models that
fail to train 
for the particular search space 
that we considered, i.e., 
the classification performance in the validation set 
fails to be better than random.
This is seen in 
Figure~\ref{fig:quants} by the large drop in the fraction of models 
that outperform $10 \%$ accuracy.
This observation is in accordance with the knowledge that very 
deep convolutional architectures are hard to train.
Additionally, 
in Figure~\ref{fig:quants}
we see that models 
have large variability in terms of 
the performance that they achieve in $30$ minutes of 
training. 
This is a desirable aspect of our model search specification 
language as it shows that it can represent  
expressive search spaces with models achieving 
significantly different performances.



\section{Conclusion}
\label{sec:conclusion}

We described
a framework for automatically 
designing and training deep models.
    This framework consists of three fundamental components: 
the model search space specification language, 
the model search algorithm, and 
the model evaluation algorithm.    
    The model search space specification language is composable, modular, 
and extensible, and allows us to easily define expressive search spaces 
over architectures.
The model evaluation algorithm determines how to compute a score for a model  
in the search space.
Models can be automatically compiled to their corresponding computational graphs.
Using the model search space specification language and the model evaluation algorithm, 
we can introduce model search algorithms for exploring the 
search space.
Using our framework, it is possible to do random search 
over interesting spaces of architectures
without much effort from the expert.
We also described more complex model search algorithms, such as 
MCTS, MCTS with tree restructuring, and SMBO.
We present experiments on CIFAR-10 comparing 
different model search algorithms and 
show that MCTS with tree restructuring and SMBO outperform 
random search.
Code for our framework and experiments 
has been made publicly available.
We hope that this paper will lead to more work and better tools for 
automatic architecture search.





\section*{Acknowledgements}

The authors would like to thank Matt Gormley, Matt Barnes, Christoph Dann, 
and Kirthevasan Kandasamy
for helpful discussions and detailed comments on 
early versions of the manuscript.

{\small
\bibliographystyle{ieee}
\bibliography{egbib_clean}
}

\clearpage
\appendix

\section{Detailed Experimental Setup}
\label{sec:detailed_exps}

In 
Section~\ref{sec:experiments}, 
we considered a search space of 
deep convolutional models having
structural hyperparameters 
for 
the depth of the network,
whether to apply batch normalization before or after 
ReLU, and 
whether to use dropout;
hyperparameters for the 
number and size of the convolutional filters; 
training hyperparameters for the learning rate schedule.
    We show in 
Figure~\ref{fig:ss_experiments_lisp} 
the LISP-like pseudocode for
the search space considered in Section~\ref{sec:experiments},
and in Figure~\ref{fig:ss_experiments_python}
the corresponding runnable Python implementation in our framework.


\begin{figure}[htp]
\raggedleft{ 
{\tiny
\begin{verbatim}
MH = (UserHyperparams 
        { 'optimizer_type' : ['adam', 'sgd'],
          'learning_rate_init' : logspace(10^-2, 10^-7, 32),
          'rate_mult' : logspace(10-2, 0.9, 8), 
          'rate_patience' : [4, 8, 12, 16, 20, 24, 28, 32],
          'stop_patience' : [64],
          'learning_rate_min' : [10^-9] })

M1 = (Conv2D [48, 64, 80, 96, 112, 128] [3, 5, 7] [2])

M2 = (RepeatTied 
        (Concat
            (Conv2D [48, 64, 80, 96, 112, 128] [3, 5] [1])  
            (MaybeSwap BatchNormalization ReLU)
            (Optional (Dropout [0.5, 0.9])))
        [1, 2, 4, 8, 16, 32])

M = (Concat MH M1 M2 M1 M2 (Affine [10])) 
\end{verbatim} } } 
\caption{Specification of the model search space used 
in Section~\ref{sec:experiments}
in LISP-like pseudocode. 
See Figure~\ref{fig:ss_experiments_python}
for the corresponding runnable Python code. }
\label{fig:ss_experiments_lisp}
\end{figure}

\begin{figure}[htp]
\raggedleft{ 
{\tiny
\begin{verbatim}
MH = UserHyperparams(['optimizer_type',
                      'learning_rate_init',
                      'rate_mult',
                      'rate_patience', 
                      'stop_patience', 
                      'learning_rate_min' ],
                      [['adam', 'sgd_mom'], 
                      list( np.logspace(-2, -7, num=32) ), 
                      list( np.logspace(-2, np.log10(0.9), num=8) ),
                      range(4, 33, 4), 
                      [64], 
                      [1e-9] ])

conv_initers = [ kaiming2015delving_initializer_conv(1.0) ]
aff_initers = [ xavier_initializer_affine( 1.0 )]

def Module_fn(filter_ns, filter_ls, keep_ps, repeat_ns):
    b = RepeatTied(
            Concat([
                Conv2D(filter_ns, filter_ls, [1], ["SAME"], conv_initers),
                MaybeSwap_fn( ReLU(), BatchNormalization() ),
                Optional_fn( Dropout(keep_ps) )
        ]), repeat_ns)
    return b

filter_nums = range(48, 129, 16)
repeat_nums = [2 ** i for i in xrange(6)]
mult_fn = lambda ls, alpha: list(alpha * np.array(ls))

M = Concat([MH,
            Conv2D(filter_nums, [3, 5, 7], [2], ["SAME"], conv_initers), 
            Module_fn(filter_nums, [3, 5], [0.5, 0.9], repeat_nums),
            Conv2D(filter_nums, [3, 5, 7], [2], ["SAME"], conv_initers),
            Module_fn(mult_fn(filter_nums, 2), [3, 5], [0.5, 0.9], repeat_nums),
            Affine([num_classes], aff_initers) ])
\end{verbatim} } }  
\caption{Runnable specification of the model search space used in 
Section~\ref{sec:experiments} in our Python implementation of the framework. 
See Figure~\ref{fig:ss_experiments_lisp} for the specification of the 
same search space in the LISP-like pseudocode 
used throughout this paper.}
\label{fig:ss_experiments_python}
\end{figure}

In Figure~\ref{fig:ss_experiments_lisp} 
and Figure~\ref{fig:ss_experiments_python},
to include training hyperparameters in the search space, 
we concatenate
the module that encapsulates the training hyperparameters 
(the module assigned to \texttt{MH}) 
and the modules that encapsulate the 
remaining model hyperparameters 
(the modules other than \texttt{MH} 
in the declaration of \texttt{M}).

The Python specification 
of the model search space
in Figure~\ref{fig:ss_experiments_python} is remarkably close in both 
semantics and length 
to the LISP-like pseudocode in Figure~\ref{fig:ss_experiments_lisp}.
We omit some hyperparameters in Figure~\ref{fig:ss_experiments_lisp}
because we did not consider multiple values for them, e.g., 
for \texttt{Conv2D} modules, we always used 
same size padding
and the
initialization scheme described in He \etal~\cite{he2015delving}.

Our implementation has code modularity and reusability benefits.
For example, 
we can define an auxiliary function to instantiate modules and then 
use it in the instantiation of the module for the complete search space.
This is illustrated in Figure~\ref{fig:ss_experiments_python} 
with the definition of \texttt{Module\_fn}
and its use in the declaration of \texttt{M}. 


\section{List of Modules}
\label{sec:list_modules}

We provide a brief description of 
a representative subset of 
the types of basic and composite modules that
we have implemented in our framework.

\subsection{Basic Modules}



Basic modules take no  
other modules when instantiated,
having only local hyperparameters
and parameters.

\begin{itemize}
\item \texttt{Affine}: 
        Dense affine transformation. 
        Hyperparameters: 
            number of the hidden units and
            initialization scheme of the parameters.
        Parameters: 
            dense matrix and
            bias vector.
    \item \texttt{ReLU}: 
        ReLU nonlinearity. 
        Hyperparameters: none.
        Parameters: none.  
    \item \texttt{Dropout}: 
        Dropout. 
        Hyperparameter: 
            dropout probability.
        Parameters: 
            none.
    \item \texttt{Conv2D}: 
        Two-dimensional convolution. 
        Hyperparameters: 
            number of filters,
            size of the filters,
            stride,
            padding scheme, and
            initialization scheme of the parameters.
        Parameters: 
            convolutional filters and
            bias vector.
    \item \texttt{MaxPooling2D}:
        Two-dimensional max pooling.
        Hyperparameters: 
            size of the filters,
            stride, and
            padding scheme.
        Parameters:
            none.
    \item \texttt{BatchNormalization}:
        Batch normalization.
        Hyperparameters:
            none.
        Parameters:
            translation coefficients and
            scaling coefficients.
    \item \texttt{UserHyperparams}:
        User-defined hyperparameters.
        Hyperparameters:
            hyperparameters determined by the user expert.
        Parameters:
            none.
    \item \texttt{Empty}:
        Identity.
        Hyperparameters:
            none.
        Parameters:
            none.
\end{itemize}

\subsection{Composite Modules}

Composite modules take other modules as arguments 
when instantiated, 
which we will call \emph{submodules}.
The behavior of a composite module depends 
on its submodules.
The hyperparameters 
which a 
composite module has to specify 
depend on the values of the hyperparameters of the composite module
and the hyperparameters of the submodules;
e.g., \texttt{Or} takes a list of submodules 
but it only has to specify 
the hyperparameters of the 
submodule that it ends up choosing.
A composite module  
is responsible for specifying its submodules, 
which is done through calls to 
the module interfaces of the submodules.


\begin{itemize}
    \item \texttt{Concat}: 
        Takes a list of submodules and connects them 
            in series.
        Hyperparameters:
            hyperparameters of the submodules.
        Parameters:
            parameters of the submodules.
    \item \texttt{Or}: 
        Chooses one of its submodules to use.
        Hyperparameters:
            which submodule to use and
            hyperparameters of the submodule chosen.
        Parameters:
            parameters of the submodule chosen.
    \item \texttt{Repeat}: 
        Repeats a submodule some number of times,
        connecting the repetitions in series; 
        values for the hyperparameters of the repetitions
        are chosen independently.
        Hyperparameters:
            number of times to repeat the submodule 
            and
            hyperparameters of the repetitions of the submodule.
        Parameters:
            parameters of the repetitions of the submodule.
    \item \texttt{RepeatTied}: 
        Same as \texttt{Repeat}, but values for the hyperparameters of the 
        submodule are chosen once and used for all the submodule repetitions.
        Hyperparameters:
            the number of times to repeat the submodule and 
            hyperparameters of the submodule.
        Parameters:
           parameters of the repetitions of the submodule.
    \item \texttt{Optional}: 
        Takes a submodule and chooses whether to use it or not.
        Hyperparameters:
            whether to include the submodule or not and, 
            if included, 
            hyperparameters of the submodule.
        Parameters:
            if included, parameters of the submodule.
    \item \texttt{Residual}:
        Takes a submodule and implements a skip connection adding 
        the input and output;
        if the input and output have different dimensions, 
        they are padded to make addition possible.
        Hyperparameters:
            hyperparameters of the submodule.
        Parameters:
            parameters of the submodule.
    \item \texttt{MaybeSwap}: 
        Takes two submodules and connects them in series, 
        choosing which submodule comes first.
        Hyperparameters:
            which of the submodules comes first
            and hyperparameters of the submodules.
        Parameters:
            parameters of the submodules.        
\end{itemize}

\section{Module Interface}

We describe the module interface as we implemented it in 
Python. To implement a new type of module, one only 
needs to implement the module interface.

\begin{figure}[htp]
{\raggedleft 
{\scriptsize
\begin{verbatim}
class Module(object):
    def initialize(self, in_d, scope)
    def get_outdim(self)
    def is_specified(self)
    def get_choices(self)
    def choose(self, choice_i)
    def compile(self, in_x, train_feed, eval_feed)
\end{verbatim} } }
\caption{Module interface used by all modules irrespective if they are 
basic or composite. To implement a new type of module, the human expert only 
needs to implement the module interface.}
\label{fig:interface} 
\end{figure}

\begin{itemize}
    \item \texttt{initialize}: 
        Tells a module its input dimensionality.
        A composite module is responsible 
        for initializing the submodules 
        that it uses.

    \item \texttt{get\_outdim}:
        Once a module is fully specified, we can determine its output dimensionality
        by calling \texttt{get\_outdim}. 
        The output dimensionality is a function of the input dimensionality 
        (which is determined when \texttt{initialize} is called)
        and the values of the hyperparameters chosen.
\item \texttt{is\_specified}:
        Tests whether a module is fully specified.
        If a module is fully specified, \texttt{outdim} and \texttt{compile}
        may be called.
    \item \texttt{get\_choices}:
        Returns a list of the possible values for the hyperparameter 
        currently being specified.
    \item \texttt{choose}:
        Chooses one of the possible values for the hyperparameter 
        being specified. 
        The module assigns the chosen value to that hyperparameter and either
        transitions to the next hyperparameter to 
        specify or becomes fully specified. 
        The module maintains 
        internally the state of its search process.





    \item \texttt{compile}:
        Creates the computational graph of the model in a deep learning 
        model specification language, such as Tensorflow or PyTorch.
        For composite modules, compilation can be performed recursively, 
        through calls to the \texttt{compile} functions of its submodules.
\end{itemize}

Composite modules rely on calls to the module interfaces of its submodules 
to implement their own module interfaces. For example, \texttt{Concat} needs
to call \texttt{out\_dim} for the last submodule of the series connection 
to determine its own output dimensionality,
and needs to call \texttt{choose} on the submodules to specify itself.
One of the design choices that make the language modular 
is the fact that a \emph{composite module can 
implement its own module interface through calls to the module interfaces of 
its submodules}.
All information about the specification of a module is local 
to itself or kept within its submodules.

\section{Beyond Single-Input Single-Output Modules}
\label{sec:beyond_siso}

We can define new modules with 
complex signal paths as long as their existence is encapsulated, i.e.,  
a module may have 
many signal paths
as long they
fork from a single input and 
merge to a single output, 
as illustrated in 
Figure~\ref{fig:complex_module}. 

\tikzset{
    module/.style = {draw, fill=white, rectangle, minimum height=2em, minimum width=3em},
    tmp/.style  = {coordinate}, 
    input/.style = {coordinate},
    output/.style= {coordinate},
    sum/.style= {draw, fill=white, circle},
}

\begin{figure}[htp]
\centering
    \resizebox{\columnwidth}{!}{
        \begin{tikzpicture}[auto, node distance=1.5cm,>=latex', scale=0.50]
\node [module] (b2) {\texttt{M2}};
            \node [module, above of=b2] (b1) {\texttt{M1}};
            \node [module, below of=b2] (b3) {\texttt{M3}};
\node [input, left of=b1] (in_m1) {};
            \node [input, left of=b2] (in_m2) {};
            \node [input, left of=b3] (in_m3) {};
            \node [input, left of=in_m2] (in_m) {};
\draw [-] (in_m) -- (in_m2);
            \draw [-] (in_m1) -- (in_m2);
            \draw [-] (in_m2) -- (in_m3);
            \draw [-] (in_m1) -- (b1);   
            \draw [-] (in_m1) -- (b1);   
            \draw [-] (in_m2) -- (b2);   
            \draw [-] (in_m3) -- (b3);   
\node [sum, right of=b2] (g1) {$g _1$};
            \node [tmp, right of=b1] (tmp1_g1) {};
            \draw [-] (b2) -- (g1);
            \draw [-] (b1) -- (tmp1_g1);
            \draw [-] (tmp1_g1) -- (g1);    
\node [module, right of=b3] (b4) {\texttt{M4}};
            \draw [-] (b3) -- (b4);
\node [module, right of=g1] (b5) {\texttt{M5}};
            \draw [-] (g1) -- (b5);
\node [sum, right of=b5] (g2) {$g _2$};
            \node [tmp, below of=g2] (tmp4_g2) {};
            \draw [-] (b5) -- (g2);
            \draw [-] (b4) -- (tmp4_g2);
            \draw [-] (tmp4_g2) -- (g2);
\node [output, right of=g2] (out_b) {};
            \draw [-] (g2) -- (out_b) {};
\node [tmp, above left of=in_m1] (tmp_lu) {};
            \node [tmp, below left of=in_m3] (tmp_ld) {};
            \node [tmp, above of=g2] (tmp_ru_aux) {};
            \node [tmp, above right of=tmp_ru_aux] (tmp_ru) {};
            \node [tmp, below right of=tmp4_g2] (tmp_rd) {};
            \draw [dashed] (tmp_lu) -- (tmp_ru) -- (tmp_rd) -- (tmp_ld) -- (tmp_lu);
\node [tmp, below of=tmp_ru] (tmp_anot) {};
            \node [above left of=tmp_anot] {\texttt{NewModule}};
        \end{tikzpicture}
    }
    \caption{A module with many signal paths from input to output. 
        To implement a module, the human expert 
        only needs to implement its 
        module interface. 
        \texttt{M1}, \texttt{M2}, \texttt{M3}, and \texttt{M4} are 
        arbitrary  
        single-input single-output modules; 
        $g _1$ and $g _2$ are arbitrary transformations 
        that may have additional hyperparameters. 
        The hyperparameters of $g _1$ and $g _2$  
        can be managed internally by \texttt{NewModule}. }
    \label{fig:complex_module}
\end{figure}

In Figure~\ref{fig:complex_module} there is a single 
input fed into
\texttt{M1}, \texttt{M2}, and \texttt{M3}. 
\texttt{M1}, \texttt{M2}, \texttt{M3}, \texttt{M4}, \texttt{M5} 
are arbitrary single-input single-output 
submodules of \texttt{NewModule}.
The module interface of \texttt{NewModule} 
can be implemented
using the module interfaces of its submodules.
Instantiating a module of type \texttt{NewModule} requires submodules 
for \texttt{M1}, \texttt{M2}, \texttt{M3}, \texttt{M4}, and \texttt{M5},
and potentially lists of possible values 
for the hyperparameters of $g _1$ and $g _2$.
A residual module which chooses what
type of merging function to apply, e.g., additive or multiplicative,
is an example of a module with hyperparameters for the merging functions 

A module of the type \texttt{NewModule} is fully specified after 
we choose values for all the hyperparameters of  
\texttt{M1}, \texttt{M2}, \texttt{M3}, \texttt{M4}, \texttt{M5}, $g_1$,
and $g _2$. 
Testing if \texttt{M1}, \texttt{M2}, \texttt{M3}, \texttt{M4}, 
and \texttt{M5} are fully specified 
can be done by calling 
\texttt{is\_specified} 
on the corresponding submodule.
    
    The output dimensionality of \texttt{NewModule} can be computed
as a function of 
the 
values of the hyperparameters of $g _2$
and 
the output dimensionality of \texttt{M5} 
and \texttt{M4}, which 
can be obtained 
by calling \texttt{get\_outdim}.
Similarly, for \texttt{get\_choices} 
we have to keep track of which 
hyperparameter we are specifying, 
which can either come from 
\texttt{M1}, \texttt{M2}, \texttt{M3}, \texttt{M4}, and \texttt{M5}, 
or from 
$g _1$ and $g _2$. 
If we are choosing values for an hyperparameter in 
\texttt{M1}, \texttt{M2}, \texttt{M3}, \texttt{M4}, and \texttt{M5}
we can call \texttt{get\_choices} and \texttt{choose} on that submodule, 
while for the hyperparameters of $g _1$ and $g _2$ 
we have to keep track of the state in \texttt{NewModule}.
\texttt{compile} is similar 
in the sense that it is
implemented using calls
to the \texttt{compile} functionality of 
the submodules.

\end{document}