{'fraction_non_alphanumeric': 0.02370566469119461, 'fraction_numerical': 0.010799915766673687, 'mean_word_length': 5.094976164283095, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Recurrent Iterative Gating Networks for Semantic Segmentation

In this paper, we present an approach for Recurrent Iterative Gating called RIGNet. The core elements of RIGNet involve recurrent connections that control the flow of information in neural networks in a top-down manner, and different variants on the core structure are considered. The iterative nature of this mechanism allows for gating to spread in both spatial extent and feature space. This is revealed to be a powerful mechanism with broad compatibility with common existing networks. Analysis shows how gating interacts with different network characteristics, and we also show that more shallow networks with gating may be made to perform better than much deeper networks that do not include RIGNet modules.


Introduction
The problem of semantic segmentation and other pixelwise labeling problems [26,7,41,16,1,28] has been studied in detail, and is important in image understanding and for various applications including autonomous driving. Moreover, many successful solutions have been proposed based on deep neural networks [19,34,37,13,14]. While progress continues to be made, this progress has also been accompanied by increasingly deep and complex models. While increasing the depth of the network may allow for strong inferences to be made, this also risks poor spatial granularity in labeling when pooling occurs and in some sense also acts as a complex template matching process. Given a deep model, the demand of making dense predictions for all pixels at once makes the problem more challenging insofar as any relational reasoning must be handled in a single feedforward pass. There is good reason to believe that more parsimonious solutions might be presented from the careful guidance of how the image is interpreted from early layers to deep layers that encode more complex features. Evidence of this comes from both examples of existing neural networks that consider such principles [11,31,26,17,25,16,18,6,5,40], and also the very significant role that recurrence, gain control and gating play Figure 1. A recurrent iterative gating based model. A conceptual illustration of how higher layers of the network influence lower layers by gating information that flows forward. When applied iteratively (left to right), this results in belief propagation for features in ascending layers, that propagates over iterations both spatially and in feature space. in biological vision systems as a mechanisms for task, context or input dependent adaptation.
In particular, gating is one mechanism capable of controlling information flow with the possibility of filtering out ambiguous interpretations of a scene. The precise mechanism by which this can be accomplished may take many different forms. There are at least two principal mechanisms of importance in considering the role of recurrent gating: 1. To ensure that activation among earlier layers is consistent with the higher-level interpretation reached by later layers. For example, if a deep layer signals with high confidence that a face is present, features that carry more importance for faces, or carry more discriminative value relevant to faces should be passed forward. More importantly, activation that arises from patterns at the location of the face that are not related to faces should be suppressed.
2. In the case that local features in a scene are diagnostic of semantic category, there should be a mechanism for this local diagnosticity to propagate outwards both in features carried forward and to envelop a larger spatial extent (see Fig. 1). That is, belief in a semantic concept may propagate spatially by virtue of the recurrent gating mechanism.
To this end, we propose an iterative gating mechanism wherein deeper features signal to earlier features what in-formation should be passed forward. Moreover, some networks are marked by spatial pooling, the spatial extent of activation observed very deep in the network has the capacity to propagate to a larger spatial region among earlier layers. When this is done iteratively, there is no limit to the spatial extent over which strongly diagnostic features can be matched to less discriminative and more ambiguous regions of the scene allowing for a consensus on the most likely labeling to be determined through gating and iteration.
It is also the case that one might expect that more efficient handling of the traffic that flows through the network may allow for more parsimonious network architectures to handle challenging problems.
In this paper we present one such mechanism, a Recurrent Iterative Gating Network RIGNet. The results presented in the paper consider how gating mechanisms may interact with different network properties including depth of network, spatial pooling, dilated filters and other characteristics. Through this presentation we show that a wide range of different network architectures reveal better performance through the use of RIG. Moreover, we show that simpler versions of networks (e.g. ResNet-50) can be as capable as much deeper networks (e.g. ResNet-101) when modified to form a RIG-Net and show that this result is true for several different networks.
This has important implications for semantic segmentation, but also any dense image labeling problem and also in how the nature of recurrent processing in general is viewed. In short, this presents a solution for improving the performance of any network by adding a simple canonical recurrent gating mechanism.

Related Work
Feed-forward neural networks have shown tremendous success in various visual recognition tasks. e.g. image classification [34,13,14], semantic segmentation [26,7,41,16,1,28]. Recent approaches mostly focus on generating a discriminative feature representation by increasing the depth of the network. There has also been prior research in machine learning [31,3,38,33,40,5,6] that incorporates feedback in the learning process. In this paper, we carefully examine the essence of feedback based learning, including the role of iterative recurrence and provide an overview of some recent work that falls into different categories in the role of feedback.
Traditional feed-forward networks, e.g., AlexNet [19], VGG [34] do not employ any recurrence or feedback mechanism inside the network and carry a large number of parameters. Recent successful methods e.g. ResNet [13], GoogleNet [36], and Highway Networks [35] have structure connected to earlier layers in the feed-forward network in the form of residual connections. While the deeper networks with skip connections counter the problem of degra-dation due to depth, networks with residual connections address this with the identity shortcut. Moreover, several recent methods have shown the superiority of feedback based approaches [40,5,2,21,24,22,31] for particular tasks of interest. While most approaches focus on directly correcting the initial prediction iteratively, we instead propagate information backward through the network to learn a compact representation that is also strong in its predictions and plays an implicit role in correcting the final prediction made.
Inference in human and other biological vision systems includes both short range and long range recurrent connections [12] where feed-forward paths work in concert with recurrent feedback to provide pre-attentive and attentive modes of vision [20]. Some approaches [3,30,30,15] consider recurrent neural networks (e.g. LSTM [35]) for the task of semantic segmentation or scene labeling.
Related to our proposed approach is the idea of learning in an iterative manner in a feed-forward network with feedback modulation. Recently proposed Feedback Networks [40] present feedback based learning for the purpose of hierarchical taxonomy learning in image classification. IEF [21] proposed a feedback based pipeline that corrects the initial prediction iteratively based on the feedback from each timestep. RCNN [31] introduced a recurrent convolutional neural network for scene labeling where the underlying CNN takes an input image and the label predictions from the previous iteration.
Architecturally, our work is closest to the iterative feedback modulation strategy of recurrent feedback neural networks which are unrolled for several iterations with successive feature refinement. Conceptually, our work is quite different than prior works in the way that feedback is propagated through deep convolutional neural networks for feature refinement, and we provide detailed analysis and support of this approach that includes intuitive and empirical grounding. In summary, our proposed approach can be thought of as a novel formulation of feedback based recurrent design on deep convolutional neural networks that can emulate attentive vision to facilitate top down attention (in space and feature-space) and improve spatial and semantic context for inference. This implies an approach that has a high degree of generality and desirable characteristics which we relate to characteristics of different network architectures in the sections that follow.

Recurrent Iterative Gating Network
In this section, we present the recurrent iterative gating mechanism with different recurrent unrolling mechanisms. We also highlight some theory towards the logical explanation for the recurrence gating module and several core advantages of different unrolling mechanisms. Finally, we propose our top-down feedback based Recurrent Iterative Gating Network, the RIGNet for semantic segmentation.  Figure 2. Illustration of (a) traditional iterative feed-forward network (b) iterative recurrent network where the hidden state serves as a feedback gate and (c) our recurrent iterative gating network for semantic segmentation. In contrast to previous works, our framework involves recurrent iterative gating that control the flow of information passed forward in a top-down manner.

Overview of RIGNet Formulation
The process involved in iterative feedback based approaches has few key elements: (1) Output from some layers/blocks in the network is fed-back to earlier layers through a gating module where the simplest gate may be an identity transform or skip connection (2) The feedback is combined with a representation at an earlier layer through concatenation/multiplication/addition to generate the input for next iteration and (3) The final output is generated at the end of the last iteration. The input image undergoes shared convolutional stages repeatedly to predict labels at each step. The premise behind this is that iterating the feedforward modules (most cases RNN) a few times produces a different final output at the last iteration. However, there is no backward interaction involving the feed-forward modules. In the proposed RIGNet architecture, we take the output of each block of layers as feedback, modulating the signal that forms the input of that block. The outcome of our recurrent feedback based approach is seen to be beneficial in few respects: (a) modulate the initial input with the feedback signal to emulate attentive vision (b) a compact representation that can compete performance-wise with deeper architectures through unrolling for more iteration (c) this allows a common architecture suitable for a wide range of devices with different computational throughput by varying the number of iterations (d) this introduces a hierarchical structure that leads to an implicit coarse-to-fine representations to improve spatial and semantic context of the inference. Overall, this allows for refinement of feature specific activations, and confidence for categories separated by space to propagate over the image.
An illustration of the RIGNet architecture is shown in Fig. 2. Unlike existing work, we integrate iterative feedback modules inside the feed-forward network which can be seen as rerouting the captured information based on information that flows in a backward direction. At a high-level, RIGNet mimics the cyclical structure of the human brain which is created by integrating iteration in the feedback modules of a feed-forward network.

Iterative Gating Mechanism
In this section, we share the details of our proposed recurrent iterative gating/feedback mechanism which is based on stacking feedback modules in each stage of the feedforward network. Recent works on semantic segmentation that have shown success typically share common strategies involving dilation [8,39,14], encoder-decoder structure [28,16,1], and coarse-to-fine refinement [16,32,6,25] to balance semantic context and fine details by recovering per-pixel categorization. Most of these approaches are increasingly precise in their performance but introduce additional model complexity. Our main objective is to demonstrate a compact representation of complex deep networks which can achieve similar performance and is agnostic to the network it is paired with. To accomplish this, we propose a network with several iterative feedback modules (shown as a feedback gate in Fig. 2) similar to recurrent neural networks. More specifically, we apply recurrent top-down feedback in a block-wise manner rather than layer-wise [23,24] or over the full network [31]. We argue that formulating top-down feedback layer-wise similar to [23,24] suffers from few major drawbacks: (1) adds a huge overhead in number of parameters (2) limiting for transfer learning (3) the output of a single deeper layer may not contain sufficiently rich semantic information for feedback. Moreover, the recurrence over the whole network [31] is also unable to leverage semantic and spatial contextual information through feedback to refine the previous layers. In this context, the behaviour of filters remains fixed and only varies based on the current label hypotheses rather than any internal feature representations. In contrast, in RIGNet feedback is taken from the output of a block of convolution layers resulting in a larger effective field of view and more abstraction. Also, this mechanism allows the lower-level layers to be influenced by the weight/activation of higherlevel features resulting in refined weight/activation in the earlier layers that refines information passed forward and importantly also allows for spatial propagation through internal feature representations throughout the network. The mechanism is further defined by a parameter (u i ) denoted as the unroll iteration of the network that determines the number of times the feedback loop will be instantiated to predict the final output. The unrolling parameter (u i ) can be viewed the same as the unrolling steps in RNNs. Fig. 3 shows the unrolling effect on the network presented in Fig. 2 (c).
The final output is generated with multiple iterations over the network where the number of iterations is determined by the unroll iterations (u i ). In the very first iteration, all feedback gates remain disconnected from the network (i.e. there is no gating without prior knowledge of the image among subsequent layers). In subsequent iterations, the output of the previous iteration is subject to modulation by the feedback gate at every layer in the most extreme The difference with the traditional approach is that the loop connections feed into layers that share parameters with previous layers in addition to gating being controlled top-down. Consider iteration ui = 1 where the feed-forward network receives the input image and predicts the initial output which is gated with the corresponding iterative gating module in iteration ui = 2.
case all the way from the first layer to the deepest layers. This operation repeats for all the stages of the network to obtain a prediction for the current iteration. The reverse information flow towards the input all the way from output layers allows the earlier layers to be implicitly subject to adjusted parameters at the time of inference to provide guidance to remove ambiguity that may arise anywhere within the network. Similarly, the loopy structure inside the feedback modules allows a shallower network to be influenced by a rich feature representation. The iterative nature allows for stage-wise refinement and spatial propagation of refinement. This implies that much simpler networks can perform more powerful inference given that their behaviour is not fixed and can be modulated by recurrent feedback.

Unroll Mechanism
For a recurrent approach to be practical, there is a need for a specific recurrent structure (and implied unrolling mechanism) and also a constraint that the unrolling iterations should be finite. It is important to note that often only a finite number of iterations is of value given that the final output will tend to converge on a certain set of labels and show little change beyond a fixed number of iterations. Note also that when we set the unroll iteration u i = 1, RIGNet becomes a purely end-to-end feed-forward neural network. We explore two different unrolling mechanisms to control the flow of information in a top-down manner.

Sequential Unroll
Sequential unrolling involves the recurrence within block tied to a particular iteration, with the order of recurrence following subsequent blocks all involved in a single feedforward pass. Activations are forwarded to the next recurrent block when iterations in all previous network blocks within a single recurrent iteration are finished. Fig. 4 depicts the sequential unrolling mechanism when the network is unrolled for three iterations (u i = 3). Conceptually, the sequential unroll mechanism increases the effective depth of the unrolled network by a multiplicative factor. For example, given a network with l t layers in the RIGNet formulation, l f of l t layers remain similar whereas we introduce l r layers within the blockwise recurrent feedback stage. So, the feed-forward network has effective depth similar to the original depth of the network ( l e = l f + l r ) however the RIGNet with unroll iteration u i has effective depth of l e = l f + l r * u i .  Figure 4. Illustration of RIGNet with sequential unroll for three iteration in last three feed-forward blocks. Note that f i ϑ refers to a feed-forward block and F i denotes the recurrent feedback gate.

Parallel Unroll
In the parallel unrolling mechanism, the network initially gathers the final representation (activations) of the first iteration and then recurrence proceeds by way of feedback from the first block to the last (deep → shallow). The formulation of obtaining the final representation in subsequent iterations is similar to the first iteration. Our proposed RIGNet in Fig. 3 is a feed-forward network with a parallel unrolling mechanism. Fig. 5 illustrates the parallel unrolling mechanism where a RIGNet with feedback in last three blocks is unrolled for three iterations. The parallel unrolling mechanism has less effective depth compared to the sequential one since it increases the effective depth multiplicatively only for the last feedback block. To continue with the example in Sec. 3.3.1, assume the last feedback block has l rk layers among l r whereas the remaining blocks with feedback have l rj = l r − l rk layers. In this case the effective depth of the RIGNet with parallel unrolling is l e = l f +l rj +l rk * u i . This depth analysis between sequential and parallel unrolling mechanisms reveals the impact of increasing the effective depth on performance improvement. This analysis also sheds light on the hypothesis that an effective depth increase helps to improve the overall per- formance as opposed to the role of long range semantic context (across layers and spatially) through feedback bringing improvement. Additionally, parallel recurrence brings another advantage of generating a early prediction (coarse representation) at the end of each iteration which can be used to facilitate taxonomy learning where some coarse grained predictions can be made at initial iterations (like vehicles) and then fine predictions in final iterations (like cars/bus). This can be done by backpropagation of loss defined by coarse predictions in initial iteration similar to the concept explored in [40] for classification task. Since we are principally interested in the final prediction, we only backpropagate loss once at the end of final iteration, but it should be noted that the generality of the RIGNet structure presents a wide range of directions that may be explored further.

Parallel Unroll with Multi Range Feedback
In addition to our basic feedback model (RIGNet), we also extend the concept of short range feedback to long range feedback. Our multi range feedback is a best fit for the parallel recurrence mechanism as it requires additional feedback from not only subsequent blocks but also deeper blocks. The concept of multi range feedback is more analogous to biological vision systems and has been considered to a limited degree in the context on image classification [27].

Iterative Gating Module Formulation
In this section we present the formulation for both our basic feedback gate and multi range feedback gate.

Basic Feedback Gate
Each feedback gate module takes the output of the forward block (next stage feature map) f i+1 ϑ as input and learns to pass information relevant to gating backwards through the following sequence of operations: First we apply an average pooling (resultant feature map f i +1 ϑ ) followed by a 3 × 3 convolution to obtain a feature map f i +1 b which is capable of carrying context with a larger field of view. We then apply a sigmoid operation followed by bilinear upsampling to produce a feature map whose spatial resolution is the same as the input to the feedback gate. The resultant feature map provides the input to the feedback gate. The i th stage feedback gate F i+1 combines the inputs through an elementwise product resulting in a modulated feature map f i r . We can summarize these operations as follows: where A p represents an average pooling operation and (Θ) denotes the parameters of the convolution C. ξ refers to upsampling operation.

Multi Range Feedback Gate
In a multi range feedback gate, the long range feedback is taken from the output of the last block. For example, we denote the output from the last block as f i c at iteration i.

Experiments
We perform a series of experiments to evaluate the performance of RIGNet. We begin by providing implementation details of RIGNet and baseline approaches. Initially, we perform a controlled study to analyze and investigate the contribution of each component in RIGNet. Then we experiment on the object-centric PASCAL VOC 2012 dataset [10]. In addition to semantic segmentation, we also explore how the recurrent iterative gating mechanism can improve scene parsing performance on the COCO-Stuff dataset [4].

Implementation Details and Baseline Networks
Our experimental pipeline and the pre-trained models are based on the open source toolbox PyTorch [29]. We begin with experiments using simpler networks and gradually move to more complex networks to show performance improvements related to different network architectures with the recurrent iterative gating mechanism. First, we report evaluation performance for the vanilla ResNet baselines denoted as ResNet50-FCN, ResNet101-FCN and our corresponding proposed ResNet50-RIGNet, ResNet101-RIGNet networks. So given an input image I ∈ R h×w×d , the networks produce a feature map of size h 32 , w 32 . Then we extend our experiments with a more sophisticated network architecture to examine the effectiveness of RIGNet. We choose DeepLabV2 [9] as our new baseline network due to it's superior performance on pixel-wise labeling tasks. DeepLabV2 uses the dilated structure to balance the semantic context and fine details, resulting in a feature map of size h 8 , w 8 given an input image I ∈ R h×w×d . For ease of representation, we use the following notations to report numbers throughout the experiment section. Sequential unroll (S u ), Parallel unroll (P u ), Parallel unroll with multi-range feedback (P f u ), unroll iteration (u i ). F b j..i refers to feedback used in blocks from i to j.

Analyzing RIGNet
In this section, we perform ablation studies to investigate the role of the recurrent iterative gating mechanism. We highlight a few major facts to validate the design choices: 1) the role of applying iterative gating modules in different stages 2) the length of iteration in a gating module. 3) the design choice associated with the feedback gate 4) the influence of network-wide vs block-wise feedback mechanism.

