1 Introduction
A fundamental problem of vision is how to deal with the enormous complexity of images and visual scenes ^{1}^{1}1Similar complexity issues will arise for other perceptual and cognitive modalities.. The total number of possible images is almost infinitely large [8]
. The number of objects is also huge and has been estimated at around 30,000
[2]. How can a biological, or artificial, vision system deal with this complexity? For example, considering the enormous input space of images and output space of objects, how can humans interpret images in less than 150 msec [16]?There are three main issues involved. Firstly, how can a visual system be designed so that it can efficiently represent large classes of objects, including their parts and subparts? Secondly, how can the visual system be designed so that it can rapidly infer which object, or objects, are present in an input image and the positions of their subparts? And, thirdly, how can this representation be learnt in an unsupervised, or weakly supervised fashion? In short, what visual architectures enable us to address these three issues?
Many considerations suggest that visual architectures should be hierarchical. The structure of mammalian visual systems is hierarchical with the lower levels (e.g., in areas V1 and V2) tuned to small image features while the higher levels (i.e. in area IT) are tuned to objects ^{2}^{2}2
But just because mammalian visual systems are hierarchical does not necessarily imply that this is the best design for computer vision systems.
. Moreover, as appreciated by pioneers such as Fukushima [5], hierarchical architectures lend themselves naturally to efficient representations of objects in terms of parts and subparts which can be shared between many objects. Hierarchical architectures also lead to efficient learning algorithms as illustrated by deep belief learning and others [7]. There are many varieties of hierarchical models which differ in details of their representations and their learning and inference algorithms [14, 7, 15, 1, 13, 18, 10, 3, 9]. But, to the best of our knowledge, there has been no detailed study of their complexity properties.This paper provides a mathematical analysis of compositional models [6], which are a subclass of the hierarchical models. The key idea of compositionality is to explicitly represent objects by recursive composition from parts and subparts. This gives rise to natural learning and inference algorithms which proceed from subparts to parts to objects (e.g., inference is efficient because a leg detector can be used for detecting the legs of cows, horses, and yaks). The explicitness of the object representations helps quantify the efficiency of partsharing and make mathematical analysis possible. The compositional models we study are based on the work of L. Zhu and his collaborators [19, 20] but we make several technical modifications including a parallel reformulation of the models. We note that in previous papers [19, 20] the representations of the compositional models were learnt in an unsupervised manner, which relates to the memorization algorithms of Valiant [17]. This paper does not address learning but instead explores the consequence of the representations which were learnt.
Our analysis assumes that objects are represented by hierarchical graphical probability models
^{3}^{3}3These graphical models contain closed loops but with restricted maximal clique size. which are composed from more elementary models by partsubpart compositions. An object – a graphical model with levels – is defined as a composition of parts which are graphical models with levels. These parts are defined recursively in terms of subparts which are represented by graphical models of increasingly lower levels. It is convenient to specify these compositional models in terms of a set of dictionaries where the level parts in dictionary are composed in terms of level parts in dictionary . The highest level dictionaries represent the set of all objects. The lowest level dictionaries represent the elementary features that can be measured from the input image. Partsubpart composition enables us to construct a very large number of objects by different compositions of elements from the lowestlevel dictionary. It enables us to perform partsharing during learning and inference, which can lead to enormous reductions in complexity, as our mathematical analysis will show.There are three factors which enable computational efficiency. The first is partsharing, as described above, which means that we only need to perform inference on the dictionary elements. The second is the executivesummary principle. This principle allows us to represent the state of a part coarsely because we are also representing the state of its subparts (e.g., an executive will only want to know that ”there is a horse in the field” and will not care about the precise positions of its legs). For example, consider a letter which is composed of a horizontal and vertical bar. If the positions of these two bars are specified precisely, then we can specify the position of the letter more crudely (sufficient for it to be ”bound” to the two bars). This relates to Lee and Mumford’s highresolution buffer hypothesis [11] and possibly to the experimental finding that neurons higher up the visual pathway are tuned to increasingly complex image features but are decreasingly sensitive to spatial position. The third factor is parallelism which arises because the part dictionaries can be implemented in parallel, essentially having a set of receptive fields, for each dictionary element. This enables extremely rapid inference at the cost of a larger, but parallel, graphical model.
2 The Compositional Models
Compositional models are based on the idea that objects are built by compositions of parts which, in turn, are compositions of more elementary parts. These are built by partsubpart compositions.
2.1 Compositional PartSubparts
We formulate partsubpart compositions by probabilistic graphical model which specifies how a part is composed of its subparts. A parent node of the graph represents the part by its type and a state variable (e.g., could indicate the position of the part). The child nodes represent the parts by their types and state variables ^{4}^{4}4In this paper, we assume a fixed value for all partsubpart compositions.. The type of the parent node is specified by . Here are the types of the child nodes, and specifies a distribution over the states of the subparts (e.g.,over their relative spatial positions). Hence the type of the parent specifies the partsubpart compositional model.
The probability distribution for the partsubpart model relates the states of the part and the subparts by:
(1) 
Here is a deterministic function, so the state of the parent node is determined uniquely by the state of the child nodes. The function specifies a distribution on the relative states of the child nodes. The distribution obeys a locality principle, which means that , unless is smaller than a threshold for all . This requirement captures the intuition that subparts of a part are typically close together.
The state variable of the parent node provides an executive summary description of the part. Hence they are restricted to take a smaller set of values than the state variables of the subparts. Intuitively, the state of the parent offers summary information (e.g., there is a cow in the right side of a field) while the child states offer more detailed information (e.g., the position of the parts of the cow). In general, information about the object is represented in a distributed manner with coarse information at the upper levels of the hierarchy and more precise information at lower levels.
We give examples of partsubpart compositions in figure (1). The compositions represent the letters and , which are the types of the parent nodes. The types of the child nodes are horizontal and vertical bars, indicated by . The child state variables indicate the image positions of the horizontal and vertical bars. The state variable of the parent node gives a summary description of the position of the letters and . The compositional models for letters and differ by their parameter which species the relative positions of the horizontal and vertical bars. In this example, we choose
to a Gaussian distribution, so
where is the mean relative positions between the bars and is the covariance. We set , so the state of the parent node specifies the average positions of the child nodes (i.e. the positions of the two bars). Hence the two compositional models for the and have types and .2.2 Models of Object Categories
An object category can be modeled by repeated partsubpart compositions. This is illustrated in figure (2) where we combine ’s and ’s with other parts to form more complex objects. More generally, we can combine partsubpart compositions into bigger structures by treating the parts as subparts of higher order parts.
More formally, an object category of type is represented by a probability distribution defined over a graph . This graph has a hierarchical structure with levels , where . Each object has a single, root node, at level (i.e. contains a single node). Any node (for ) has children nodes in indexed by . Hence there are nodes at levelh (i.e. ).
At each node there is a state variable which indicates spatial position and type . The type of the root node indicates the object category and also specifies the types of its parts.
The position variables take values in a set of lattices , so that a levelh node, , takes position . The leaf nodes of the graph take values on the image lattice . The lattices are evenly spaced and the number of lattice points decreases by a factor of for each level, so , see figure (1). This decrease in number of lattice points imposes the executive summary principle. The lattice spacing is designed so that parts do not overlap. At higher levels of the hierarchy the parts cover larger regions of the image and so the lattice spacing must be larger, and hence the number of lattice points smaller, to prevent overlapping ^{5}^{5}5Previous work [20, 19] was not formulated on lattices and used nonmaximal suppression to achieve the same effect..
The probability model for an object category of type is specified by products of partsubpart relations:
(2) 
Here
is the uniform distribution.
2.3 Multiple Object Categories, Shared Parts, and Hierarchical Dictionaries
Now suppose we have a set of object categories , each of which can be expressed by an equation such as equation (2). We assume that these objects share parts. To quantify the amount of part sharing we define a hierarchical dictionary , where is the dictionary of parts at level . This gives an exhaustive set of the parts of this set of the objects, at all levels . The elements of the dictionary are composed from elements of the dictionary by partsubpart compositions ^{6}^{6}6
The unsupervised learning algorithm in
[19] automatically generates this hierarchical dictionary..This gives an alternative way to think of object models. The type variable of a node at level (i.e. in ) indexes an element of the dictionary . Hence objects can be encoded in terms of the hierarchical dictionary. Moreover, we can create new objects by making new compositions from existing elements of the dictionaries.
2.4 The Likelihood Function and the Generative Model
To specify a generative model for each object category we proceed as follows. The prior specifies a distribution over the positions and types of the leaf nodes of the object model. Then the likelihood function is specified in terms of the type at the leaf nodes (e.g., if the leaf node is a vertical bar, then there is a high probability that the image has a vertical edge at that position).
More formally, the prior , see equation (2), specifies a distribution over a set of points (the leaf nodes of the graph) and specifies their types . These points are required to lie on the image lattice (e.g., ). We denote this as where is specified in the natural manner (i.e. if then ). We specify distributions for the probability of the image at conditioned on the type of the leaf node. We specify a default probability at positions where there is no leaf node of the object.
This gives a likelihood function for the states of the object model in terms of the image :
(3) 
The likelihood and the prior, equations (3,2), give a generative model for each object category.
We can extend this in the natural manner to give generative models or two, or more, objects in the image provided they do not overlap. Intuitively, this involves multiple sampling from the prior to determine the types of the lattice pixels, followed by sampling from at the leaf nodes to determine the image . Similarly, we have a default background model for the entire image if no object is present:
(4) 
3 Inference by Dynamic Programming
The inference task is to determine which objects are present in the image and to specify their positions. This involves two subtasks: (i) state estimation, to determine the optimal states of a model and hence the position of the objects and its parts, and (ii) model selection, to determine whether objects are present or not. As we will show, both tasks can be reduced to calculating and comparing loglikelihood ratios which can be performed efficiently using dynamic programming methods.
We will first describe the simplest case which consists of estimating the state variables of a single object model and using model selection to determine whether the object is present in the image and, if so, how many times. Next we show that we can perform inference and model selection for multiple objects efficiently by exploiting part sharing (using hierarchical dictionaries). Finally, we show how these inference tasks can be performed even more efficiently using a parallel implementation. We stress that we are performing exact inference and no approximations are made. We are simply exploiting partsharing so that computations required for performing inference for one object can be reused when performing inference for other objects.
3.1 Inference Tasks: State Detection and Model Selection
We first describe a standard dynamic programming algorithm for finding the optimal state of a single object category model. Then we describe how the same computations can be used to perform model selection and to the detection and state estimation if the object appears multiple times in the image (nonoverlapping).
Consider performing inference for a single object category model defined by equations (2,3). To calculate the MAP estimate of the state variables requires computing . By subtracting the constant term from the righthand side, we can reexpress this as estimating:
(5) 
Here denotes the positions of the leaf nodes of the graph, which must be determined during inference.
We estimate by performing dynamic programming. This involves a bottomup pass which recursively computes quantities by the formula:
(6) 
We refer to as the local evidence for part with state (after maximizing over the states of the lower parts of the graphical model). This local evidence is computed bottomup. We call this the local evidence because it ignores the context evidence for the part which will be provided during topdown processing (i.e. that evidence for other parts of the object, in consistent positions, will strengthen the evidence for this part).
The bottomup pass outputs the global evidence for object category at position . We can detect the most probable state of the object by computing . Then we can perform the topdown pass of dynamic programming to estimate the most probable states of the entire model by recursively performing:
(7) 
This outputs the most probable state of the object in the image. Note that the bottomup process first estimates the optimal ”executive summary” description of the object () and only later determines the optimal estimates of the lowerlevel states of the object in the topdown pass. Hence, the algorithm is faster at detecting that there is a cow in the right side of the field (estimated in the bottomup pass) and is slower at determining the position of the feet of the cow (estimated in the topdown pass). This is illustrated in figure (3).
Importantly, we only need to perform slight extensions of this algorithm to compute significantly more. First, we can perform model selection – to determine if the object is present in the image – by determining if , where is a threshold. This is because, by equation (5), is the loglikelihood ratio of the probability that the object is present at position compared to the probability that the corresponding part of the image is generated by the background image model . Secondly, we can compute the probability that the object occurs several times in the image, by computing the set , to compute the ”executive summary” descriptions for each object (e.g., the coarse positions of each object). We then perform the topdown pass initialized at each coarse position (i.e. at each point of the set described above) to determine the optimal configuration for the states of the objects. Hence, we can reuse the computations required to detect a single object in order to detect multiple instances of the object (provided there are no overlaps)^{7}^{7}7Note that this is equivalent to performing optimal inference simultaneously over a set of different generative models of the image, where one model assumes that there is one instance of the object in the image, another models assumes there are two, and so on.. The number of objects in the image is determined by the loglikelihood ratio test with respect to the background model.
3.2 Inference on Multiple Objects by Part Sharing using the Hierarchical Dictionaries
Now suppose we want to detect instances of many object categories simultaneously. We can exploit the shared parts by performing inference using the hierarchical dictionaries.
The main idea is that we need to compute the global evidence for all objects and at all positions in the toplevel lattice. These quantities could be computed separately for each object by performing the bottomup pass, specified by equation (6), for each object. But this is wasteful because the objects share parts and so we would be performing the same computations multiple times. Instead we can perform all the necessary computations more efficiently by working directly with the hierarchical dictionaries.
More formally, computing the global evidence for all object models and at all positions is specified as follows.
(8) 
All these calculations can be done efficiently using the hierarchical dictionaries (except for the and tasks at level which must be done separately). Recalling that each dictionary element at level is composed, by partsubpart composition, of dictionary elements at level . Hence we can apply the bottomup update rule in equation (6) directly to the dictionary elements. This is illustrated in figure (4). As analyzed in the next section, this can yield major gains in computational complexity.
Once the global evidences for each object model have been computed at each position (in the top lattice) we can perform winnertakeall to estimate the object model which has largest evidence at each position. Then we can apply thresholding to see if it passes the loglikelihood ratio test compared to the background model. If it does pass this loglikelihood test, then we can use the topdown pass of dynamic programming, see equation (7), to estimate the most probable state of all parts of the object model.
We note that we are performing exact inference over multiple object models at the same time. This is perhaps unintuitive to some readers because this corresponds to doing exact inference over a probability model which can be expressed as a graph with a large number of closed loops, see figure (4). But the main point is that partsharing enables us share inference efficiently between many models.
The only computation which cannot be performed by dynamic programming are the and tasks at level , see top line of equation (8). These are simple operations and require order calculations. This will usually be a small number, compared to the complexity of other computations. But this will become very large if there are a large number of objects, as we will discuss in section (4).
3.3 Parallel Formulation and Inference Algorithm
Finally, we observe that all the computations required for performing inference on multiple objects can be parallelized. This requires computing the quantities in equation (8).
The parallelization is possible, in the bottomup pass of dynamic programming, calculations are done separately for each position , see equation (6). So we can compute the local evidence for all parts in the hierarchical dictionary recursively and in parallel for each position, and hence compute the for all and . The and operations at level can also be done in parallel for each position . Similarly we can perform the topdown pass of dynamic programming, see equation (7), in parallel to compute the best configurations of the detected objects in parallel for different possible positions of the objects (on the toplevel lattice).
The parallel formulation can be visualized by making copies of the elements of the hierarchical dictionary elements (the parts), so that a model at levelh has copies, with one copy at each lattice point. Hence at levelh, we have ”receptive fields” at each lattice point in with each one tuned to a different part , see figure (5). At level0, these receptive fields are tuned to specific image properties (e.g., horizontal or vertical bars). Note that the receptive fields are highly nonlinear (i.e. they do not obey any superposition principle)^{8}^{8}8Nevertheless they are broadly speaking, tuned to image stimuli which have the mean shape of the corresponding part . In agreement, with findings about mammalian cortex, the receptive fields become more sensitive to image structure (e.g., from bars, to more complex shapes) at increasing levels. Moreover, their sensitivity to spatial position decreases because at higher levels the models only encode the executive summary descriptions, on coarser lattices, while the finer details of the object are represented more precisely at the lower levels.. Moreover, they are influenced both by bottomup processing (during the bottomup pass) and by topdown processing (during the topdown pass). The bottomup processing computes the local evidence while the topdown pass modifies it by the highlevel context.
The computations required by this parallel implementation are illustrated in figure (6). The bottomup pass is performed by a twolayer network where the first layer performs an AND operation (to compute the local evidence for a specific configuration of the child nodes) and the second layer performs an OR, or operation, to determine the local evidence (by maxing over the possible child configurations)^{9}^{9}9Note that other hierarchical models, including bioinspired ones, use similar operations but motivated by different reasons.. The topdown pass only has to perform an computation to determine which child configuration gave the best local evidence.
4 Complexity Analysis
We now analyze the complexity of the inference algorithms for performing the tasks. Firstly, we analyze complexity for a single object (without partsharing). Secondly, we study the complexity for multiple objects with shared parts. Thirdly, we consider the complexity of the parallel implementation.
The complexity is expressed in terms of the following quantities: (I) The size of the image. (II) The scale decrease factor (enabling executive summary). (III) The number of levels of the hierarchy. (IV) The sizes of the hierarchical dictionaries. (V) The number of subparts of each part. (VI) The number of possible partsubpart configurations.
4.1 Complexity for Single Objects and Ignoring Part Sharing
This section estimates the complexity of inference for a single object and the complexity for multiple objects when part sharing is not used. These results are for comparison to the complexities derived in the following section using part sharing.
The inference complexity for a single object requires computing: (i) the number of computations required by the bottomup pass, (ii) the number of computations required by model selection at the toplevel of the hierarchy, and (iii) the number of computations required by the topdown pass.
The complexity of the bottomup pass can be computed from equation (6). This requires a total of computations for each position for each levelh node. There are nodes at level and each can take positions. This gives a total of computations at level . This can be summed over all levels to yield:
(9) 
Observe that the main contributions to come from the first few levels of the hierarchy because the factors decrease rapidly with . This calculation uses . For large we can approximate by (because will be small).
We calculate for the complexity of model selection (which only requires thresholding at every point on the toplevel lattice).
The complexity of the topdown pass is computed from equation (7). At each level there are nodes and we must compute computations for each. This yields complexity of for each possible root node. There are at most possible root nodes (depending on the results of the model selection stage). This yields an upper bound:
(10) 
Clearly the complexity is dominated by the complexity of the bottomup pass. For simplicity, we will bound/approximate this by:
(11) 
Now suppose we perform inference for multiple objects simultaneously without exploiting shared parts. In this case the complexity will scale linearly with the number of objects. This gives us complexity:
(12) 
4.2 Computation with Shared Parts in Series and in Parallel
This section computes the complexity using part sharing. Firstly, for the standard serial implementation of part sharing. Secondly, for the parallel implementation.
Now suppose we perform inference on many objects with part sharing using a serial computer. This requires performing computations over the partsubpart compositions between elements of the dictionaries. At level there are dictionary elements. Each can take possible states. The bottomup pass requires performing computations for each of them. This gives a total of computations for the bottomup process. The complexity of model selection is (this is between all the objects, and the background model, at all points on the top lattice). As in the previous section, the complexity of the topdown process is less than the complexity of the bottomup process. Hence the complexity for multiple objects using part sharing is given by:
(13) 
Next consider the parallel implementation. In this case almost all of the computations are performed in parallel and so the complexity is now expressed in terms of the number of ”neurons” required to encode the dictionaries, see figure (5). This is specified by the total number of dictionary elements multiplied by the number of spatial copies of them:
(14) 
The computation, both the forward and backward passes of dynamic programming, are linear in the number of levels. We only need to perform the computations illustrated in figure (6) between all adjacent levels.
Hence the parallel implementation gives speed which is linear in at the cost of a possibly large number of ”neurons” and connections between them.
4.3 Advantages of Part Sharing in Different Regimes
The advantages of partsharing depend on how the number of parts scales with the level of the hierarchy. In this section we consider three different regimes: (I) The exponential growth regime where the size of the dictionaries increases exponentially with the level . (II) The empirical growth regime where we use the size of the dictionaries found experimentally by compositional learning [19]. (III) The exponential decrease regime where the size of the dictionaries decreases exponentially with level . For all these regimes we compare the advantages of the serial and parallel implementations using part sharing by comparison to the complexity results without sharing.
Exponential growth of dictionaries is a natural regime to consider. It occurs when subparts are allowed to combine with all other subparts (or a large fraction of them) which means that the number of partsubpart compositions is polynomial in the number of subparts. This gives exponential growth in the size of the dictionaries if it occurs at different levels (e.g., consider the enormous number of objects that can be built using lego).
An interesting special case of the exponential growth regime is when scales like , see figure (7)(left panel). In this case the complexity of computation for serial partsharing, and the number of neurons required for parallel implementation, scales only with the number of levels . This follows from equations (13,14). But nevertheless the number of objects that can be detected scales exponentially as . By contrast, the complexity of inference without partsharing scales exponentially with , see equation (12, because we have to perform a fixed number of computations, given by equation (11), for each of an exponential number of objects. This is summarized by the following result.
Result 1: If the number of shared parts scales exponentially by then we can perform inference for order objects using part sharing in time linear in , or with a number of neurons linear in for parallel implementation. By contrast, inference without partsharing requires exponential complexity.
To what extent is exponential growth a reasonable assumption for real world objects? This motivates us to study the empirical growth regime using the dictionaries obtained by the compositional learning experiments reported in [19]. In these experiments, the size of the dictionaries increased rapidly at the lower levels (i.e. small ) and then decreased at higher levels (roughly consistent with the findings of psychophysical studies – Biederman, personal communication). For these ”empirical dictionaries” we plot the growth, and the number of computations at each level of the hierarchy, in figure (7)(center panel). This shows complexity which roughly agrees with the exponential growth model. This can be summarized by the following result:
Result 2: If grows slower than and if then there are gains due to part sharing using serial and parallel computers. This is illustrated in figure (7)(center panel) based on the dictionaries found by unsupervised computational learning [19]. In parallel implementations, computation is linear in while requiring a limited number of nodes (”neurons”).
Finally we consider the exponential decrease regime. To motivate this regime, suppose that the dictionaries are used to model image appearance, by contrast to the dictionaries based on geometrical features such as bars and oriented edges (as used in [19]). It is reasonable to assume that there are a large number of lowlevel dictionaries used to model the enormous variety of local intensity patterns. The number of higherlevel dictionaries can decrease because they can be used to capture a cruder summary description of a larger image region, which is another instance of the executive summary principle. For example, the lowlevel dictionaries could be used to provide detailed modeling of the local appearance of a cat, or some other animal, while the higherlevel dictionaries could give simpler descriptions like ”catfur” or ”dogfur” or simply ”fur”. In this case, it is plausible that the size of the dictionaries decreases exponentially with the level . The results for this case emphasize the advantages of parallel computing.
Result 3: If then there is no gain for part sharing if serial computers are used, see figure (7)(right panel). Parallel implementations can do inference in time which is linear in but require an exponential number of nodes (”neurons”).
Result 3 may appear negative at first glance even for the parallel version since it requires an exponentially large number of neurons required to encode the lower level dictionaries. But it may relate to one of the more surprising facts about the visual cortex in monkeys and humans – namely that the first two visual areas, V1 and V2, where lowlevel dictionaries would be implemented are enormous compared to the higher levels such as IT where object detection takes places. Current models of V1 and V2 mostly relegate it to being a large filter bank which seems paradoxical considering their size. For example, as one theorist [12] has stated when reviewing the functions of V1 and V2 “perhaps the most troublesome objection to the picture I have delivered is that an enormous amount of cortex is used to achieve remarkably little”. Our complexity studies suggest a reason why these visual areas may be so large if they are used to encode dictionaries^{10}^{10}10Of course, this is extremely conjectural..
5 Discussion
This paper provides a complexity analysis of what is arguably one of the most fundamental problem of visions – how, a biological or artificial vision system could rapidly detect and recognize an enormous number of different objects. We focus on a class of hierarchical compositional models [20, 19] whose formulation makes it possible to perform this analysis. But we conjecture that similar results will apply to related hierarchical models of vision (e.g., those cited in the introduction).
Technically this paper has required us to reformulate compositional models so that they can be defined on regular lattices (which makes them easier to compare to alternatives such as deep belief networks) and a novel parallel implementation. Hopefully the analysis has also clarified the use of partsharing to perform exact inference even on highly complex models, which may not have been clear in the original publications. We note that the reuse of computations in this manner might relate to methods developed to speed up inference on graphical models, which gives an interesting direction to explore.
Finally, we note that the parallel inference algorithms used by this class of compositional models have an interesting interpretation in terms of the bottomup versus topdown debate concerning processing in the visual cortex [4]. The algorithms have rapid parallel inference, in time which is linear in the number of layers, and which rapidly estimates a coarse “executive summary” interpretation of the image. The full interpretation of the image takes longer and requires a topdown pass where the highlevel context is able to resolve ambiguities which occur at the lower levels. Of course, for some simple images the local evidence for the low level parts is sufficient to detect the parts in the bottomup pass and so the topdown pass is not needed. But more generally, in the bottomup pass the neurons are very active and represent a large number of possible hypotheses which are pruned out during the topdown pass using context, when “highlevel tells lowlevel to stop gossiping”.
Acknowledgments
Many of the ideas in this paper were obtained by analyzing models developed by L. Zhu and Y. Chen in collaboration with the first author. G. Papandreou gave very useful feedback on drafts of this work. D. Kersten gave patient feedback on speculations about how these ideas might relate to the brain. The WCU program at Korea University, under the supervision of SW Lee, gave peace and time to develop these ideas.
References
 [1] N. J. Adams and C. K. I. Williams. Dynamic trees for image modelling. Image and Vision Computing, 20(10):865–877, 2003.
 [2] I. Biederman. Recognitionbycomponents: a theory of human image understanding. Psychological Review, 94(2):115–147, Apr. 1987.
 [3] E. Borenstein and S. Ullman. Classspecific, topdown segmentation. ECCV 2002, pages 639–641, 2002.
 [4] J. J. DiCarlo, D. Zoccolan, and N. C. Rust. How Does the Brain Solve Visual Object Recognition? Neuron, 73(3):415–434, Feb. 2012.

[5]
K. Fukushima.
Neocognitron  a Hierarchical Neural Network Capable of VisualPattern Recognition.
Neural Networks, 1(2):119–130, 1988.  [6] S. Geman, D. Potter, and Z. Chi. Composition systems. Quarterly of Applied Mathematics, 60(4):707–736, 2002.
 [7] G. E. Hinton, S. Osindero, and Y. Teh. A fast learning algorithm for deep belief nets. Neural Computation, 18:1527–54, 2006.
 [8] D. Kersten. Predictability and redundancy of natural images. JOSA A, 4(12):2395–2400, 1987.
 [9] I. Kokkinos and A. Yuille. Inference and learning with hierarchical shape models. Int. J. Comput. Vision, 93(2):201–225, June 2011.
 [10] Y. LeCun and Y. Bengio. Convolutional networks for images, speech, and timeseries. In M. A. Arbib, editor, The Handbook of Brain Theory and Neural Networks. MIT Press, 1995.

[11]
T. Lee and D. Mumford.
Hierarchical Bayesian inference in the visual cortex.
Journal of the Optical Society of America A, Optics, Image Science, and Vision, 20(7):1434–1448, July 2003.  [12] P. Lennie. Single units and visual cortical organization. Perception, 27:889–935, 1998.

[13]
H. Poon and P. Domingos.
Sumproduct networks: A new deep architecture.
In
Uncertainty in Artificial Intelligence (UAI)
, 2010.  [14] M. Riesenhuber and T. Poggio. Hierarchical models of object recognition in cortex. Nature Neuroscience, 2:1019–1025, 1999.
 [15] T. Serre, L. Wolf, S. Bileschi, M. Riesenhuber, and T. Poggio. Robust object recognition with cortexlike mechanisms. IEEE Transactions on Pattern Analysis and Machine Intelligence, 29:411–426, 2007.
 [16] S. Thorpe, D. Fize, and C. Marlot. Speed of processing in the human visual system. Nature, 381(6582):520–2, 1996.
 [17] L. G. Valiant. In Circuits of the Mind, 2000.
 [18] M. Zeiler, D. Krishnan, G. Taylor, and R. Fergus. Deconvolutional networks. Computer Vision and Pattern Recognition (CVPR), 2010 IEEE Conference on, pages 2528–2535, 2010.
 [19] L. Zhu, Y. Chen, A. Torralba, W. Freeman, and A. L. Yuille. Part and appearance sharing: Recursive compositional models for multiview multiobject detection. In Proceedings of Computer Vision and Pattern Recognition, 2010.
 [20] L. Zhu, C. Lin, H. Huang, Y. Chen, and A. L. Yuille. Unsupervised structure learning: Hierarchical recursive composition, suspicious coincidence and competitive exclusion. In Proceedings of The 10th European Conference on Computer Vision, 2008.