On the Importance of Stereo for Accurate Depth Estimation: An Efficient Semi-Supervised Deep Neural Network Approach
Nikolai Smolyanskiy Alexey Kamenev Stan Birchfield



















  
    
  
    
  




  
    
      
      
    
    
    
  
  







  
  
  
    
    
  
    
      
      
    
      
      
      
      
      
      
      
      
    
  
  
  
































On the Importance of Stereo for Accurate Depth Estimation: 

An Efficient Semi-Supervised Deep Neural Network Approach
    Nikolai Smolyanskiy     Alexey Kamenev     Stan Birchfield 

NVIDIA 

{nsmolyanskiy, akamenev, sbirchfield}@nvidia.com
    
==========================================================================================================================

empty










   
   
   
   
   
   
   
	We revisit the problem of visual depth estimation in the context of autonomous vehicles.
	Despite the progress on monocular depth estimation in recent years, we show
	that the gap between monocular and stereo depth accuracy remains large—a particularly relevant result due to the prevalent reliance upon monocular 
	cameras by vehicles that are expected to be self-driving.
	We argue that the challenges of removing this gap are significant, owing to fundamental limitations
	of monocular vision.  
	As a result, we focus our efforts on depth estimation by stereo.
	We propose a novel semi-supervised learning approach to training a deep stereo neural network, along with a novel architecture containing a machine-learned argmax layer and a custom runtime that enables a smaller version of our stereo DNN to run on an embedded GPU.  Competitive results are shown on the KITTI 2015 stereo dataset.  We also evaluate the recent progress of stereo algorithms
	by measuring the impact upon accuracy of various design criteria.[Video of the system is at <https://youtu.be/0FPQdVOYoAU>.] 
	
	
	
	
	
	
	
	





§ INTRODUCTION




Estimating depth from images is a long-standing problem in computer vision.  Depth perception is useful for scene understanding, scene reconstruction, virtual and augmented reality, obstacle avoidance, self-driving cars, robotics, and other applications.

Traditionally, multiple images have been used to estimate depth.  Techniques that fall within this category include stereo, photometric stereo, depth from focus, depth from defocus, time-of-flight,[Although time-of-flight does not, in theory require multiple images, in practice multiple images are collected with different bandwidths in order to achieve high accuracy over long ranges.] and structure from motion.  The reasons for using multiple images are twofold:  1) absolute depth estimates require at least one known distance in the world, which can often be provided by some knowledge regarding the multi-camera rig (e.g., the baseline between stereo cameras); and 2) multiple images provide geometric constraints that can be leveraged to overcome the many ambiguities of photometric data.

The alternative is to use a single image to estimate depth.  We argue that this alternative—due to its fundamental limitations—is not likely to be able to achieve high-accuracy depth estimation at large distances in unfamiliar environments.  As a result, in the context of self-driving cars we believe monocular depth estimation is not likely to yield results with sufficient accuracy.  In contrast, we offer a novel, efficient deep-learning stereo approach that achieves compelling results on the KITTI 2015 dataset by leveraging a semi-supervised loss function (using LIDAR and photometric consistency), concatenating cost volume, 3D convolutions, and a machine-learned argmax function.  The contributions of the paper are as follows:


	
  * Quantitative and qualitative demonstration of the gap in depth accuracy between monocular and stereoscopic depth.
	
  * A novel semi-supervised approach (combining lidar and photometric losses) to training a deep stereo neural network.  To our knowledge, ours is the first deep stereo network to do so.[Similarly, Kuznietsov et al. <cit.> use a semi-supervised approach for training a monocular network.]
	
  * A smaller version of our network, and a custom runtime, that runs at near real-time (∼20 fps) on a standard GPU, and runs efficiently on an embedded GPU.  To our knowledge, ours is the first stereo DNN to run on an embedded GPU.
	
  * Quantitative analysis of various network design choices, along with a novel machine-learned argmax layer that yields smoother disparity maps.
	





§ MOTIVATION







The undeniable success of deep neural networks in computer vision has encouraged researchers to pursue the problem of estimating depth from a single image <cit.>.  This is, no doubt, a noble endeavor:  if it were possible to accurately estimate depth from a single image, then the complexity (and hence cost) of the hardware needed would be dramatically reduced, which would broaden the applicability substantially.  An excellent overview of existing work on monocular depth estimation can be found in <cit.>.