Unroll Mechanism and Feedback Blocks
To evaluate the value of applying iterative gating modules in different convolutional stages, we perform a control study where we train models by adding iterative gating modules step by step to different layers to evaluate their effect on performance. More specifically, we train a feed-forward network by adding feedback modules at the last stage only and compute mIoU for the final predictions. We repeat this operation several times until we reach the first convolutional stage to examine the importance of integrating recurrent iterative gating mechanisms at the final layer, many deep layers, or all layers. We first report mIoU for the vanilla ResNet baselines in Table 1. Table 2 shows the depth-wise performance of the ResNet50-RIGNet architecture on the PASCAL VOC 2012 validation set. From this analysis, it is clear that inclusion of iterative gating modules improves the overall performance gradually.

Unroll Iteration
To justify the significance of an iterative solution, we examine the extent of the recurrent gating module in terms of iterations. Table 3 shows the experimental results of the iterative gating module per the discussion. We keep the best performing combination for the three different scenarios.
Iter. RIGNet (S u ) 6..4 RIGNet (P u ) 6..4 RIGNet (P f u ) 6.. 1  For this analysis, we compare evaluation performance for unroll iter 2, unroll iter 4, and unroll iter 6. We observe that overall performance progressively improves with each successive stage of iteration. We empirically found this observation to be valid across datasets and different network architectures. Interestingly, ResNet50-RIGNet with unroll iteration 3 outperforms the ResNet101-FCN which further validates the impact of increasing the number of iterations in recurrent gating.

