id
stringlengths 12
15
| title
stringlengths 8
162
| content
stringlengths 1
17.6k
| prechunk_id
stringlengths 0
15
| postchunk_id
stringlengths 0
15
| arxiv_id
stringlengths 10
10
| references
sequencelengths 1
1
|
|---|---|---|---|---|---|---|
1512.04455#17 | Memory-based control with recurrent neural networks | for cartpole swing-up it is limited to the angle of the pole and the position of the cart. Velocity is crucial for solving the task and thus it must be estimated from the history of the system. Figure 1a shows the learning curves for pendulum swing-up. Both RDPG and RSVG0 were tested on the pendulum task, and are able to learn good solutions which bring the pole to upright. For the cartpole swing-up task, in addition to not providing the agent with velocity information, we also varied the length of the pole from episode to episode. The pole length is invisible to the agent and needs to be inferred from the response of the system. In this task the sensor integration problem is thus paired with the need for system identiï¬ | 1512.04455#16 | 1512.04455#18 | 1512.04455 | [
"1509.03005"
] |
1512.04455#18 | Memory-based control with recurrent neural networks | cation. As can be seen in ï¬ gure 1b, the RDPG agent with an LSTM network reliably solves this task every time while a simple feedforward agent (DDPG) fails entirely. RDPG with a simple RNN performs considerably less well than the LSTM agent, presumably due to relatively long episodes (T=350 steps) and the failure to backpropagate gradients effectively through the plain RNN. We found that a feedforward agent that does receive velocity information can solve the variable-length swing-up task partly but does so less reliably than the recurrent agent as it is unable to identify the relevant system parameters (not shown). # 4.2 Memory tasks Another type of partially-observed task, which has been less studied in the context of reinforcement learning, involves the need to remember explicit information over a number of steps. We constructed two tasks like this. One was a 3-joint reacher which must reach for a randomly positioned target, but the position of the target is only provided to the agent in the initial observation (the entire episode is 80 timesteps). As a harder variant of this task, we constructed a 5 joint gripper which must reach for a (fully-observed) payload from a randomized initial conï¬ guration and then return the payload to the initial position of its â handâ (T=100). Note that this is a challenging control problem even in the fully observed case. The results for both tasks are shown in ï¬ gure 2, RDPG agents with LSTM networks solve both tasks reliably whereas purely feedforward agents fail on the memory components of the task as can be seen in the supplemental video. | 1512.04455#17 | 1512.04455#19 | 1512.04455 | [
"1509.03005"
] |
1512.04455#19 | Memory-based control with recurrent neural networks | 6 (a) (b) (c) (d) (e) Figure 3: (a) shows the reward curve for different agents performing the water maze task. Both recurrent algorithms are capable of learning good solutions to the problem, while the non-recurrent agent (DDPG) is not. It is particularly notable that despite learning a deterministic policy, RDPG is able ï¬ nd search strategies that allow it to locate the platform. (b) This shows the number of steps the agents take to reach the platform after a reset, normalized by the number of steps taken for the ï¬ rst attempt. Note that on the 2nd and 3rd attempts the recurrent agents are able to reach the platform much more quickly, indicating they are learning to remember and recall the position of the platform. Example trajectories for the (c) RDPG, (d) RSVG(0) and (e) DDPG agents. Trajectory of the ï¬ | 1512.04455#18 | 1512.04455#20 | 1512.04455 | [
"1509.03005"
] |
1512.04455#20 | Memory-based control with recurrent neural networks | rst attempt is purple, second is blue and third is yellow. # 4.3 Water maze The Morris water maze has been used extensively in rodents for the study of memory [3]. We tested our algorithms on a simpliï¬ ed version of the task. The agent moves in a 2-dimensional circular space where a small region of the space is an invisible â platformâ where the agent receives a positive reward. At the beginning of the episode the agent and platform are randomly positioned in the tank. The platform position is not visible to the agent but it â | 1512.04455#19 | 1512.04455#21 | 1512.04455 | [
"1509.03005"
] |
1512.04455#21 | Memory-based control with recurrent neural networks | seesâ when it is on platform. The agent needs to search for and stay on the platform to receive reward by controlling its acceleration. After 5 steps on the platform the agent is reset randomly to a new position in the tank but the platform stays in place for the rest of the episode (T=200). The agent needs to remember the position of the platform to return to it quickly. It is sometimes presumed that a stochastic policy is required in order to solve problems like this, which require learning a search strategy. | 1512.04455#20 | 1512.04455#22 | 1512.04455 | [
"1509.03005"
] |
1512.04455#22 | Memory-based control with recurrent neural networks | Although there is some variability in the results, we found that both RDPG and RSVG(0) were able to ï¬ nd similarly good solutions (ï¬ gure 3a), indicating RDPG is able to learn reasonable, deterministic search strategies. Both solutions were able to make use of memory to return to the platform more quickly after discovering it during the initial search (ï¬ gure 3b). A non-recurrent agent (DDPG) is able to learn a limited search strategy but fails to exploit memory to return the platform after having been reset to a random position in the tank. # 4.4 High-dimensional observations We also tested our agents, with convolutional networks, on solving tasks directly from high- dimensional pixel spaces. We tested on the pendulum task (but now the agent is given only a static rendering of the pendulum at each timestep), and a two-choice reaching task, where the target dis- appears after 5 frames (and the agent is not allowed to move during the ï¬ rst 5 frames to prevent it from encoding the target position in its initial trajectory). We found that RDPG was able to learn effective policies from high-dimensional observations which integrate information from multiple timesteps to estimate velocity and remember the visually queued target for the full length of the episode (in the reacher task). | 1512.04455#21 | 1512.04455#23 | 1512.04455 | [
"1509.03005"
] |
1512.04455#23 | Memory-based control with recurrent neural networks | Figure 4 shows the results. 7 2 8 = a 4 0 (a) (b) (c) Figure 4: RDPG was able to learn good policies directly from high-dimensional renderings for pendulum (a), and a two choice reaching task with a disappearing target (b). (c) Example frame from the reaching task. # 5 Discussion # 5.1 Variants In the experiments presented here, the actor and critic networks are entirely disjoint. However, par- ticularly when learning deep, convolutional networks the ï¬ lters required in the early layers may be similar between the policy and the actor. Sharing these early layers could improve computational efï¬ ciency and learning speed. Similar arguments apply to the recurrent part of the network, which could be shared between the actor and the critic. Such sharing, however, can also result in instabili- ties as updates to one network may unknowingly damage or shift the other network. For this reason, we have not used any sharing here, although it is a potential topic for further investigation. # 5.2 Related work There is a large body of literature on solving partially observed control problems. We focus on the most closely related work that aims to solve such problems with learned memory. Several groups [15, 1, 5] have studied the use of model-free algorithms with recurrent networks to solve POMDPs with discrete action spaces. [1] focused on relatively long-horizon (â | 1512.04455#22 | 1512.04455#24 | 1512.04455 | [
"1509.03005"
] |
1512.04455#24 | Memory-based control with recurrent neural networks | deepâ ) memory problems in small state-action spaces. In contrast, [5] modiï¬ ed the Atari DQN architecture [16] (i.e. they perform control from high-dimensional pixel inputs) and demonstrated that recurrent Q learning [15] can perform the required information integration to resolve short-term partial observability (e.g. to estimate velocities) that is achieved via stacks of frames in the original DQN architecture. Continuous action problems with relatively low-dimensional observation spaces have been con- [30] trained LSTM-based stochastic policies using Reinforce; sidered e.g. in [30, 31, 29, 32]. [31, 29, 32] used actor-critic architectures. The algorithm of [31] can be seen as a special case of DPG where the deterministic policy produces the parameters of an action distribution from which the actions are then sampled. This requires suitable exploration at the level of distribution parame- ters (e.g. exploring in terms of means and variances of a Gaussian distribution); in contrast, SVG(0) also learns stochastic policies but allows exploration at the action level only. All works mentioned above, except for [32], consider the memory to be internal to the policy and learn the RNN parameters using BPTT, back-propagating either TD errors or policy gradients. [32] instead take the view of [17] and consider memory as extra state dimensions that can can be read and set by the policy. They optimize the policy using guided policy search [12] which performs explicit trajectory optimization along reference trajectories and, unlike our approach, requires a well deï¬ ned full latent state and access to this latent state during training. | 1512.04455#23 | 1512.04455#25 | 1512.04455 | [
"1509.03005"
] |
1512.04455#25 | Memory-based control with recurrent neural networks | # 6 Conclusion We have demonstrated that two related model-free approaches can be extended to learn effectively with recurrent neural networks on a variety of partially-observed problems, including directly from pixel observations. Since these algorithms learn using standard backpropagation through time, we 8 are able to beneï¬ t from innovations in supervised recurrent neural networks, such as long-short term memory networks [7], to solve challenging memory problems such as the Morris water maze. # References [1] B. Bakker. | 1512.04455#24 | 1512.04455#26 | 1512.04455 | [
"1509.03005"
] |
1512.04455#26 | Memory-based control with recurrent neural networks | Reinforcement learning with long short-term memory. In NIPS, 2002. [2] D. Balduzzi and M. Ghifary. Compatible value gradients for reinforcement learning of contin- uous deep policies. arXiv preprint arXiv:1509.03005, 2015. [3] R. DHooge and P. P. De Deyn. Applications of the morris water maze in the study of learning and memory. Brain research reviews, 36(1):60â | 1512.04455#25 | 1512.04455#27 | 1512.04455 | [
"1509.03005"
] |
1512.04455#27 | Memory-based control with recurrent neural networks | 90, 2001. [4] R. Hafner and M. Riedmiller. Reinforcement learning in feedback control. Machine learning, 84(1-2):137â 169, 2011. [5] M. Hausknecht and P. Stone. Deep recurrent q-learning for partially observable mdps. arXiv preprint arXiv:1507.06527, 2015. [6] N. Heess, G. Wayne, D. Silver, T. Lillicrap, T. Erez, and Y. | 1512.04455#26 | 1512.04455#28 | 1512.04455 | [
"1509.03005"
] |
1512.04455#28 | Memory-based control with recurrent neural networks | Tassa. Learning continuous control policies by stochastic value gradients. In NIPS, 2015. [7] S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural computation, 9(8):1735â 1780, 1997. [8] L. P. Kaelbling, M. L. Littman, and A. R. Cassandra. Planning and acting in partially observ- able stochastic domains. Artiï¬ cial intelligence, 101(1):99â 134, 1998. [9] D. Kingma and J. Ba. Adam: | 1512.04455#27 | 1512.04455#29 | 1512.04455 | [
"1509.03005"
] |
1512.04455#29 | Memory-based control with recurrent neural networks | A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. [10] D. P. Kingma and M. Welling. Auto-encoding variational bayes. CoRR, abs/1312.6114, 2013. [11] A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classiï¬ cation with deep convolutional neural networks. In Advances in neural information processing systems, pages 1097â 1105, 2012. [12] S. Levine, C. Finn, T. Darrell, and P. Abbeel. | 1512.04455#28 | 1512.04455#30 | 1512.04455 | [
"1509.03005"
] |
1512.04455#30 | Memory-based control with recurrent neural networks | End-to-end training of deep visuomotor policies. arXiv preprint arXiv:1504.00702, 2015. [13] F. L. Lewis and D. Vrabie. Reinforcement learning and adaptive dynamic programming for feedback control. Circuits and Systems Magazine, IEEE, 9(3):32â 50, 2009. [14] T. P. Lillicrap, J. J. Hunt, A. Pritzel, N. Heess, T. Erez, Y. Tassa, D. Silver, and D. Wierstra. | 1512.04455#29 | 1512.04455#31 | 1512.04455 | [
"1509.03005"
] |
1512.04455#31 | Memory-based control with recurrent neural networks | Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. [15] L.-J. Lin and T. M. Mitchell. Reinforcement learning with hidden states. In J.-A. Meyer, H. L. Roitblat, and S. W. Wilson, editors, From animals to animats 2, pages 271â 280. MIT Press, Cambridge, MA, USA, 1993. [16] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, et al. | 1512.04455#30 | 1512.04455#32 | 1512.04455 | [
"1509.03005"
] |
1512.04455#32 | Memory-based control with recurrent neural networks | Human-level control through deep rein- forcement learning. Nature, 518(7540):529â 533, 2015. [17] L. Peshkin, N. Meuleau, and L. P. Kaelbling. Learning policies with external memory. In ICML, 1999. [18] A. S. Razavian, H. Azizpour, J. Sullivan, and S. Carlsson. Cnn features off-the-shelf: an astounding baseline for recognition. In Computer Vision and Pattern Recognition Workshops (CVPRW), 2014 IEEE Conference on, pages 512â | 1512.04455#31 | 1512.04455#33 | 1512.04455 | [
"1509.03005"
] |
1512.04455#33 | Memory-based control with recurrent neural networks | 519. IEEE, 2014. [19] D. J. Rezende, S. Mohamed, and D. Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of the 31th International Conference on Machine Learning, ICML 2014, Beijing, China, 21-26 June 2014, pages 1278â 1286, 2014. [20] B. Sallans. Reinforcement learning for factored markov decision processes. | 1512.04455#32 | 1512.04455#34 | 1512.04455 | [
"1509.03005"
] |
1512.04455#34 | Memory-based control with recurrent neural networks | PhD thesis, Cite- seer, 2002. [21] J. Schulman, S. Levine, P. Abbeel, M. I. Jordan, and P. Moritz. Trust region policy optimiza- tion. In ICML, 2015. [22] J. Schulman, P. Moritz, S. Levine, M. I. Jordan, and P. Abbeel. High-dimensional continuous control using generalized advantage estimation. CoRR, abs/1506.02438, 2015. | 1512.04455#33 | 1512.04455#35 | 1512.04455 | [
"1509.03005"
] |
1512.04455#35 | Memory-based control with recurrent neural networks | 9 [23] G. Shani, J. Pineau, and R. Kaplow. A survey of point-based pomdp solvers. Autonomous Agents and Multi-Agent Systems, 27(1):1â 51, 2013. [24] D. Silver, G. Lever, N. Heess, T. Degris, D. Wierstra, and M. Riedmiller. Deterministic policy gradient algorithms. In ICML, 2014. | 1512.04455#34 | 1512.04455#36 | 1512.04455 | [
"1509.03005"
] |
1512.04455#36 | Memory-based control with recurrent neural networks | [25] S. P. Singh. Learning without state-estimation in partially observable markovian decision pro- cesses. In ICML, 1994. [26] P. Thomas. Bias in natural actor-critic algorithms. In Proceedings of The 31st International Conference on Machine Learning, pages 441â 448, 2014. [27] S. Thrun, W. Burgard, and D. Fox. Probabilistic robotics. MIT press, 2005. [28] E. Todorov, T. Erez, and Y. Tassa. | 1512.04455#35 | 1512.04455#37 | 1512.04455 | [
"1509.03005"
] |
1512.04455#37 | Memory-based control with recurrent neural networks | Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pages 5026â 5033. IEEE, 2012. [29] H. Utsunomiya and K. Shibata. Contextual behaviors and internal representations acquired by reinforcement learning with a recurrent neural network in a continuous state and action space task. In M. Kppen, N. Kasabov, and G. Coghill, editors, Advances in Neuro-Information Processing, volume 5507 of Lecture Notes in Computer Science, pages 970â 978. Springer Berlin Heidelberg, 2009. [30] D. Wierstra, A. F¨orster, J. Peters, and J. Schmidhuber. | 1512.04455#36 | 1512.04455#38 | 1512.04455 | [
"1509.03005"
] |
1512.04455#38 | Memory-based control with recurrent neural networks | Solving deep memory pomdps with recurrent policy gradients. In ICANN, 2007. [31] D. Wierstra and J. Schmidhuber. Policy gradient critics. In ECML, 2007. [32] M. Zhang, S. Levine, Z. McCarthy, C. Finn, and P. Abbeel. Policy learning with continuous memory states for partially observed robotic control. CoRR, abs/1507.01273, 2015. | 1512.04455#37 | 1512.04455#39 | 1512.04455 | [
"1509.03005"
] |
1512.04455#39 | Memory-based control with recurrent neural networks | 10 # 7 Supplementary Algorithm 2 RSVG(0) algorithm Initialize critic network Qâ (az, hy) and actor 7°(h,) with parameters w and 0. Initialize target networks Q*â and xâ with weights w! â w, 6â + 0. Initialize replay buffer R. for episodes = 1, Mdo initialize empty history ho fort=1,T do receive observation 0; hy < heâ 1, Gtâ 1, 0; (append observation and previous action to history) select action a, = 7°(h:,v) with v ~ B) end for Store the sequence (01,41, 71...07,a7,1rr) in R a Sample a minibatch of N episodes (0), a, 7}, ...0'p, ap, Tp)i=1,...,n from R Construct histories hi = (o',a4,...ai_4, 04) Compute target values for each sample episode (y{, ...yâ -) using the recurrent target Y= rit 7Q? (bigs. 7? (hig) with v~ B T ) using the recurrent target networks Compute critic update (using BPTT) 0Q* (hi Aw = TL Dwi Qâ (hi, a4) a oon hia) a) | 1512.04455#38 | 1512.04455#40 | 1512.04455 | [
"1509.03005"
] |
1512.04455#40 | Memory-based control with recurrent neural networks | Compute actor update (using BPTT) 1 OQâ (hi, 7° (hi,v)) On? (hi, v) - Aé Nr » » Ja a8 with v~ 8 Update actor and critic using Adam [9] Update the target networks w! & tw t (L-T)w 0 +704 (1-7/0 end for 11 | 1512.04455#39 | 1512.04455 | [
"1509.03005"
] |
|
1512.03385#0 | Deep Residual Learning for Image Recognition | 5 1 0 2 c e D 0 1 ] V C . s c [ 1 v 5 8 3 3 0 . 2 1 5 1 : v i X r a # Deep Residual Learning for Image Recognition # Kaiming He # Xiangyu Zhang # Shaoqing Ren # Jian Sun # Microsoft Research # @microsoft.com kahe, v-xiangz, v-shren, jiansun } { # Abstract | 1512.03385#1 | 1512.03385 | [
"1505.00387"
] |
|
1512.03385#1 | Deep Residual Learning for Image Recognition | Deeper neural networks are more difï¬ cult to train. We present a residual learning framework to ease the training of networks that are substantially deeper than those used previously. We explicitly reformulate the layers as learn- ing residual functions with reference to the layer inputs, in- stead of learning unreferenced functions. We provide com- prehensive empirical evidence showing that these residual networks are easier to optimize, and can gain accuracy from considerably increased depth. On the ImageNet dataset we evaluate residual nets with a depth of up to 152 layersâ | 1512.03385#0 | 1512.03385#2 | 1512.03385 | [
"1505.00387"
] |
1512.03385#2 | Deep Residual Learning for Image Recognition | 8 à deeper than VGG nets [41] but still having lower complex- ity. An ensemble of these residual nets achieves 3.57% error on the ImageNet test set. This result won the 1st place on the ILSVRC 2015 classiï¬ cation task. We also present analysis on CIFAR-10 with 100 and 1000 layers. The depth of representations is of central importance for many visual recognition tasks. Solely due to our ex- tremely deep representations, we obtain a 28% relative im- provement on the COCO object detection dataset. Deep residual nets are foundations of our submissions to ILSVRC & COCO 2015 competitions1, where we also won the 1st places on the tasks of ImageNet detection, ImageNet local- ization, COCO detection, and COCO segmentation. | 1512.03385#1 | 1512.03385#3 | 1512.03385 | [
"1505.00387"
] |
1512.03385#3 | Deep Residual Learning for Image Recognition | # 1. Introduction Deep convolutional neural networks [22, 21] have led to a series of breakthroughs for image classiï¬ cation [21, 50, 40]. Deep networks naturally integrate low/mid/high- level features [50] and classiï¬ ers in an end-to-end multi- layer fashion, and the â levelsâ of features can be enriched by the number of stacked layers (depth). Recent evidence [41, 44] reveals that network depth is of crucial importance, and the leading results [41, 44, 13, 16] on the challenging ImageNet dataset [36] all exploit â very deepâ [41] models, with a depth of sixteen [41] to thirty [16]. Many other non- trivial visual recognition tasks [8, 12, 7, 32, 27] have also and http://mscoco.org/dataset/#detections-challenge2015. | 1512.03385#2 | 1512.03385#4 | 1512.03385 | [
"1505.00387"
] |
1512.03385#4 | Deep Residual Learning for Image Recognition | 56-layer 20-layer 56-layer 20-layer * iter, (led) * ter. (1e4) Figure 1. Training error (left) and test error (right) on CIFAR-10 with 20-layer and 56-layer â plainâ networks. The deeper network has higher training error, and thus test error. Similar phenomena on ImageNet is presented in Fig. 4. greatly beneï¬ ted from very deep models. Driven by the signiï¬ cance of depth, a question arises: | 1512.03385#3 | 1512.03385#5 | 1512.03385 | [
"1505.00387"
] |
1512.03385#5 | Deep Residual Learning for Image Recognition | Is learning better networks as easy as stacking more layers? An obstacle to answering this question was the notorious problem of vanishing/exploding gradients [1, 9], which hamper convergence from the beginning. This problem, however, has been largely addressed by normalized initial- ization [23, 9, 37, 13] and intermediate normalization layers [16], which enable networks with tens of layers to start con- verging for stochastic gradient descent (SGD) with back- propagation [22]. When deeper networks are able to start converging, a degradation problem has been exposed: with the network depth increasing, accuracy gets saturated (which might be unsurprising) and then degrades rapidly. Unexpectedly, such degradation is not caused by overï¬ tting, and adding more layers to a suitably deep model leads to higher train- ing error, as reported in [11, 42] and thoroughly veriï¬ ed by our experiments. Fig. 1 shows a typical example. | 1512.03385#4 | 1512.03385#6 | 1512.03385 | [
"1505.00387"
] |
1512.03385#6 | Deep Residual Learning for Image Recognition | The degradation (of training accuracy) indicates that not all systems are similarly easy to optimize. Let us consider a shallower architecture and its deeper counterpart that adds more layers onto it. There exists a solution by construction to the deeper model: the added layers are identity mapping, and the other layers are copied from the learned shallower model. The existence of this constructed solution indicates that a deeper model should produce no higher training error than its shallower counterpart. But experiments show that our current solvers on hand are unable to ï¬ nd solutions that 1 | 1512.03385#5 | 1512.03385#7 | 1512.03385 | [
"1505.00387"
] |
1512.03385#7 | Deep Residual Learning for Image Recognition | x y weight layer F(x) V relu x weight layer identity Figure 2. Residual learning: a building block. are comparably good or better than the constructed solution (or unable to do so in feasible time). In this paper, we address the degradation problem by introducing a deep residual In- stead of hoping each few stacked layers directly ï¬ t a desired underlying mapping, we explicitly let these lay- ers ï¬ t a residual mapping. Formally, denoting the desired (x), we let the stacked nonlinear underlying mapping as x. The orig- layers ï¬ t another mapping of (x) F inal mapping is recast into (x)+x. We hypothesize that it is easier to optimize the residual mapping than to optimize the original, unreferenced mapping. To the extreme, if an identity mapping were optimal, it would be easier to push the residual to zero than to ï¬ t an identity mapping by a stack of nonlinear layers. (x) + x can be realized by feedfor- ward neural networks with â | 1512.03385#6 | 1512.03385#8 | 1512.03385 | [
"1505.00387"
] |
1512.03385#8 | Deep Residual Learning for Image Recognition | shortcut connectionsâ (Fig. 2). Shortcut connections [2, 34, 49] are those skipping one or more layers. In our case, the shortcut connections simply perform identity mapping, and their outputs are added to Identity short- the outputs of the stacked layers (Fig. 2). cut connections add neither extra parameter nor computa- tional complexity. The entire network can still be trained end-to-end by SGD with backpropagation, and can be eas- ily implemented using common libraries (e.g., Caffe [19]) without modifying the solvers. We present comprehensive experiments on ImageNet [36] to show the degradation problem and evaluate our method. We show that: 1) Our extremely deep residual nets are easy to optimize, but the counterpart â | 1512.03385#7 | 1512.03385#9 | 1512.03385 | [
"1505.00387"
] |
1512.03385#9 | Deep Residual Learning for Image Recognition | plainâ nets (that simply stack layers) exhibit higher training error when the depth increases; 2) Our deep residual nets can easily enjoy accuracy gains from greatly increased depth, producing re- sults substantially better than previous networks. Similar phenomena are also shown on the CIFAR-10 set [20], suggesting that the optimization difï¬ culties and the effects of our method are not just akin to a particular dataset. We present successfully trained models on this dataset with over 100 layers, and explore models with over 1000 layers. On the ImageNet classiï¬ cation dataset [36], we obtain excellent results by extremely deep residual nets. Our 152- layer residual net is the deepest network ever presented on ImageNet, while still having lower complexity than VGG nets [41]. Our ensemble has 3.57% top-5 error on the | 1512.03385#8 | 1512.03385#10 | 1512.03385 | [
"1505.00387"
] |
1512.03385#10 | Deep Residual Learning for Image Recognition | 2 ImageNet test set, and won the 1st place in the ILSVRC 2015 classiï¬ cation competition. The extremely deep rep- resentations also have excellent generalization performance on other recognition tasks, and lead us to further win the 1st places on: ImageNet detection, ImageNet localization, COCO detection, and COCO segmentation in ILSVRC & COCO 2015 competitions. This strong evidence shows that the residual learning principle is generic, and we expect that it is applicable in other vision and non-vision problems. | 1512.03385#9 | 1512.03385#11 | 1512.03385 | [
"1505.00387"
] |
1512.03385#11 | Deep Residual Learning for Image Recognition | # 2. Related Work Residual Representations. In image recognition, VLAD [18] is a representation that encodes by the residual vectors with respect to a dictionary, and Fisher Vector [30] can be formulated as a probabilistic version [18] of VLAD. Both of them are powerful shallow representations for image re- trieval and classiï¬ cation [4, 48]. For vector quantization, encoding residual vectors [17] is shown to be more effec- tive than encoding original vectors. In low-level vision and computer graphics, for solv- ing Partial Differential Equations (PDEs), the widely used Multigrid method [3] reformulates the system as subprob- lems at multiple scales, where each subproblem is respon- sible for the residual solution between a coarser and a ï¬ | 1512.03385#10 | 1512.03385#12 | 1512.03385 | [
"1505.00387"
] |
1512.03385#12 | Deep Residual Learning for Image Recognition | ner scale. An alternative to Multigrid is hierarchical basis pre- conditioning [45, 46], which relies on variables that repre- sent residual vectors between two scales. It has been shown [3, 45, 46] that these solvers converge much faster than stan- dard solvers that are unaware of the residual nature of the solutions. These methods suggest that a good reformulation or preconditioning can simplify the optimization. Shortcut Connections. Practices and theories that lead to shortcut connections [2, 34, 49] have been studied for a long time. An early practice of training multi-layer perceptrons (MLPs) is to add a linear layer connected from the network input to the output [34, 49]. In [44, 24], a few interme- diate layers are directly connected to auxiliary classiï¬ ers for addressing vanishing/exploding gradients. The papers of [39, 38, 31, 47] propose methods for centering layer re- sponses, gradients, and propagated errors, implemented by shortcut connections. In [44], an â inceptionâ layer is com- posed of a shortcut branch and a few deeper branches. Concurrent with our work, â highway networksâ [42, 43] present shortcut connections with gating functions [15]. These gates are data-dependent and have parameters, in contrast to our identity shortcuts that are parameter-free. When a gated shortcut is â closedâ (approaching zero), the layers in highway networks represent non-residual func- tions. On the contrary, our formulation always learns residual functions; our identity shortcuts are never closed, and all information is always passed through, with addi- tional residual functions to be learned. In addition, high- way networks have not demonstrated accuracy gains with extremely increased depth (e.g., over 100 layers). # 3. Deep Residual Learning # 3.1. Residual Learning (x) as an underlying mapping to be ï¬ t by a few stacked layers (not necessarily the entire net), with x denoting the inputs to the ï¬ rst of these layers. | 1512.03385#11 | 1512.03385#13 | 1512.03385 | [
"1505.00387"
] |
1512.03385#13 | Deep Residual Learning for Image Recognition | If one hypothesizes that multiple nonlinear layers can asymptoti- cally approximate complicated functions2, then it is equiv- alent to hypothesize that they can asymptotically approxi- mate the residual functions, i.e., x (assuming that the input and output are of the same dimensions). So rather than expect stacked layers to approximate (x), we explicitly let these layers approximate a residual function x. The original function thus becomes (x) := F (x)+x. Although both forms should be able to asymptot- F ically approximate the desired functions (as hypothesized), the ease of learning might be different. This reformulation is motivated by the counterintuitive phenomena about the degradation problem (Fig. 1, left). As we discussed in the introduction, if the added layers can be constructed as identity mappings, a deeper model should have training error no greater than its shallower counter- part. The degradation problem suggests that the solvers might have difï¬ culties in approximating identity mappings by multiple nonlinear layers. With the residual learning re- formulation, if identity mappings are optimal, the solvers may simply drive the weights of the multiple nonlinear lay- ers toward zero to approach identity mappings. In real cases, it is unlikely that identity mappings are op- timal, but our reformulation may help to precondition the If the optimal function is closer to an identity problem. mapping than to a zero mapping, it should be easier for the solver to ï¬ nd the perturbations with reference to an identity mapping, than to learn the function as a new one. We show by experiments (Fig. 7) that the learned residual functions in general have small responses, suggesting that identity map- pings provide reasonable preconditioning. # 3.2. Identity Mapping by Shortcuts | 1512.03385#12 | 1512.03385#14 | 1512.03385 | [
"1505.00387"
] |
1512.03385#14 | Deep Residual Learning for Image Recognition | We adopt residual learning to every few stacked layers. A building block is shown in Fig. 2. Formally, in this paper we consider a building block deï¬ ned as: (x, Wi y = (1) ) + x. } { Here x and y are the input and output vectors of the lay- ers considered. The function ) represents the } residual mapping to be learned. For the example in Fig. 2 = W2Ï (W1x) in which Ï denotes that has two layers, # F # F | 1512.03385#13 | 1512.03385#15 | 1512.03385 | [
"1505.00387"
] |
1512.03385#15 | Deep Residual Learning for Image Recognition | 2This hypothesis, however, is still an open question. See [28]. 3 ReLU [29] and the biases are omitted for simplifying no- tations. The operation + x is performed by a shortcut connection and element-wise addition. We adopt the sec- ond nonlinearity after the addition (i.e., Ï (y), see Fig. 2). The shortcut connections in Eqn.(1) introduce neither ex- tra parameter nor computation complexity. This is not only attractive in practice but also important in our comparisons between plain and residual networks. We can fairly com- pare plain/residual networks that simultaneously have the same number of parameters, depth, width, and computa- tional cost (except for the negligible element-wise addition). must be equal in Eqn.(1). F If this is not the case (e.g., when changing the input/output channels), we can perform a linear projection Ws by the shortcut connections to match the dimensions: y = (x, Wi (2) ) + Wsx. } # F { | 1512.03385#14 | 1512.03385#16 | 1512.03385 | [
"1505.00387"
] |
1512.03385#16 | Deep Residual Learning for Image Recognition | We can also use a square matrix Ws in Eqn.(1). But we will show by experiments that the identity mapping is sufï¬ cient for addressing the degradation problem and is economical, and thus Ws is only used when matching dimensions. is ï¬ exible. Exper- The form of the residual function F iments in this paper involve a function that has two or three layers (Fig. 5), while more layers are possible. But if has only a single layer, Eqn.(1) is similar to a linear layer: F y = W1x + x, for which we have not observed advantages. We also note that although the above notations are about fully-connected layers for simplicity, they are applicable to convolutional layers. The function ) can repre- } sent multiple convolutional layers. The element-wise addi- tion is performed on two feature maps, channel by channel. | 1512.03385#15 | 1512.03385#17 | 1512.03385 | [
"1505.00387"
] |
1512.03385#17 | Deep Residual Learning for Image Recognition | # 3.3. Network Architectures We have tested various plain/residual nets, and have ob- served consistent phenomena. To provide instances for dis- cussion, we describe two models for ImageNet as follows. Plain Network. Our plain baselines (Fig. 3, middle) are mainly inspired by the philosophy of VGG nets [41] (Fig. 3, left). The convolutional layers mostly have 3 3 ï¬ lters and à follow two simple design rules: (i) for the same output feature map size, the layers have the same number of ï¬ l- ters; and (ii) if the feature map size is halved, the num- ber of ï¬ lters is doubled so as to preserve the time com- plexity per layer. We perform downsampling directly by convolutional layers that have a stride of 2. The network ends with a global average pooling layer and a 1000-way fully-connected layer with softmax. The total number of weighted layers is 34 in Fig. 3 (middle). It is worth noticing that our model has fewer ï¬ lters and lower complexity than VGG nets [41] (Fig. 3, left). Our 34- layer baseline has 3.6 billion FLOPs (multiply-adds), which is only 18% of VGG-19 (19.6 billion FLOPs). # VGG-19 # 34-layer plain # 34-layer residual image image output 3x3 conv, 64 size: 224 u Â¥ 3x3 conv, 64 pool, /2 output size: 112 3x3 conv, 128 Â¥v 3x3 conv, 128 â | 1512.03385#16 | 1512.03385#18 | 1512.03385 | [
"1505.00387"
] |
1512.03385#18 | Deep Residual Learning for Image Recognition | 7x7 conv, 64, /2 v v pool, /2 pool, /2 output see56 [333 ony 256 2 conw 64 Â¥v Â¥ Ba con 256 Ba con 6 38 conv, 56 Ba con 64 Â¥ Â¥ 38 conv, 256 Ba con 64 v 3x3 conv, 64 Ba conv, 64 5 Za pool, /2 3x3 conv, 128, /2 output sue28 Tagen Bacon 28 Â¥ Ba conv, 512 Bid conv, 128 Â¥v Â¥v Ba conv, S12 Bid conv, 198 Bd conv, S12 Bid conv, 128 v 3rd conv, 128 3d conv, 198 Bd conv, 128 output WOO size: 14 pool, /2 3x3 conv, 256, /2 3d conv, SD 3rd conv, 256 Â¥v es Bacon Sia Bacon B56 Â¥v Â¥ Bacon 52 3a conv 256 Been sz 33 conv, 256 Â¥ BS eon 256 3rd conv, 256 3x3 con, 256 Ba conv, 256 Bed eon 256 Â¥ 3rd conv, 256 3rd conv, 256 utput Vo cue pool, /2 30d conv, 512, 2 sive: 7 v 3d conv, 52 Bd conv, 512 Â¥v Ba conv, 512 3rd conv, 52 3x3 conv, 52 Â¥ output 7.4096 avg pool size:1 Â¥v # image â 7x7 conv, 64, /2 v pool, /2 # [3 conv 6a Â¥v [acon 6a # [scom6a Â¥ [secon ea # 3rd conv, 64 # Bid conv, 64 c= [36 conv, 128,72 # (arenas ee Bad conv, 128 Â¥v # Bd con, 128 # Bd conv, 128 Â¥ # Bd eony, 28 # Bid conv, 128 # Bid conv, 128 # EEE 3x3 conv, 256, /2 # 3a conv, 256 | 1512.03385#17 | 1512.03385#19 | 1512.03385 | [
"1505.00387"
] |
1512.03385#19 | Deep Residual Learning for Image Recognition | # [amenase v [scones # [pean ¥v [eens # Bad conv, 256 # 3rd conv, 256 # Bed conv, 256 # [eens # Bad conv, 256 3rd conv, 256 3xd conv, 512, 72 ¥v # Wes = # Bd conv, 51D # Bd conv, 512 v # Bd conv, 512 # 3rd conv, 512 # 3rd conv, S12 | 1512.03385#18 | 1512.03385#20 | 1512.03385 | [
"1505.00387"
] |
1512.03385#20 | Deep Residual Learning for Image Recognition | # avg pool 64096 1000 %1000 7 1000 Figure 3. Example network architectures for ImageNet. Left: the VGG-19 model [41] (19.6 billion FLOPs) as a reference. Mid- dle: a plain network with 34 parameter layers (3.6 billion FLOPs). Right: a residual network with 34 parameter layers (3.6 billion FLOPs). The dotted shortcuts increase dimensions. Table 1 shows more details and other variants. 4 | 1512.03385#19 | 1512.03385#21 | 1512.03385 | [
"1505.00387"
] |
1512.03385#21 | Deep Residual Learning for Image Recognition | Residual Network. Based on the above plain network, we insert shortcut connections (Fig. 3, right) which turn the network into its counterpart residual version. The identity shortcuts (Eqn.(1)) can be directly used when the input and output are of the same dimensions (solid line shortcuts in Fig. 3). When the dimensions increase (dotted line shortcuts in Fig. 3), we consider two options: (A) The shortcut still performs identity mapping, with extra zero entries padded for increasing dimensions. This option introduces no extra parameter; (B) The projection shortcut in Eqn.(2) is used to match dimensions (done by 1 1 convolutions). For both options, when the shortcuts go across feature maps of two sizes, they are performed with a stride of 2. # 3.4. Implementation Our implementation for ImageNet follows the practice in [21, 41]. The image is resized with its shorter side ran- domly sampled in [256, 480] for scale augmentation [41]. A 224 224 crop is randomly sampled from an image or its horizontal ï¬ ip, with the per-pixel mean subtracted [21]. The standard color augmentation in [21] is used. We adopt batch normalization (BN) [16] right after each convolution and before activation, following [16]. We initialize the weights as in [13] and train all plain/residual nets from scratch. We use SGD with a mini-batch size of 256. The learning rate starts from 0.1 and is divided by 10 when the error plateaus, 104 iterations. We and the models are trained for up to 60 use a weight decay of 0.0001 and a momentum of 0.9. We do not use dropout [14], following the practice in [16]. In testing, for comparison studies we adopt the standard 10-crop testing [21]. For best results, we adopt the fully- convolutional form as in [41, 13], and average the scores at multiple scales (images are resized such that the shorter side is in | 1512.03385#20 | 1512.03385#22 | 1512.03385 | [
"1505.00387"
] |
1512.03385#22 | Deep Residual Learning for Image Recognition | ). } # { 4. Experiments # 4.1. ImageNet Classiï¬ cation We evaluate our method on the ImageNet 2012 classiï¬ - cation dataset [36] that consists of 1000 classes. The models are trained on the 1.28 million training images, and evalu- ated on the 50k validation images. We also obtain a ï¬ nal result on the 100k test images, reported by the test server. We evaluate both top-1 and top-5 error rates. | 1512.03385#21 | 1512.03385#23 | 1512.03385 | [
"1505.00387"
] |
1512.03385#23 | Deep Residual Learning for Image Recognition | Plain Networks. We ï¬ rst evaluate 18-layer and 34-layer plain nets. The 34-layer plain net is in Fig. 3 (middle). The 18-layer plain net is of a similar form. See Table 1 for de- tailed architectures. The results in Table 2 show that the deeper 34-layer plain net has higher validation error than the shallower 18-layer plain net. To reveal the reasons, in Fig. 4 (left) we com- pare their training/validation errors during the training pro- cedure. We have observed the degradation problem - the | 1512.03385#22 | 1512.03385#24 | 1512.03385 | [
"1505.00387"
] |
1512.03385#24 | Deep Residual Learning for Image Recognition | Tayer name | output size T8-layer 34-layer 30-layer 101-layer 152-layer convl | 112x112 7X7, 64, stride 2 3x3 max pool, stride 2 1x1, 64 1x1, 64 1x1, 64 conv2.x | 56x56 [ an | x2 [ et | 3 3x3,64 | x3 3x3,64 | x3 3x3, 64 | x3 a 7 1x1, 256 1x1, 256 1x1, 256 Ix, 128 1x1, 128 1x1, 128 cony3.x | 28x28 [ ae }2 [ a be | x4} | 3x3, 128 | x4 3x3, 128 | x4 3x3, 128 | x8 7 a 1x1, 512 1x1, 512 1x1, 512 1x1, 256 1x1, 256 1x1, 256 2 conv4.x | 14x14 [ poe }= [33 ze | 3x3,256 | x6]] 3x3,256 | x23 |] 3x3,256 | x36 79, 290 HO, 0 1x1, 1024 11, 1024 1x1, 1024 1x1, 512 1x1, 512 1x1, 512 2 convs.x | 7x7 [ Ra }= [ 3383 }s 3x3,512 | x3 | | 3x3,512 | x3 3x3,512 | x3 pone oe 1x1, 2048 1x1, 2048 1x1, 2048 xl average pool, 1000-d fe, softmax FLOPs 18x10" 3.6x10" 3.8x10" 76x10" 11.3x10" Table 1. Architectures for ImageNet. | 1512.03385#23 | 1512.03385#25 | 1512.03385 | [
"1505.00387"
] |
1512.03385#25 | Deep Residual Learning for Image Recognition | Building blocks are shown in brackets (see also Fig. 5), with the numbers of blocks stacked. Down- sampling is performed by conv3 1, conv4 1, and conv5 1 with a stride of 2. â plain-34 l=. . A . : 0 10 30 iter. (1e4) 60} AMA DAM 30 - -----------j4.--=25> ae â ResNet-18 NR aly â ResNet-34 34-layer 205 10 20 30 40 50 iter. (1e4) Figure 4. Training on ImageNet. Thin curves denote training error, and bold curves denote validation error of the center crops. Left: plain networks of 18 and 34 layers. Right: ResNets of 18 and 34 layers. In this plot, the residual networks have no extra parameter compared to their plain counterparts. 18 layers 34 layers plain 27.94 28.54 ResNet 27.88 25.03 | 1512.03385#24 | 1512.03385#26 | 1512.03385 | [
"1505.00387"
] |
1512.03385#26 | Deep Residual Learning for Image Recognition | Table 2. Top-1 error (%, 10-crop testing) on ImageNet validation. Here the ResNets have no extra parameter compared to their plain counterparts. Fig. 4 shows the training procedures. 34-layer plain net has higher training error throughout the whole training procedure, even though the solution space of the 18-layer plain network is a subspace of that of the 34-layer one. We argue that this optimization difï¬ culty is unlikely to be caused by vanishing gradients. These plain networks are trained with BN [16], which ensures forward propagated signals to have non-zero variances. We also verify that the backward propagated gradients exhibit healthy norms with BN. So neither forward nor backward signals vanish. In fact, the 34-layer plain net is still able to achieve compet- itive accuracy (Table 3), suggesting that the solver works to some extent. We conjecture that the deep plain nets may have exponentially low convergence rates, which impact the reducing of the training error3. The reason for such opti- mization difï¬ culties will be studied in the future. | 1512.03385#25 | 1512.03385#27 | 1512.03385 | [
"1505.00387"
] |
1512.03385#27 | Deep Residual Learning for Image Recognition | Residual Networks. Next we evaluate 18-layer and 34- layer residual nets (ResNets). The baseline architectures are the same as the above plain nets, expect that a shortcut connection is added to each pair of 3 3 ï¬ lters as in Fig. 3 (right). In the ï¬ rst comparison (Table 2 and Fig. 4 right), we use identity mapping for all shortcuts and zero-padding for increasing dimensions (option A). So they have no extra parameter compared to the plain counterparts. We have three major observations from Table 2 and Fig. 4. | 1512.03385#26 | 1512.03385#28 | 1512.03385 | [
"1505.00387"
] |
1512.03385#28 | Deep Residual Learning for Image Recognition | First, the situation is reversed with residual learn- ing â the 34-layer ResNet is better than the 18-layer ResNet (by 2.8%). More importantly, the 34-layer ResNet exhibits considerably lower training error and is generalizable to the validation data. This indicates that the degradation problem is well addressed in this setting and we manage to obtain accuracy gains from increased depth. Second, compared to its plain counterpart, the 34-layer 3We have experimented with more training iterations (3Ã ) and still ob- served the degradation problem, suggesting that this problem cannot be feasibly addressed by simply using more iterations. 5 | 1512.03385#27 | 1512.03385#29 | 1512.03385 | [
"1505.00387"
] |
1512.03385#29 | Deep Residual Learning for Image Recognition | model VGG-16 [41] GoogLeNet [44] PReLU-net [13] top-1 err. 28.07 - 24.27 top-5 err. 9.33 9.15 7.38 plain-34 ResNet-34 A ResNet-34 B ResNet-34 C ResNet-50 ResNet-101 28.54 25.03 24.52 24.19 22.85 21.75 21.43 10.02 7.76 7.46 7.40 6.71 6.05 5.71 ResNet-152 Table 3. Error rates (%, 10-crop testing) on ImageNet validation. VGG-16 is based on our test. ResNet-50/101/152 are of option B that only uses projections for increasing dimensions. method VGG [41] (ILSVRCâ 14) GoogLeNet [44] (ILSVRCâ 14) VGG [41] (v5) PReLU-net [13] BN-inception [16] ResNet-34 B ResNet-34 C ResNet-50 ResNet-101 ResNet-152 top-1 err. - - 24.4 21.59 21.99 21.84 21.53 20.74 19.87 19.38 top-5 err. 8.43â 7.89 7.1 5.71 5.81 5.71 5.60 5.25 4.60 4.49 Table 4. | 1512.03385#28 | 1512.03385#30 | 1512.03385 | [
"1505.00387"
] |
1512.03385#30 | Deep Residual Learning for Image Recognition | Error rates (%) of single-model results on the ImageNet validation set (except â reported on the test set). method VGG [41] (ILSVRCâ 14) GoogLeNet [44] (ILSVRCâ 14) VGG [41] (v5) PReLU-net [13] BN-inception [16] ResNet (ILSVRCâ 15) top-5 err. (test) 7.32 6.66 6.8 4.94 4.82 3.57 Table 5. Error rates (%) of ensembles. The top-5 error is on the test set of ImageNet and reported by the test server. ResNet reduces the top-1 error by 3.5% (Table 2), resulting from the successfully reduced training error (Fig. 4 right vs. left). | 1512.03385#29 | 1512.03385#31 | 1512.03385 | [
"1505.00387"
] |
1512.03385#31 | Deep Residual Learning for Image Recognition | This comparison veriï¬ es the effectiveness of residual learning on extremely deep systems. Last, we also note that the 18-layer plain/residual nets are comparably accurate (Table 2), but the 18-layer ResNet converges faster (Fig. 4 right vs. left). When the net is â not overly deepâ (18 layers here), the current SGD solver is still able to ï¬ nd good solutions to the plain net. In this case, the ResNet eases the optimization by providing faster conver- gence at the early stage. | 1512.03385#30 | 1512.03385#32 | 1512.03385 | [
"1505.00387"
] |
1512.03385#32 | Deep Residual Learning for Image Recognition | # Identity vs. Projection Shortcuts. We have shown that 6 256-d ix, 64 yeu 3x3, 64 rela 1x1, 256 Figure 5. A deeper residual function F for ImageNet. Left: a building block (on 56Ã 56 feature maps) as in Fig. 3 for ResNet- 34. Right: a â bottleneckâ building block for ResNet-50/101/152. parameter-free, identity shortcuts help with training. Next we investigate projection shortcuts (Eqn.(2)). In Table 3 we compare three options: (A) zero-padding shortcuts are used for increasing dimensions, and all shortcuts are parameter- free (the same as Table 2 and Fig. 4 right); (B) projec- tion shortcuts are used for increasing dimensions, and other shortcuts are identity; and (C) all shortcuts are projections. Table 3 shows that all three options are considerably bet- ter than the plain counterpart. B is slightly better than A. We argue that this is because the zero-padded dimensions in A indeed have no residual learning. C is marginally better than B, and we attribute this to the extra parameters introduced by many (thirteen) projection shortcuts. But the small dif- ferences among A/B/C indicate that projection shortcuts are not essential for addressing the degradation problem. So we do not use option C in the rest of this paper, to reduce mem- ory/time complexity and model sizes. Identity shortcuts are particularly important for not increasing the complexity of the bottleneck architectures that are introduced below. Deeper Bottleneck Architectures. Next we describe our deeper nets for ImageNet. Because of concerns on the train- ing time that we can afford, we modify the building block as a bottleneck design4. For each residual function , we use a stack of 3 layers instead of 2 (Fig. 5). The three layers are 1 1 layers are responsible for reducing and then increasing (restoring) 3 layer a bottleneck with smaller dimensions, leaving the 3 input/output dimensions. Fig. 5 shows an example, where both designs have similar time complexity. The parameter-free identity shortcuts are particularly im- portant for the bottleneck architectures. | 1512.03385#31 | 1512.03385#33 | 1512.03385 | [
"1505.00387"
] |
1512.03385#33 | Deep Residual Learning for Image Recognition | If the identity short- cut in Fig. 5 (right) is replaced with projection, one can show that the time complexity and model size are doubled, as the shortcut is connected to the two high-dimensional ends. So identity shortcuts lead to more efï¬ cient models for the bottleneck designs. 50-layer ResNet: We replace each 2-layer block in the 4Deeper non-bottleneck ResNets (e.g., Fig. 5 left) also gain accuracy from increased depth (as shown on CIFAR-10), but are not as economical as the bottleneck ResNets. So the usage of bottleneck designs is mainly due to practical considerations. We further note that the degradation problem of plain nets is also witnessed for the bottleneck designs. 34-layer net with this 3-layer bottleneck block, resulting in a 50-layer ResNet (Table 1). We use option B for increasing dimensions. This model has 3.8 billion FLOPs. 101-layer and 152-layer ResNets: We construct 101- layer and 152-layer ResNets by using more 3-layer blocks (Table 1). | 1512.03385#32 | 1512.03385#34 | 1512.03385 | [
"1505.00387"
] |
1512.03385#34 | Deep Residual Learning for Image Recognition | Remarkably, although the depth is signiï¬ cantly increased, the 152-layer ResNet (11.3 billion FLOPs) still has lower complexity than VGG-16/19 nets (15.3/19.6 bil- lion FLOPs). The 50/101/152-layer ResNets are more accurate than the 34-layer ones by considerable margins (Table 3 and 4). We do not observe the degradation problem and thus en- joy signiï¬ cant accuracy gains from considerably increased depth. The beneï¬ ts of depth are witnessed for all evaluation metrics (Table 3 and 4). Comparisons with State-of-the-art Methods. In Table 4 we compare with the previous best single-model results. Our baseline 34-layer ResNets have achieved very compet- itive accuracy. Our 152-layer ResNet has a single-model top-5 validation error of 4.49%. This single-model result outperforms all previous ensemble results (Table 5). We combine six models of different depth to form an ensemble (only with two 152-layer ones at the time of submitting). This leads to 3.57% top-5 error on the test set (Table 5). This entry won the 1st place in ILSVRC 2015. # 4.2. CIFAR-10 and Analysis We conducted more studies on the CIFAR-10 dataset [20], which consists of 50k training images and 10k test- ing images in 10 classes. We present experiments trained on the training set and evaluated on the test set. Our focus is on the behaviors of extremely deep networks, but not on pushing the state-of-the-art results, so we intentionally use simple architectures as follows. The plain/residual architectures follow the form in Fig. 3 32 images, with (middle/right). The network inputs are 32 3 convo- the per-pixel mean subtracted. The ï¬ rst layer is 3 lutions. Then we use a stack of 6n layers with 3 3 convo- lutions on the feature maps of sizes respectively, with 2n layers for each feature map size. | 1512.03385#33 | 1512.03385#35 | 1512.03385 | [
"1505.00387"
] |
1512.03385#35 | Deep Residual Learning for Image Recognition | The numbers of ï¬ lters are respectively. The subsampling is per- formed by convolutions with a stride of 2. The network ends with a global average pooling, a 10-way fully-connected layer, and softmax. There are totally 6n+2 stacked weighted layers. The following table summarizes the architecture: output map size # layers # ï¬ lters 32à 32 1+2n 16 16à 16 2n 32 8à 8 2n 64 When shortcut connections are used, they are connected 3 layers (totally 3n shortcuts). On this to the pairs of 3 dataset we use identity shortcuts in all cases (i.e., option A), | 1512.03385#34 | 1512.03385#36 | 1512.03385 | [
"1505.00387"
] |
1512.03385#36 | Deep Residual Learning for Image Recognition | 7 method Maxout [10] NIN [25] DSN [24] error (%) 9.38 8.81 8.22 FitNet [35] Highway [42, 43] Highway [42, 43] ResNet ResNet ResNet ResNet ResNet ResNet # layers 19 19 32 20 32 44 56 110 1202 # params 2.5M 2.3M 1.25M 8.80 0.27M 8.75 0.46M 7.51 0.66M 7.17 0.85M 6.97 1.7M 19.4M 7.93 8.39 7.54 (7.72±0.16) 6.43 (6.61±0.16) Table 6. Classiï¬ | 1512.03385#35 | 1512.03385#37 | 1512.03385 | [
"1505.00387"
] |
1512.03385#37 | Deep Residual Learning for Image Recognition | cation error on the CIFAR-10 test set. All meth- ods are with data augmentation. For ResNet-110, we run it 5 times and show â best (mean±std)â as in [43]. so our residual models have exactly the same depth, width, and number of parameters as the plain counterparts. We use a weight decay of 0.0001 and momentum of 0.9, and adopt the weight initialization in [13] and BN [16] but with no dropout. These models are trained with a mini- batch size of 128 on two GPUs. We start with a learning rate of 0.1, divide it by 10 at 32k and 48k iterations, and terminate training at 64k iterations, which is determined on a 45k/5k train/val split. We follow the simple data augmen- tation in [24] for training: 4 pixels are padded on each side, 32 crop is randomly sampled from the padded and a 32 image or its horizontal ï¬ | 1512.03385#36 | 1512.03385#38 | 1512.03385 | [
"1505.00387"
] |
1512.03385#38 | Deep Residual Learning for Image Recognition | ip. For testing, we only evaluate the single view of the original 32 à , leading to 20, 32, 44, and 56-layer networks. Fig. 6 (left) shows the behaviors of the plain nets. The deep plain nets suffer from increased depth, and exhibit higher training error when going deeper. This phenomenon is similar to that on ImageNet (Fig. 4, left) and on MNIST (see [42]), suggesting that such an optimization difï¬ culty is a fundamental problem. Fig. 6 (middle) shows the behaviors of ResNets. Also similar to the ImageNet cases (Fig. 4, right), our ResNets manage to overcome the optimization difï¬ culty and demon- strate accuracy gains when the depth increases. We further explore n = 18 that leads to a 110-layer ResNet. | 1512.03385#37 | 1512.03385#39 | 1512.03385 | [
"1505.00387"
] |
1512.03385#39 | Deep Residual Learning for Image Recognition | In this case, we ï¬ nd that the initial learning rate of 0.1 is slightly too large to start converging5. So we use 0.01 to warm up the training until the training error is below 80% (about 400 iterations), and then go back to 0.1 and con- tinue training. The rest of the learning schedule is as done previously. This 110-layer network converges well (Fig. 6, middle). It has fewer parameters than other deep and thin 5With an initial learning rate of 0.1, it starts converging (<90% error) after several epochs, but still reaches similar accuracy. S6-layer 20-layer T 2 3 â + # iter. # (Le) # iter. (1e4) # iter. # (Let) Figure 6. | 1512.03385#38 | 1512.03385#40 | 1512.03385 | [
"1505.00387"
] |
1512.03385#40 | Deep Residual Learning for Image Recognition | Training on CIFAR-10. Dashed lines denote training error, and bold lines denote testing error. Left: plain networks. The error of plain-110 is higher than 60% and not displayed. Middle: ResNets. Right: ResNets with 110 and 1202 layers. F=-plain-20 F=-plain-20 plain-56 Net-20 Iâ ResNet-56 I ResNet-110 0 20 layer index (sorted by magnitude) " Figure 7. Standard deviations (std) of layer responses on CIFAR- 10. The responses are the outputs of each 3Ã 3 layer, after BN and before nonlinearity. Top: the layers are shown in their original order. Bottom: the responses are ranked in descending order. | 1512.03385#39 | 1512.03385#41 | 1512.03385 | [
"1505.00387"
] |
1512.03385#41 | Deep Residual Learning for Image Recognition | training data test data VGG-16 ResNet-101 07+12 VOC 07 test 73.2 76.4 07++12 VOC 12 test 70.4 73.8 Table 7. Object detection mAP (%) on the PASCAL VOC 2007/2012 test sets using baseline Faster R-CNN. See also Ta- ble 10 and 11 for better results. metric VGG-16 ResNet-101 [email protected] 41.5 48.4 mAP@[.5, .95] 21.2 27.2 Table 8. Object detection mAP (%) on the COCO validation set using baseline Faster R-CNN. See also Table 9 for better results. networks such as FitNet [35] and Highway [42] (Table 6), yet is among the state-of-the-art results (6.43%, Table 6). Analysis of Layer Responses. Fig. 7 shows the standard deviations (std) of the layer responses. The responses are the outputs of each 3 3 layer, after BN and before other nonlinearity (ReLU/addition). For ResNets, this analy- sis reveals the response strength of the residual functions. Fig. 7 shows that ResNets have generally smaller responses than their plain counterparts. These results support our ba- sic motivation (Sec.3.1) that the residual functions might be generally closer to zero than the non-residual functions. We also notice that the deeper ResNet has smaller magni- tudes of responses, as evidenced by the comparisons among ResNet-20, 56, and 110 in Fig. 7. When there are more layers, an individual layer of ResNets tends to modify the signal less. Exploring Over 1000 layers. We explore an aggressively deep model of over 1000 layers. We set n = 200 that leads to a 1202-layer network, which is trained as described above. Our method shows no optimization difï¬ culty, and this 103-layer network is able to achieve training error <0.1% (Fig. 6, right). Its test error is still fairly good (7.93%, Table 6). But there are still open problems on such aggressively deep models. | 1512.03385#40 | 1512.03385#42 | 1512.03385 | [
"1505.00387"
] |
1512.03385#42 | Deep Residual Learning for Image Recognition | The testing result of this 1202-layer network is worse than that of our 110-layer network, although both have similar training error. We argue that this is because of overï¬ tting. The 1202-layer network may be unnecessarily large (19.4M) for this small dataset. Strong regularization such as maxout [10] or dropout [14] is applied to obtain the best results ([10, 25, 24, 35]) on this dataset. In this paper, we use no maxout/dropout and just simply impose regular- ization via deep and thin architectures by design, without distracting from the focus on the difï¬ culties of optimiza- tion. But combining with stronger regularization may im- prove results, which we will study in the future. # 4.3. | 1512.03385#41 | 1512.03385#43 | 1512.03385 | [
"1505.00387"
] |
1512.03385#43 | Deep Residual Learning for Image Recognition | Object Detection on PASCAL and MS COCO Our method has good generalization performance on other recognition tasks. Table 7 and 8 show the object de- tection baseline results on PASCAL VOC 2007 and 2012 [5] and COCO [26]. We adopt Faster R-CNN [32] as the de- tection method. Here we are interested in the improvements of replacing VGG-16 [41] with ResNet-101. The detection implementation (see appendix) of using both models is the same, so the gains can only be attributed to better networks. Most remarkably, on the challenging COCO dataset we ob- tain a 6.0% increase in COCOâ s standard metric (mAP@[.5, .95]), which is a 28% relative improvement. This gain is solely due to the learned representations. Based on deep residual nets, we won the 1st places in several tracks in ILSVRC & COCO 2015 competitions: Im- ageNet detection, ImageNet localization, COCO detection, and COCO segmentation. | 1512.03385#42 | 1512.03385#44 | 1512.03385 | [
"1505.00387"
] |
1512.03385#44 | Deep Residual Learning for Image Recognition | The details are in the appendix. 8 # References [1] Y. Bengio, P. Simard, and P. Frasconi. Learning long-term dependen- cies with gradient descent is difï¬ cult. IEEE Transactions on Neural Networks, 5(2):157â 166, 1994. [2] C. M. Bishop. Neural networks for pattern recognition. Oxford university press, 1995. [3] W. L. Briggs, S. F. McCormick, et al. | 1512.03385#43 | 1512.03385#45 | 1512.03385 | [
"1505.00387"
] |
1512.03385#45 | Deep Residual Learning for Image Recognition | A Multigrid Tutorial. Siam, 2000. [4] K. Chatï¬ eld, V. Lempitsky, A. Vedaldi, and A. Zisserman. The devil is in the details: an evaluation of recent feature encoding methods. In BMVC, 2011. [5] M. Everingham, L. Van Gool, C. K. Williams, J. Winn, and A. Zis- serman. | 1512.03385#44 | 1512.03385#46 | 1512.03385 | [
"1505.00387"
] |
1512.03385#46 | Deep Residual Learning for Image Recognition | The Pascal Visual Object Classes (VOC) Challenge. IJCV, pages 303â 338, 2010. [6] S. Gidaris and N. Komodakis. Object detection via a multi-region & semantic segmentation-aware cnn model. In ICCV, 2015. [7] R. Girshick. Fast R-CNN. In ICCV, 2015. [8] R. Girshick, J. Donahue, T. Darrell, and J. Malik. | 1512.03385#45 | 1512.03385#47 | 1512.03385 | [
"1505.00387"
] |
1512.03385#47 | Deep Residual Learning for Image Recognition | Rich feature hier- archies for accurate object detection and semantic segmentation. In CVPR, 2014. [9] X. Glorot and Y. Bengio. Understanding the difï¬ culty of training deep feedforward neural networks. In AISTATS, 2010. [10] I. J. Goodfellow, D. Warde-Farley, M. Mirza, A. Courville, and Y. Bengio. Maxout networks. arXiv:1302.4389, 2013. [11] K. He and J. Sun. | 1512.03385#46 | 1512.03385#48 | 1512.03385 | [
"1505.00387"
] |
1512.03385#48 | Deep Residual Learning for Image Recognition | Convolutional neural networks at constrained time cost. In CVPR, 2015. [12] K. He, X. Zhang, S. Ren, and J. Sun. Spatial pyramid pooling in deep convolutional networks for visual recognition. In ECCV, 2014. [13] K. He, X. Zhang, S. Ren, and J. Sun. Delving deep into rectiï¬ ers: Surpassing human-level performance on imagenet classiï¬ cation. In ICCV, 2015. [14] G. E. Hinton, N. Srivastava, A. Krizhevsky, I. Sutskever, and R. R. Salakhutdinov. | 1512.03385#47 | 1512.03385#49 | 1512.03385 | [
"1505.00387"
] |
1512.03385#49 | Deep Residual Learning for Image Recognition | Improving neural networks by preventing co- adaptation of feature detectors. arXiv:1207.0580, 2012. [15] S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural computation, 9(8):1735â 1780, 1997. [16] S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015. [17] H. Jegou, M. Douze, and C. Schmid. | 1512.03385#48 | 1512.03385#50 | 1512.03385 | [
"1505.00387"
] |
1512.03385#50 | Deep Residual Learning for Image Recognition | Product quantization for nearest neighbor search. TPAMI, 33, 2011. [18] H. Jegou, F. Perronnin, M. Douze, J. Sanchez, P. Perez, and C. Schmid. Aggregating local image descriptors into compact codes. TPAMI, 2012. [19] Y. Jia, E. Shelhamer, J. Donahue, S. Karayev, J. Long, R. Girshick, S. Guadarrama, and T. | 1512.03385#49 | 1512.03385#51 | 1512.03385 | [
"1505.00387"
] |
1512.03385#51 | Deep Residual Learning for Image Recognition | Darrell. Caffe: Convolutional architecture for fast feature embedding. arXiv:1408.5093, 2014. [20] A. Krizhevsky. Learning multiple layers of features from tiny im- ages. Tech Report, 2009. [21] A. Krizhevsky, I. Sutskever, and G. Hinton. Imagenet classiï¬ cation with deep convolutional neural networks. In NIPS, 2012. [22] Y. LeCun, B. Boser, J. S. Denker, D. Henderson, R. E. Howard, W. Hubbard, and L. D. Jackel. | 1512.03385#50 | 1512.03385#52 | 1512.03385 | [
"1505.00387"
] |
1512.03385#52 | Deep Residual Learning for Image Recognition | Backpropagation applied to hand- written zip code recognition. Neural computation, 1989. [23] Y. LeCun, L. Bottou, G. B. Orr, and K.-R. M¨uller. Efï¬ cient backprop. In Neural Networks: Tricks of the Trade, pages 9â 50. Springer, 1998. [24] C.-Y. Lee, S. Xie, P. Gallagher, Z. Zhang, and Z. Tu. Deeply- | 1512.03385#51 | 1512.03385#53 | 1512.03385 | [
"1505.00387"
] |
1512.03385#53 | Deep Residual Learning for Image Recognition | supervised nets. arXiv:1409.5185, 2014. [25] M. Lin, Q. Chen, and S. Yan. Network in network. arXiv:1312.4400, 2013. [26] T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Doll´ar, and C. L. Zitnick. Microsoft COCO: Common objects in context. In ECCV. 2014. [27] J. Long, E. Shelhamer, and T. Darrell. | 1512.03385#52 | 1512.03385#54 | 1512.03385 | [
"1505.00387"
] |
1512.03385#54 | Deep Residual Learning for Image Recognition | Fully convolutional networks for semantic segmentation. In CVPR, 2015. 9 [28] G. Mont´ufar, R. Pascanu, K. Cho, and Y. Bengio. On the number of linear regions of deep neural networks. In NIPS, 2014. [29] V. Nair and G. E. Hinton. Rectiï¬ ed linear units improve restricted boltzmann machines. In ICML, 2010. | 1512.03385#53 | 1512.03385#55 | 1512.03385 | [
"1505.00387"
] |
1512.03385#55 | Deep Residual Learning for Image Recognition | [30] F. Perronnin and C. Dance. Fisher kernels on visual vocabularies for image categorization. In CVPR, 2007. [31] T. Raiko, H. Valpola, and Y. LeCun. Deep learning made easier by linear transformations in perceptrons. In AISTATS, 2012. [32] S. Ren, K. He, R. Girshick, and J. Sun. | 1512.03385#54 | 1512.03385#56 | 1512.03385 | [
"1505.00387"
] |
1512.03385#56 | Deep Residual Learning for Image Recognition | Faster R-CNN: Towards real-time object detection with region proposal networks. In NIPS, 2015. [33] S. Ren, K. He, R. Girshick, X. Zhang, and J. Sun. Object detection networks on convolutional feature maps. arXiv:1504.06066, 2015. [34] B. D. Ripley. Pattern recognition and neural networks. Cambridge university press, 1996. [35] A. Romero, N. Ballas, S. E. Kahou, A. Chassang, C. Gatta, and Y. Bengio. Fitnets: Hints for thin deep nets. | 1512.03385#55 | 1512.03385#57 | 1512.03385 | [
"1505.00387"
] |
1512.03385#57 | Deep Residual Learning for Image Recognition | In ICLR, 2015. [36] O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Imagenet Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, et al. large scale visual recognition challenge. arXiv:1409.0575, 2014. [37] A. M. Saxe, J. L. McClelland, and S. Ganguli. | 1512.03385#56 | 1512.03385#58 | 1512.03385 | [
"1505.00387"
] |
1512.03385#58 | Deep Residual Learning for Image Recognition | Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv:1312.6120, 2013. [38] N. N. Schraudolph. Accelerated gradient descent by factor-centering decomposition. Technical report, 1998. [39] N. N. Schraudolph. Centering neural network gradient factors. In Neural Networks: Tricks of the Trade, pages 207â 226. Springer, 1998. [40] P. Sermanet, D. Eigen, X. Zhang, M. Mathieu, R. Fergus, and Y. Le- Cun. | 1512.03385#57 | 1512.03385#59 | 1512.03385 | [
"1505.00387"
] |
1512.03385#59 | Deep Residual Learning for Image Recognition | Overfeat: Integrated recognition, localization and detection using convolutional networks. In ICLR, 2014. [41] K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015. [42] R. K. Srivastava, K. Greff, and J. Schmidhuber. Highway networks. arXiv:1505.00387, 2015. [43] R. K. Srivastava, K. Greff, and J. Schmidhuber. | 1512.03385#58 | 1512.03385#60 | 1512.03385 | [
"1505.00387"
] |
1512.03385#60 | Deep Residual Learning for Image Recognition | Training very deep networks. 1507.06228, 2015. [44] C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Anguelov, D. Er- han, V. Vanhoucke, and A. Rabinovich. Going deeper with convolu- tions. In CVPR, 2015. [45] R. Szeliski. Fast surface interpolation using hierarchical basis func- tions. | 1512.03385#59 | 1512.03385#61 | 1512.03385 | [
"1505.00387"
] |
1512.03385#61 | Deep Residual Learning for Image Recognition | TPAMI, 1990. [46] R. Szeliski. Locally adapted hierarchical basis preconditioning. In SIGGRAPH, 2006. [47] T. Vatanen, T. Raiko, H. Valpola, and Y. LeCun. Pushing stochas- tic gradient towards second-order methodsâ backpropagation learn- In Neural Information ing with transformations in nonlinearities. Processing, 2013. [48] A. Vedaldi and B. Fulkerson. VLFeat: An open and portable library of computer vision algorithms, 2008. | 1512.03385#60 | 1512.03385#62 | 1512.03385 | [
"1505.00387"
] |
1512.03385#62 | Deep Residual Learning for Image Recognition | [49] W. Venables and B. Ripley. Modern applied statistics with s-plus. 1999. [50] M. D. Zeiler and R. Fergus. Visualizing and understanding convolu- tional neural networks. In ECCV, 2014. # A. Object Detection Baselines In this section we introduce our detection method based on the baseline Faster R-CNN [32] system. The models are initialized by the ImageNet classiï¬ cation models, and then ï¬ ne-tuned on the object detection data. We have experi- mented with ResNet-50/101 at the time of the ILSVRC & COCO 2015 detection competitions. Unlike VGG-16 used in [32], our ResNet has no hidden fc layers. | 1512.03385#61 | 1512.03385#63 | 1512.03385 | [
"1505.00387"
] |
1512.03385#63 | Deep Residual Learning for Image Recognition | We adopt the idea of â Networks on Conv fea- ture mapsâ (NoC) [33] to address this issue. We compute the full-image shared conv feature maps using those lay- ers whose strides on the image are no greater than 16 pixels (i.e., conv1, conv2 x, conv3 x, and conv4 x, totally 91 conv layers in ResNet-101; Table 1). We consider these layers as analogous to the 13 conv layers in VGG-16, and by doing so, both ResNet and VGG-16 have conv feature maps of the same total stride (16 pixels). These layers are shared by a region proposal network (RPN, generating 300 proposals) [32] and a Fast R-CNN detection network [7]. RoI pool- ing [7] is performed before conv5 1. On this RoI-pooled feature, all layers of conv5 x and up are adopted for each region, playing the roles of VGG-16â s fc layers. The ï¬ nal classiï¬ cation layer is replaced by two sibling layers (classi- ï¬ cation and box regression [7]). For the usage of BN layers, after pre-training, we com- pute the BN statistics (means and variances) for each layer on the ImageNet training set. Then the BN layers are ï¬ xed during ï¬ ne-tuning for object detection. As such, the BN layers become linear activations with constant offsets and scales, and BN statistics are not updated by ï¬ ne-tuning. We ï¬ | 1512.03385#62 | 1512.03385#64 | 1512.03385 | [
"1505.00387"
] |
1512.03385#64 | Deep Residual Learning for Image Recognition | x the BN layers mainly for reducing memory consumption in Faster R-CNN training. # PASCAL VOC Following [7, 32], for the PASCAL VOC 2007 test set, we use the 5k trainval images in VOC 2007 and 16k train- val images in VOC 2012 for training (â 07+12â ). For the PASCAL VOC 2012 test set, we use the 10k trainval+test images in VOC 2007 and 16k trainval images in VOC 2012 for training (â 07++12â ). | 1512.03385#63 | 1512.03385#65 | 1512.03385 | [
"1505.00387"
] |
1512.03385#65 | Deep Residual Learning for Image Recognition | The hyper-parameters for train- ing Faster R-CNN are the same as in [32]. Table 7 shows the results. ResNet-101 improves the mAP by >3% over VGG-16. This gain is solely because of the improved fea- tures learned by ResNet. # MS COCO The MS COCO dataset [26] involves 80 object cate- gories. We evaluate the PASCAL VOC metric (mAP @ IoU = 0.5) and the standard COCO metric (mAP @ IoU = .5:.05:.95). We use the 80k images on the train set for train- ing and the 40k images on the val set for evaluation. Our detection system for COCO is similar to that for PASCAL VOC. We train the COCO models with an 8-GPU imple- mentation, and thus the RPN step has a mini-batch size of | 1512.03385#64 | 1512.03385#66 | 1512.03385 | [
"1505.00387"
] |
1512.03385#66 | Deep Residual Learning for Image Recognition | 10 8 images (i.e., 1 per GPU) and the Fast R-CNN step has a mini-batch size of 16 images. The RPN step and Fast R- CNN step are both trained for 240k iterations with a learn- ing rate of 0.001 and then for 80k iterations with 0.0001. Table 8 shows the results on the MS COCO validation set. ResNet-101 has a 6% increase of mAP@[.5, .95] over VGG-16, which is a 28% relative improvement, solely con- tributed by the features learned by the better network. Re- markably, the mAP@[.5, .95]â s absolute increase (6.0%) is nearly as big as [email protected]â s (6.9%). This suggests that a deeper network can improve both recognition and localiza- tion. # B. Object Detection Improvements For completeness, we report the improvements made for the competitions. These improvements are based on deep features and thus should beneï¬ t from residual learning. | 1512.03385#65 | 1512.03385#67 | 1512.03385 | [
"1505.00387"
] |
1512.03385#67 | Deep Residual Learning for Image Recognition | MS COCO Box reï¬ nement. Our box reï¬ nement partially follows the it- erative localization in [6]. In Faster R-CNN, the ï¬ nal output is a regressed box that is different from its proposal box. So for inference, we pool a new feature from the regressed box and obtain a new classiï¬ cation score and a new regressed box. We combine these 300 new predictions with the orig- inal 300 predictions. Non-maximum suppression (NMS) is applied on the union set of predicted boxes using an IoU threshold of 0.3 [8], followed by box voting [6]. | 1512.03385#66 | 1512.03385#68 | 1512.03385 | [
"1505.00387"
] |
1512.03385#68 | Deep Residual Learning for Image Recognition | Box re- ï¬ nement improves mAP by about 2 points (Table 9). Global context. We combine global context in the Fast R-CNN step. Given the full-image conv feature map, we pool a feature by global Spatial Pyramid Pooling [12] (with a â single-levelâ pyramid) which can be implemented as â RoIâ pooling using the entire imageâ s bounding box as the RoI. This pooled feature is fed into the post-RoI layers to obtain a global context feature. This global feature is con- catenated with the original per-region feature, followed by the sibling classiï¬ cation and box regression layers. This new structure is trained end-to-end. Global context im- proves [email protected] by about 1 point (Table 9). Multi-scale testing. In the above, all results are obtained by single-scale training/testing as in [32], where the imageâ s shorter side is s = 600 pixels. Multi-scale training/testing has been developed in [12, 7] by selecting a scale from a feature pyramid, and in [33] by using maxout layers. In our current implementation, we have performed multi-scale testing following [33]; we have not performed multi-scale training because of limited time. In addition, we have per- formed multi-scale testing only for the Fast R-CNN step (but not yet for the RPN step). With a trained model, we compute conv feature maps on an image pyramid, where the 200, 400, 600, 800, 1000 imageâ | 1512.03385#67 | 1512.03385#69 | 1512.03385 | [
"1505.00387"
] |
1512.03385#69 | Deep Residual Learning for Image Recognition | s shorter sides are s . } training data test data mAP baseline Faster R-CNN (VGG-16) baseline Faster R-CNN (ResNet-101) +box reï¬ nement +context +multi-scale testing ensemble COCO train COCO val @.5 41.5 48.4 49.9 51.1 53.8 @[.5, .95] 21.2 27.2 29.9 30.0 32.5 COCO trainval COCO test-dev @.5 @[.5, .95] 53.3 55.7 59.0 32.2 34.9 37.4 | 1512.03385#68 | 1512.03385#70 | 1512.03385 | [
"1505.00387"
] |
1512.03385#70 | Deep Residual Learning for Image Recognition | Table 9. Object detection improvements on MS COCO using Faster R-CNN and ResNet-101. net VGG-16 ResNet-101 data 07+12 07+12 system baseline baseline baseline+++ ResNet-101 COCO+07+12 mAP areo 73.2 76.5 79.0 70.9 65.5 52.1 83.1 84.7 86.4 52.0 81.9 65.7 84.8 84.6 77.5 76.7 38.8 73.6 73.9 83.0 72.6 76.4 79.8 80.7 76.2 68.3 55.9 85.1 85.3 89.8 56.7 87.8 69.4 88.3 88.9 80.9 78.4 41.7 78.6 79.8 85.3 72.0 85.6 90.0 89.6 87.8 80.8 76.1 89.9 89.9 89.6 75.5 90.0 80.7 89.6 90.3 89.1 88.7 65.4 88.1 85.6 89.0 86.8 bike bird boat bottle bus car cat chair cow table dog horse mbike person plant sheep sofa train tv | 1512.03385#69 | 1512.03385#71 | 1512.03385 | [
"1505.00387"
] |
1512.03385#71 | Deep Residual Learning for Image Recognition | Table 10. Detection results on the PASCAL VOC 2007 test set. The baseline is the Faster R-CNN system. The system â baseline+++â include box reï¬ nement, context, and multi-scale testing in Table 9. mAP areo 70.4 84.9 79.8 74.3 53.9 49.8 77.5 75.9 88.5 45.6 77.1 55.3 86.9 81.7 80.9 79.6 40.1 72.6 60.9 81.2 61.5 baseline baseline 73.8 86.5 81.6 77.2 58.0 51.0 78.6 76.6 93.2 48.6 80.4 59.0 92.1 85.3 84.8 80.7 48.1 77.3 66.5 84.7 65.6 baseline+++ ResNet-101 COCO+07++12 83.8 92.1 88.4 84.8 75.9 71.4 86.3 87.8 94.2 66.8 89.4 69.2 93.9 91.9 90.9 89.6 67.9 88.2 76.8 90.3 80.0 net VGG-16 ResNet-101 data 07++12 07++12 system bike bird boat bottle bus car cat chair cow table dog horse mbike person plant sheep sofa train Table 11. Detection results on the PASCAL VOC 2012 test set (http://host.robots.ox.ac.uk:8080/leaderboard/ displaylb.php?challengeid=11&compid=4). The baseline is the Faster R-CNN system. | 1512.03385#70 | 1512.03385#72 | 1512.03385 | [
"1505.00387"
] |
1512.03385#72 | Deep Residual Learning for Image Recognition | The system â baseline+++â include box reï¬ nement, context, and multi-scale testing in Table 9. tv We select two adjacent scales from the pyramid following [33]. RoI pooling and subsequent layers are performed on the feature maps of these two scales [33], which are merged by maxout as in [33]. Multi-scale testing improves the mAP by over 2 points (Table 9). GoogLeNet [44] (ILSVRCâ 14) our single model (ILSVRCâ 15) our ensemble (ILSVRCâ 15) val2 - 60.5 63.6 test 43.9 58.8 62.1 Using validation data. Next we use the 80k+40k trainval set for training and the 20k test-dev set for evaluation. The test- dev set has no publicly available ground truth and the result is reported by the evaluation server. Under this setting, the results are an [email protected] of 55.7% and an mAP@[.5, .95] of 34.9% (Table 9). This is our single-model result. Ensemble. In Faster R-CNN, the system is designed to learn region proposals and also object classiï¬ ers, so an ensemble can be used to boost both tasks. We use an ensemble for proposing regions, and the union set of proposals are pro- cessed by an ensemble of per-region classiï¬ ers. Table 9 shows our result based on an ensemble of 3 networks. The mAP is 59.0% and 37.4% on the test-dev set. This result won the 1st place in the detection task in COCO 2015. # PASCAL VOC We revisit the PASCAL VOC dataset based on the above model. With the single model on the COCO dataset (55.7% [email protected] in Table 9), we ï¬ ne-tune this model on the PAS- CAL VOC sets. The improvements of box reï¬ nement, con- text, and multi-scale testing are also adopted. By doing so Table 12. | 1512.03385#71 | 1512.03385#73 | 1512.03385 | [
"1505.00387"
] |
1512.03385#73 | Deep Residual Learning for Image Recognition | Our results (mAP, %) on the ImageNet detection dataset. Our detection system is Faster R-CNN [32] with the improvements in Table 9, using ResNet-101. we achieve 85.6% mAP on PASCAL VOC 2007 (Table 10) and 83.8% on PASCAL VOC 2012 (Table 11)6. The result on PASCAL VOC 2012 is 10 points higher than the previ- ous state-of-the-art result [6]. # ImageNet Detection The ImageNet Detection (DET) task involves 200 object categories. The accuracy is evaluated by [email protected]. Our object detection algorithm for ImageNet DET is the same as that for MS COCO in Table 9. The networks are pre- trained on the 1000-class ImageNet classiï¬ | 1512.03385#72 | 1512.03385#74 | 1512.03385 | [
"1505.00387"
] |
1512.03385#74 | Deep Residual Learning for Image Recognition | cation set, and are ï¬ ne-tuned on the DET data. We split the validation set into two parts (val1/val2) following [8]. We ï¬ ne-tune the detection models using the DET training set and the val1 set. The val2 set is used for validation. We do not use other ILSVRC 2015 data. Our single model with ResNet-101 has 6http://host.robots.ox.ac.uk:8080/anonymous/3OJ4OJ.html, submitted on 2015-11-26. 11 | 1512.03385#73 | 1512.03385#75 | 1512.03385 | [
"1505.00387"
] |
1512.03385#75 | Deep Residual Learning for Image Recognition | LOC network VGGâ s [41] VGG-16 LOC method testing 1-crop ResNet-101 1-crop ResNet-101 dense ResNet-101 dense RPN+RCNN ResNet-101 dense RPN+RCNN ensemble dense RPN RPN RPN LOC error on GT CLS 33.1 [41] 13.3 11.7 classiï¬ cation network ResNet-101 ResNet-101 ensemble top-5 LOC error on predicted CLS 14.4 10.6 8.9 Table 13. Localization error (%) on the ImageNet validation. In the column of â LOC error on GT classâ ([41]), the ground truth class is used. In the â testingâ column, â 1-cropâ denotes testing on a center crop of 224à 224 pixels, â denseâ denotes dense (fully convolutional) and multi-scale testing. 58.8% mAP and our ensemble of 3 models has 62.1% mAP on the DET test set (Table 12). This result won the 1st place in the ImageNet detection task in ILSVRC 2015, surpassing the second place by 8.5 points (absolute). | 1512.03385#74 | 1512.03385#76 | 1512.03385 | [
"1505.00387"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.