Nevertheless, there are reasons to be cautious about the reported success of monocular depth.  To date, monocular depth solutions, while yielding encouraging preliminary results, are not at the point where reliable information (from a robotics point of view) can be expected from them.  And although such solutions will continue to improve, monocular depth will never overcome well-known fundamental limitations, such as the need for a world measurement to infer absolute depth, and the ambiguity that arises when a photograph is taken of a photograph (an important observation for biometric and security systems).  



One of the motivations for monocular depth is a long-standing belief that stereo is only useful at close range.  It has been widely reported, for example in <cit.>, that beyond about 6 meters, the human visual system is essentially monocular.  But there is mounting evidence that the human stereo system is actually much more capable than that.  Multiple studies have shown metric depth estimation up to 20 meters <cit.>; and, although error increases as disparity increases <cit.>, controlled experiments have confirmed that scaled disparity can be estimated up to 300 m, even without any depth cues from monocular vision <cit.>.  Moreover, since the human visual system is capable of estimating disparity as small as a few seconds of arc <cit.>, there is reason to believe that the distance could be 1 km or greater, with some evidence supporting such a claim provided by the experiments of <cit.>.  Note that an artificial stereo system whose baseline is wider than the average 65 mm interpupillary distance of the human visual system has the potential to provide even greater accuracy.