Feedback Gate Design Choices
Additionally, concerning the design choice of feedback gate, we try a variety of alternative design choices and report the number in Table 4. When we use (additive + ReLU) interaction in recurrent gating modules, ResNet50-RIGNet achieves 64.2% mIoU on the PASCAL VOC 2012 validation set. In comparison, our proposed ResNet50-RIGNet with an (multiplicative + sigmoid) interaction in the gating modules achieves 65.2% mIoU. Multiplicative feedback routing is demonstrably valid from a performance point of view, but also intuitive in that it provides a stronger capacity to resolve categorical ambiguity present among earlier layers in the extreme case completely inhibiting activation in an earlier layer. Moreover, we also investigate the impact of different pooling operations (w/o pooling, max pool, and avg pool) in the design choice of recurrent iterative gating.   Table 6. Comparison of network-wide vs block-wide recurrence based methods on PASAL VOC val. Note that we implement the ideas in [31] with ResNet50. Also, we adapt [22] by implementing their routing mechanism attached with our basic feedback gate.

Experiments on PASCAL VOC 2012
We evaluate the performance of our proposed recurrent iterative gating network on the PASCAL VOC 2012 dataset, one of the most commonly used semantic segmentation benchmarks. Following prior works [26,9,17], we use the augmented training set comprised of 10,581, 1449, and 1456 images in training, validation, and testing respectively. The models are trained on the augmented training set and tested on the validation set. Table 7 shows results for the comparison between our proposed approach and the ResNet baselines on the validation set. Note that we only report the best result for ResNet50-RIGNet in Table 7 since the depth-wise results are already reported in Table 2. It is evident that, ResNet50-RIGNet and ResNet101-RIGNet outperform the baselines significantly in terms of mIOU achieving 68.9% and 71.6% respectively. It is worth mentioning that our proposed ResNet50-RIGNet yields mIoU better than ResNet101-FCN without any postprocessing techniques providing a convincing case for the value of our iterative gating mechanism. We also experiment with ResNet101-FCN (stride 8) as a base network and achieve superior performance (71.3% vs. 74.9% mIoU) compared to the baseline. As shown in Table 7, DeepLabv2-RIGNet outperforms the baseline significantly which further validates the importance of iteratively refining initial outcomes through recurrent gating modules. Figure 6 depicts a visual comparison of our approach with respect to the baselines. We can see that ResNet50-RIGNet is capable of producing predictions superior to ResNet101-FCN, and the RIG mechanism has a powerful impact on network performance for all cases.