This question takes on renewed significance in the context of self-driving cars, since most automobile manufacturers and experimental autonomous vehicles do not install stereo cameras in their vehicles.[To the authors' knowledge, at the time of this writing stereo cameras can be found only on certain models of Mercedes and Subaru vehicles; no major autonomous platform uses them.] Rather, these systems rely on various combinations of monocular cameras, lidar, radar, and sonar sensors.[Tesla vehicles, for example, are equipped with monocular cameras, sonar, and radar, but no lidar.  Despite having multiple foveated cameras for wider field of view, such vehicles do not rely upon depth from stereopsis.] For detecting static obstacles such as trees, poles, railings, and concrete barriers, most systems rely on cameras and/or lidar.  Although it is beyond the scope of this paper whether monocular cameras are sufficient for self-driving behavior (certainly people with monocular vision can drive safely in most situations), or whether stereo is better than lidar, we argue that the proper engineering approach to such a safety-critical system is to leverage all available sensors rather than assume they are not needed; thus, we believe that it is important to accurately assess the increased error in depth estimation when relying upon monocular cameras.






















































At typical highway speeds, the braking distance required to completely stop before impact necessitates observing an unforeseen stopped object approximately 100 m away.  Intrigued by the reported success of monocular depth, we tried some recent algorithms, only to discover that monocular depth is not able to achieve accuracies anywhere close to that requirement.  We then turned our attention to stereo, where significant progress has been made in recent years in applying deep learning to the problem <cit.>.  An excellent overview of recent stereo algorithms can be found in <cit.>.  In this flurry of activity, a variety of architectures have been proposed, but there has been no systematic study as to how these design choices impact quality. One purpose of this paper is thus to investigate several of these options in order to quantify their impact, which we do in Sec. <ref>.  In the context of this study, we develop a novel semi-supervised stereo approach, which we present in Sec. <ref>.  First, however, we illustrate the limitations of monocular depth estimation in the next section.





























§ DIFFICULTIES OF MONOCULAR DEPTH ESTIMATION




To appreciate the gap between mono and stereo vision, consider the image of Fig. <ref>, with several points of interest highlighted.  Without knowing the scene, if you were to ask yourself whether the width of the near road (on which the car (A) sits) is greater than the width of the far tracks (distance between the near and far poles (E and F)), you might be tempted to answer in the affirmative.  After all, the road not only occupies more pixels in the image (which is to be expected, since it is closer to the camera), but it occupies orders of magnitude more pixels.  We showed this image to several people in our lab, and they all reached the same conclusion:  the road indeed appears to be significantly wider.  As it turns out, if this image is any indication, people are not very good at estimating metric depth from a single image.[Specifically, we asked 8 people to estimate the distance to the fence (ground truth 14 m) and the distance to the building (ground truth 30 m).  Their estimates on average were 9.3 m and 12.4 m, respectively.  The distances were therefore underestimated by 34% and 59%, respectively, and the distance from the fence to the building was underestimated by 81%.]






The output of a leading monocular depth algorithm, called MonoDepth <cit.>, is shown in Fig. <ref>,[Other monocular algorithms produce similar results.] along with the output of our stereo depth algorithm.  At first glance, both results appear plausible.  Although the stereo algorithm preserves crisper object boundaries and appears at least slightly more accurate, it is difficult to tell from the grayscale images just how much the two results differ.  









  
  
	
	

   



In fact, the differences are quite large.  To better appreciate these differences, Fig. <ref> shows a top-down view of the point clouds associated with the depth/disparity maps with the ground truth LIDAR data overlaid.  These results reveal that monocular depth is not only inaccurate in an absolute sense (due to the overall scale ambiguity from a single images), it is also inaccurate in recovering details.  In fact, of the 8 objects of interest highlighted in Fig. 1, the monocular algorithm misses nearly all of them—except perhaps the car (A) and some of the fence (B).  In contrast, our stereo algorithm is able to properly detect the car (A), fence (B), depot (C), building (D), near (E) and far (F) poles, and people (G).  The only major object missed by the stereo algorithm is the train (H) leaving the station, which is seen primarily through the transparent depot glass.  These results are even more dramatic when viewed on the screen with freedom to rotate and zoom.  

One could argue that this is not a fair comparison:  obviously stereo is better because it has access to more information.  But that is exactly the point, namely, that stereo algorithms have access to information that monocular algorithms will never have, and such information is crucial for accurately recovering depth.  Therefore, any application that requires accurate depth and can afford to support more than one camera should take advantage of such information.  

To further shed light on this point, notice that the top-down view of the previous figure contains the answer to the question posed at the beginning of the section:  the width of the tracks is approximately the same as that of the road.  Amazingly, the stereo algorithm, with just a single pair of images from a single point in time, is able to recover such information, even though the building behind the tracks is 30 m away.  In contrast, the fact that the human visual system is so easily fooled by the single photograph leads us to believe that the limitation in accuracy for monocular depth is not due to the specific algorithm used but rather is a fundamental hurdle that will prove frustratingly difficult to overcome for a long time.[Of course, one could use multiple images in time from a single camera to overcome such limitations.  Note, however, that in the context of a self-driving car, the forward direction (which is where information is needed most) is precisely the part of the image containing the least image motion and, hence, the least information.]



















§ DEEP STEREO NETWORK





Recognizing the limitations of monocular depth, we instead use a stereo pair of images.    
Our stereo network, shown in Fig. <ref>, is inspired by the architecture of the recent GC-Net stereo network <cit.> which at the time we began the investigation, was the leader of the KITTI 2015 benchmark.
The left and right images (size H × W × C, where C=3 is the number of input channels) are processed by 2D feature extractors based on a residual network architecture that bears resemblance to ResNet-18 <cit.>.  The resulting feature tensors (dimensions H ×W × F, where F=32 is the number of features)  are used to create two cost volumes, one for left-right matching and the other for right-left matching. The left-right cost volume is created by sliding the right tensor to the right, along the epipolar lines of the left tensor, up to max disparity.  At corresponding pixel positions, the left and right features are concatenated and copied into the resulting 4D cost volume (dimensions D ×H ×W × 2F, where D is the max disparity). The right-left cost volume is created by repeating this procedure in the opposite direction by sliding the left tensor to the left, along the epipolar lines of the right tensor, also up to the max disparity.  Note that, as in <cit.>, the first layer of the network downsamples by a factor of two in each direction to reduce both computation and memory in the cost volumes.

These two cost volumes are used in a 3D convolution / deconvolution bottleneck that performs stereo matching by comparing features.  This bottleneck contains a multiscale encoder to perform matching at multiple resolutions, followed by a decoder with skip connections to incorporate information from the various resolutions.  Just as in the feature extraction layers above, the weights in the left and right bottleneck matching units are shared and learned together.  After the last decoder layer, upsampling is used to produce both a left and right tensor (dimensions D × H × W × 1) containing matching costs between pixels in the two images.  

At this point it would be natural to apply differentiable soft argmax <cit.> to these matching costs (after first converting to probabilities) to determine the best disparity for each pixel.  Soft argmax has the drawback, however, of assuming that all context has already been taken into account, which may not be the case.  To overcome this limitation, we implement a machine-learned argmax (ML-argmax) function using a sequence of 2D convolutions to produce a single value for each pixel which, after passing through a sigmoid, becomes the disparity estimate for that pixel.  We found the sigmoid to be a crucial detail, without which the disparities were not learned correctly.  Our machine-learned argmax is not only able to extract disparities from the disparity PDF tensor, but it is also better at handling uniform or multimodal probability distributions than soft argmax.  Moreover, it yields more stable convergence during training.

Three key differences of our architecture with respect to GC-Net <cit.> are the following: 1) our semi-supervised loss function which includes both supervised and unsupervised terms, as explained in more detail below; 2) our use of ELU activations <cit.> rather than ReLU-batchnorm, which enables the network to train and run faster by obviating the extra operations required by batchnorm; and 3) our novel machine-learned argmax function rather than soft argmax, which allows the network to better incorporate context before making a decision.



To train the network, we use the following loss function, which combines the supervised term (E_𝕀lidar) used by most other stereo algorithms 
<cit.>
along with unsupervised terms similar to those used by MonoDepth <cit.>:

    L = λ_1E_𝕀image + λ_2E_𝕀lidar + λ_3E_𝕀lr + λ_4E_𝕀ds,

where 

    E_𝕀image   =    E^l_𝕀image + E^r_𝕀image
    
    E_𝕀lidar   =    |d_l-d̅_l| + |d_r-d̅_r| 
    
    E_𝕀lr   =   1/n∑_ij|d_ij^l-d̃_ij^l| + 1/n∑_ij|d_ij^r-d̃_ij^r| 
    
    E_𝕀ds   =    E^l_𝕀ds + E^r_𝕀ds.


Note that Eq. (<ref>) ensures photometric consistency, Eq. (<ref>) compares the estimated disparities to the sparse LIDAR data, Eq. (<ref>) ensures that the left and right disparity maps are consistent with each other, and Eq. (<ref>) encourages the disparity maps to be piecewise smooth, respectively, where


    E^l_𝕀image   =   1/n∑_i,jα1-𝕀SSIM(I_ij^l,Ĩ_ij^l)/2 
    	+ (1-α) |I_ij^l - Ĩ_ij^l| 
    
    E^l_𝕀ds   =   1/n∑_i,j |∂_x d_ij^l | e^-∂_x I_i,j^l 
    		+ |∂_y d_ij^l | e^-∂_y I_i,j^l

and similarly for E^r_𝕀image and E^r_𝕀ds.  The quantities above are defined as

    Ĩ^l    =    w_rl(I_r,d_l) 
    Ĩ^r    =    w_lr(I_l,d_r) 
    d̃^l    =    w_rl(d_r,d_l) 
    d̃^r    =    w_lr(d_l,d_r) 
    
    w_lr(I,d)    =    (x,y) ↦ I(x-d(x,y),y) 
    
    w_rl(I,d)    =    (x,y) ↦ I(x+d(x,y),y) 
    𝕀SSIM(x,y)    =   (2μ_xμ_y+c_1/μ_x^2+μ_y^2+c_1)
    							(2σ_xy+c_2/σ_x^2+σ_y^2+c_2)

Note that I_l and I_r are the input images, d_l and d_r are the estimated disparity maps output by the network, d̅_l and d̅_r are the ground truth disparity maps obtained from LIDAR, SSIM is the structural similarity index <cit.>, n is the number of pixels, and c_1=10^-4 and c_2=10^-3 are constants to avoid dividing by zero.  Note that in Eqs. (<ref>)–(<ref>) the coordinates are often non-integers, in which case we use bilinear interpolation, implemented similar to <cit.>.



























§ EXPERIMENTAL RESULTS



To evaluate our network as well as its variants, we trained and tested on the KITTI dataset <cit.>, requiring more than 40 GPU-days.  For training, we used the 29K training images[This the same training set split used by MonoDepth <cit.>.] with sparse LIDAR for ground truth.  To our knowledge, we are the first to combine supervised and unsupervised learning for training a deep stereo network, see Tab. <ref>.  The network was implemented in TensorFlow and trained for 85000 iterations (approx. 2.9 epochs) with a batch size of 1 on an NVIDIA Titan X GPU.  We use the Adam optimizer starting with a learning rate of 10^-4, which was reduced over time.  We then tested the network on the 200 training images from the KITTI 2015 benchmark, which contain sparse LIDAR ground truth augmented by dense depth on some vehicles from fitted 3D CAD models.  (Note that this process separates the training and testing datasets, since the 200 images are from 33 scenes that are distinct from the 28 scenes associated with the 29K training images.)  Like other authors, we used these 200 training images for testing, since the ground truth for the KITTI 2015 test images is not publicly available, and submission to the website is limited.  