Experiments on COCO-Stuff
To further confirm the value and generality of proposed recurrent iterative gating mechanism on scene parsing, we evaluate on the large-scale COCO-Stuff dataset. This dataset contains images of high-complexity including things and stuff. The COCO-Stuff dataset extends the COCO annotation by adding dense pixel-wise stuff annotations and provides dense semantic labels for the whole scene, which has 9,000 training images and 1,000 test images. It includes total annotation of 182 classes consisting of 91 thing classes and 91 stuff classes.
We use the same architectures and training procedures mentioned for evaluating performance on the COCO-Stuff dataset.  Figure 7. Some samples of output quality after stage-wise addition of recurrent iterative gating modules. For each row, we show the input image, ground-truth, the vanilla ResNet-50 prediction, the predicted segmentation map of ResNet in a top→down manner when iterative gating is included, and the output of vanilla ResNet101-FCN.
COCO-Stuff 10k dataset with more sophisticated models (DeepLabV2-Res101). As shown in Table 8, RIGNet consistently outperforms the baselines by a significant margin.  The superior performance achieved by RIGNet reveals that integrating recurrent iterative gating modules in the feed-forward network are very effective in capturing more contextual information for labeling complex scenes.

Discussion
Towards examining the practical grounds for recurrent iterative gating networks with top-down feedback, we aimed to verify a few specific hypotheses with our experiments. Firstly, the recurrent iterative gating mechanism can allow more parsimonious networks to outperform deeper architectures with careful selection of the gating structure. This is revealed to be the case for the RIGNet architecture, with clear evidence of ResNet50-RIGNet outperforming ResNet101-FCN with three iterations.
Secondly, our proposed RIGNet is more precise and semantically meaningful compared to the baselines with respect to qualitative results presented in Fig. 6. Fig. 7 illustrates the impact of integrating a recurrent gating module. We can see that the recurrent iterative gating scheme progressively improves the details of a predicted segmentation map by recovering the missing spatial details which can be seen as coarse-to-fine refinement.
Moreover, the improvement in performance as a function of recurrent gating depth (RIG blocks) reveals that the RIGNet formulation of the feed-forward convolutional network improves the representational power of the model by incorporating semantic and relational context in a top-down manner. While there may exist alternatives for feedback gate design, we present an intuitive way of designing recurrent feedback gates. Given the demonstrable capability of the proposed mechanism, we expect that this work will inspire significant interest in exploring feedback based approaches within future work including an emphasis on topdown processing, gating, and iteration.

Conclusion
We have presented a network mechanism that involves Recurrent Iterative Gating for semantic segmentation, showing it is a valuable contribution in its compatibility with virtually any feedforward neural network providing a general mechanism for boosting performance, or allowing for a simpler network. Our experimental results on two challenging datasets demonstrate that the proposed model performs significantly better than the baselines. We also found that feedback based approaches are capable of developing a meaningful coarse-to-fine representation similar to coarse-to-fine refinement based approaches without bringing complexity into the network architecture. As one specific example, ResNet-50 as a RIGNet is shown to outperform ResNet-101.
Results presented reveal the capability for correcting errors made in a single feedforward pass through Recurrent Iterative Gating as an exciting and important direction for future work, which even for deep networks, allows for stronger representational capacity.