For all tests, the input images (which are originally different sizes) were resized to 1024 × 320; and for the LIDAR-only experiments the images were further cropped to remove 37.8% of the upper part.  The maximum disparity was set to D=96.  No scaling was done on the input images, but the LIDAR values were scaled to be between 0 and 1.  The same procedure was used for all variants, and no postprocessing was done on the results.  






The various architectures that we tested are listed in Tab. <ref>.  These variants are named with respect to a baseline architecture.  Thus, our ML-argmax network is an extension to the baseline, whereas the other variants are less powerful versions that either replace concatenation with cross-correlation (sliding dot product), replace the bottleneck layers with simpler convolutional layers, remove one of the two towers, or use a smaller number of weights.[We also tried replacing 3D convolutions with 2D convolutions (similar to <cit.>), but the network never converged.]  The single-tower version has a modified loss function with all terms involving the right disparity map removed.

The notation of the layers in the table is as follows:  mB_k means m blocks of type B with k layers in the block.  Thus, ↓_1 means a single downsampling layer, ↑_1 means a single upsampling layer, and 2C means two convolutional layers.  The subscript _+ indicates a residual connection, so 8(2C_+) means 8 superblocks, where each superblock consists of 2 blocks of single convolutional layers accepting residual connections.  






















Our first set of experiments was aimed at comparing unsupervised, supervised, and semi-supervised learning.  The results of three variant architectures, along with monocular depth, are shown in Tab. <ref>, which contains the D1-all error of all pixels as defined by KITTI (the percentage of pixels with an error at least 3 disparity levels or at least 5%).  This error is the percentage of outliers.  Surprisingly, in all cases the unsupervised (photometric) loss yielded better results than the supervised loss (LIDAR).  The best results were obtained by combining the two, because photometric and LIDAR data complement each other:  LIDAR is accurate at all depths, but its sparsity leads to blurrier results, and it misses the fine structure, whereas photometric consistency allows the network to recover fine-grained surfaces but suffers from loss in accuracy as depth increases.  These observations are clearly seen in the example of Fig. <ref>.



MonoDepth <cit.> performed noticeably worse, thus demonstrating (as explained earlier) that the gap between mono and stereo is significant.  (We used MonoDepth because it is a leading monocular depth algorithm whose code is available online; other monocular algorithms perform similarly.)  Note that only the relative values are important here; the absolute values are large in general from testing on images with dense ground truth despite being trained only on images with sparse ground truth.  For these experiments as well as the next, the relative weights in the loss function were set to λ_1=λ_3=1.0 for lidar and for photo, or λ_1=0.01, λ_3=0.1 for lidar+photo; and λ_4=0.1, α=0.85. 












Having established the benefit of combining supervised and unsupervised learning, the second set of experiments aimed at providing further comparison among the architecture variants.  Results are shown in Tab. <ref>.  A significant improvement is achieved by our machine-learned argmax.  Somewhat surprisingly, reducing the size of the network substantially by either using a smaller network, cross-correlation, or removing one of the towers entirely has only a slight effect on error, despite the fact that a single tower requires 1.8X less memory, cross-correlation requires 64X less memory, the small network contains 36% fewer weights, and the tiny network contains 82% fewer weights.  From these data we also see that the bottleneck is extremely important to extract information from the cost volume, and that concatenation is noticeably better than correlation, thus confirming the claim of <cit.>.  










To test on the official KITTI 2015 benchmark,[<http://www.cvlibs.net/datasets/kitti>] we submitted two versions.  The first version is exactly the same baseline network as described above without retraining or fine-tuning, except that we validated using the 200 KITTI training images to learn the relative weights, λ_1=0.01, λ_2=1.0, λ_3=λ_4=0.1; and we set the maximum disparity to D=136.  The results, shown in Tab. <ref>, are significantly better (due to this reweighting) than on the augmented training images, achieving 5.1% D1-all error on all pixels.  Although this is not competitive with recent techniques, it is surprisingly good considering that the network was not trained on dense data.  For the next result, we took this same network and fine-tuned it using the 200 KITTI 2015 augmented training images.  After fine-tuning, our results are competitive with state-of-the-art, achieving 3.2% D1-all error on all pixels and only 2.5% on non-occluded pixels.  These results were achieved without any postprocessing of the data.

Our baseline network achieves results similar to those of GC-Net <cit.>, actually winning on three of the six metrics.  The remaining difference between the results is likely due to GC-Net's pretraining on dense data from the Scene Flow dataset <cit.>.  As a result, our network performs less well around the boundaries of objects, since it has seen very little dense ground truth data.  Similar arguments can be made for other competing algorithms, such as CRL <cit.> and iResNet <cit.>.  However, the focus of this paper was to examine the influence of network architecture and loss functions rather than datasets.  It would be worthwhile in the future to also study the influence of training and pretraining datasets, as well as the use of synthetic and real data.

Fig. <ref> highlights an advantage of our approach over GC-Net and other supervised approaches.  Because our network is trained in a semi-supervised manner, it is able to recover fine detail, such as the fence rails and posts.  The sparse LIDAR data in the KITTI dataset rarely captures this detail, as seen in the second row of the figure.  As a result, all stereo algorithms trained on sparse LIDAR only (including GC-Net) will miss this important structure.  However, since the LIDAR on which the KITTI ground truth is based often misses such detail itself, algorithms (such as ours) are not rewarded by the KITTI 2015 stereo benchmark metrics for correctly recovering the detail.











	
   
   
   
   
   
   
	
	

   







	
   
   
		
	

   








	
   
   
   
   
   
   
	
	

   






	
   
   
   
	
	

   







































The colormap used in Fig. <ref> was generated by traversing the vertices of the RGB cube in the order KRYGCBMW, which uniquely ensures a Hamming distance of 1 between consecutive vertices (to avoid blending artifacts) and preserves the order of the rainbow.  Distances are scaled so that Δ_E according to CIE1976 is the same between consecutive vertices.  All images are scaled in the same way, thus preserving the color to disparity mapping.  Objections to rainbow color maps <cit.> do not appear relevant to structured data such as disparity maps.





Additional results of our final fine-tuned network on the KITTI 2015 online testing dataset are shown in 
Fig. <ref>, using the KITTI color maps.  Note that the algorithm accurately detects vehicles, cyclists, buildings, trees, and poles, in addition to the road plane.  In particular, notice in the third row that the interior of the white truck is estimated properly despite the lack of texture.

Tab. <ref> shows the computation time of the various models on different architectures.  Note that with our custom runtime (based on TensorRT / cuDNN), we are able to achieve near real-time performance (almost 20 fps) on Titan XP, as well as efficient performance on the embedded Jetson TX2.[Our custom runtime, which implements a set of custom plugins for Tensor RT that implement 3D convolutions / deconvolutions, cost volume creation, soft argmax, and ELU, is available at <https://github.com/NVIDIA-Jetson/redtail>.]  As far as we know, this is the first deep-learning stereo network ported to embedded hardware.







§ CONCLUSION


We have shown that a significant gap exists between monocular and stereo depth estimation.  We also presented a careful analysis of various deep-learning-based stereo neural network architectures and loss functions.  Based on this analysis, we propose a novel approach combining a cost volume with concatenated features, 3D convolutions for matching, and machine-learned argmax for disparity extraction, trained in a semi-supervised manner that combines LIDAR and photometric data.  We show competitive results on the standard KITTI 2015 stereo benchmark, as well as superior ability to extract fine details when compared with approaches trained using only LIDAR.  Future work should be aimed at real-time performance, detecting objects at infinity (e.g., skies), and handling occlusions.



§ ACKNOWLEDGMENTS


We thank Vijay Baiyya and Thang To for their assistance, and Nicholas Haemel for supporting this research.





 














ieee













§ NETWORK ARCHITECTURE


Tables <ref>–<ref> provide the details of the network architectures used in the experiments of this paper.  The first table shows our baseline architecture, whereas the others show variations of the baseline (with red indicating the differences).  Note that these tables only describe the architecture for one of the two towers (left / right).  This is sufficient for inference, since only one tower is used for all architectures.  However, most implementations (that is, all except the single tower variant) contain two instances of the network for training.  More specifically, during training, all networks contain left and right instances of layers 1–10; the single tower variant contains only a single instance of the remaining layers, whereas all other variants contain two instances of these remaining layers.  (As described in the paper, C=3 is the number of color channels, and F=32 is the number of features.)







	
 

	
	



	


   	
	




	
	



	
	



























	

	

	

	






	



	

	

	
	




















































