T OWARDS S TABILIZING B ATCH S TATISTICS IN B ACKWARD P ROPAGATION OF B ATCH N ORMALIZATION
A BSTRACT
Batch Normalization
(BN) is one of the most widely used techniques in Deep
Learning ﬁeld
But its performance can awfully degrade with insufﬁcient batch size.
This weakness limits the usage of
BN on many computer vision tasks like detection or segmentation, where batch size is usually small due to the constraint of memory consumption.
Therefore many modiﬁed normalization techniques have been proposed which either fail to restore the performance of BN completely or have to introduce additional nonlinear operations in inference procedure and increase huge consumption.
In this paper, we reveal that there are two extra batch statistics involved in backward propagation of BN, on which has never been well discussed before.
The extra batch statistics associated with gradients also can severely affect the training of deep neural network.
Based on our analysis, we propose a novel normalization method, named Moving Average Batch Normalization (MABN).
MABN can completely restore the performance of vanilla BN in small batch cases, without introducing any additional nonlinear operations in inference procedure.
We prove the beneﬁts of MABN by both theoretical analysis and experiments.
Our experiments demonstrate the effectiveness of MABN in multiple computer vision tasks including ImageNet and COCO.
The code has been released in https
//github.com/megvii-model/MABN .
I NTRODUCTION
Batch Normalization (BN) (Ioffe & Szegedy, 2015) is one of the most popular techniques for training neural networks.
It has been widely proven effective in many applications, and become the indispensable part of many state of the art deep models.
Despite the success of BN, it’s still challenging to utilize BN when batch size is extremely small 1 .
The batch statistics with small batch size are highly unstable, leading to slow convergence during training and bad performance during inference.
For example, in detection or segmentation tasks, the batch size is often limited to 1 or 2 per GPU due to the requirement of high resolution inputs or complex structure of the model.
Directly computing batch statistics without any modiﬁcation on each GPU will make performance of the model severely degrade.
To address such issues, many modiﬁed normalization methods have been proposed.
They can be roughly divided into two categories: some of them try to improve vanilla BN by correcting batch statistics (Ioffe, 2017; Singh & Shrivastava, 2019), but they all fail to completely restore the performance of vanilla BN; Other methods get over the instability of BN by using instance-level normalization (Ulyanov et al., 2016; Ba et al., 2016; Wu & He, 2018), therefore models can avoid the affect of batch statistics.
This type of methods can restore the performance in small batch cases to some extent.
However, instance-level normalization hardly meet industrial or commercial needs so far, for this type of methods have to compute instance-level statistics both in training and inference, which will introduce additional nonlinear operations in inference procedure and dramatically increase consumption Shao et al.
While vanilla BN uses the statistics computed over the whole training data instead of batch of samples when training ﬁnished.
Thus BN is a linear operator and can be merged with convolution layer during inference procedure.
Figure 1(a) shows with ResNet-50 (He et al., 2016), instance-level normalization almost double the inference time compared with vanilla
BN.
Therefore, it’s a tough but necessary task to restore the performance of BN in small batch training without introducing any nonlinear operations in inference procedure.
In this paper, we ﬁrst analysis the formulation of vanilla BN, revealing there are actually not onlybut 4 batch statistics involved in normalization during forward propagation (FP) as well as backward propagation (BP).
The additional 2 batch statistics involved in BP are associated with gradients of the model, and have never been well discussed before.
They play an important role in regularizing gradients of the model during BP.
In our experiments (see Figure 2), variance of the batch statistics associated with gradients in BP, due to small batch size, is even larger than that of the widelyknown batch statistics (mean, variance of feature maps).
We believe the instability of batch statistics associated with gradients is one of the key reason why BN performs poorly in small batch cases.
Based on our analysis, we propose a novel normalization method named Moving Average Batch
Normalization (MABN) .
MABN can completely get over small batch issues without introducing any nonlinear manipulation in inference procedure.
The core idea of MABN is to replace batch statistics with moving average statistics.
We substitute batch statistics involved in BP and FP with different type of moving average statistics respectively, and theoretical analysis is given to prove the beneﬁts.
However, we observed directly using moving average statistics as substitutes for batch statistics can’t make training converge in practice.
We think the failure takes place due to the occasional large gradients during training, which has been mentioned in Ioffe (2017).
To avoid training collapse, we modiﬁed the vanilla normalization form by reducing the number of batch statistics, centralizing the weights of convolution kernels, and utilizing renormalizing strategy.
We also theoretically prove the modiﬁed normalization form is more stable than vanilla form.
MABN shows its effectiveness in multiple vision public datasets and tasks, including ImageNet (Russakovsky et al., 2015), COCO (Lin et al., 2014).
All results of experiments show MABN with small batch size ( 1 or 2 ) can achieve comparable performance as BN with regular batch size (see Figure 1(b)).
Besides, it has same inference consumption as vanilla BN (see Figure 1(a)).
We also conducted sufﬁcient ablation experiments to verify the effectiveness of MABN further.
[Figure]
R ELATED W ORK
Batch normalization (BN) (Ioffe & Szegedy, 2015) normalizes the internal feature maps of deep neural network using channel-wise statistics (mean, standard deviation) along batch dimension.
It has been widely proven effectively in most of tasks.
But the vanilla BN heavily relies on sufﬁcient batch size in practice.
To restore the performance of BN in small batch cases, many normalization techniques have been proposed: Batch
Renormalization (BRN) (Ioffe, 2017) introduces renormalizing parameters in BN to correct the batch statistics during training, where the renormalizing parameters are computed using moving average statistics; Unlike BRN, EvalNorm (Singh & Shrivastava, 2019) corrects the batch statistics during inference procedure.
Both BRN and EvalNorm can restore the performance of BN to some extent, but they all fail to get over small batch issues completely.
Instance Normalization (IN) (Ulyanov et al., 2016), Layer Normalization (LN) (Ba et al., 2016), and Group normalization (GN) (Wu & He, 2018)
all try to avoid the effect of batch size by utilizing instance level statistics.
IN uses channel-wise statistics per instance instead of per batch, while
LN uses instance-level statistics along channel dimension.
But IN and LN shows no superiority to vanilla BN in most of cases.
GN divides all channels in predeﬁned groups, and uses group-wise statistics per instance.
It can restore the performance of vanilla BN very well in classiﬁcation and detection tasks.
But it have to introduce extra nonlinear manipulations in inference procedure and severely increase inference consumption, as we have pointed out in Section 1.
SyncBN (Peng et al., 2018) handle the small batch issues by computing the mean and variance across multiple GPUs.
This method doesn’t essentially solve the problem, and requires a lot of resource.
Apart from operating on feature maps, some works exploit to normalize the weights of convolution:
Weight Standardization (Qiao et al., 2019) centralizes weight at ﬁrst before divides weights by its standard deviation.
It still has to combine with GN to handle small batch cases.
S TATISTICS IN B ATCH N ORMALIZATION 3. R EVIEW OF B ATCH N ORMALIZATION
First of all, let’s review the formulation of batch Normalization (Ioffe & Szegedy, 2015): assume the input of a BN layer is denoted as X ∈ R B × p , where B denotes the batch size, p denotes number of features.
In training procedure, the normalized feature maps Y at iteration t is computed as:
[Equation]
where batch statistics µ B t and σ 2 B t are the sample mean and sample variance computed over the batch of samples B t at iteration t :
[Equation]
Besides, a pair of parameters γ , β are used to scale and shift normalized value Y :
[Equation]
The scaling and shifting part is added in all normalization form by default, and will be omitted in the following discussion for simplicity.
As Ioffe & Szegedy (2015) demonstrated, the batch statistics µ B t , σ 2 B t are both involved in backward propagation (BP).
We can derive the formulation of BP in BN as follows: let L denote the loss, Θ t denote the set of the whole learnable parameters of the model at iteration t .
Given the partial gradients ∂ L ∂ Y (cid:12)(cid:12)(cid:12)(cid:12)
Θ t , B t , the partial gradients ∂ L ∂ X (cid:12)(cid:12)(cid:12)(cid:12)
Θ t , B t is computed as
[Equation]
where · denotes element-wise production, g B t and Ψ B t are computed as
[Equation]
It can be seen from (5) that g B t and Ψ B t are also batch statistics involved in BN during BP.
But they have never been well discussed before.
3. I NSTABILITY OF BATCH STATISTICS
According to Ioffe & Szegedy (2015), the ideal normalization is to normalize feature maps X using expectation and variance computed over the whole training data set:
[Equation]
But it’s impractical when using stochastic optimization.
Therefore, Ioffe & Szegedy (2015) uses mini-batches in stochastic gradient training, each mini-batch produces estimates the mean and variance of each activation.
Such simpliﬁcation makes it possible to involve mean and variance in BP.
From the derivation in section 3.1, we can see batch statistics µ B t , σ 2 B t are the Monte Carlo (MC) estimators of population statistics E
[ X | Θ t ] , V ar [ X | Θ t ] respectively at iteration t .
Similarly, batch statistics g B t , Ψ B t are MC estimators of population
statistics E
[ ∂ L ∂ Y b, : | Θ t ] , E [ Y b, : · ∂ L ∂ Y b, : | Θ t ] at iteration t .
E [ ∂ L ∂ Y b, : | Θ t ] , E
[ Y b, : · ∂ L ∂ Y b, : | Θ t ] are computed over the whole data set.
They contain the information how the mean and the variance of population will change as model updates, so they play an important role to make trade off between the change of individual sample and population.
Therefore, it’s crucial to estimate the population statistics precisely, in order to regularize the gradients of the model properly as weights update.
It’s well known the variance of MC estimator is inversely proportional to the number of samples, hence the variance of batch statistics dramatically increases when batch size is small.
Figure 2 shows the change of batch statistics from a speciﬁc normalization layer of ResNet-50 during training on
ImageNet.
Regular batch statistics (orange line) are regarded as a good approximation for population statistics.
We can see small batch statistics (blue line) are highly unstable, and contains notable error compared with regular batch statistics during training.
In fact, the bias of g B t and Ψ B t in BP is more serious than that of µ B t and σ 2 B t (see Figure 2(c), 2(d)).
The instability of small batch statistics can worsen the capacity of the models in two aspects: ﬁrstly the instability of small batch statistics will make training unstable, resulting in slow convergence; Secondly the instability of small batch can produce huge difference between batch statistics and population statistics.
Since the model is trained using batch statistics while evaluated using population statistics, the difference between batch statistics and population statistics will cause inconsistency between training and inference procedure, leading to bad performance of the model on evaluation data.
[Figure]
M OVING A VERAGE B ATCH N ORMALIZATION
Based on the discussion in Section 3.2, the key to restore the performance of BN is to solve the instability of small batch statistics.
Therefore we considered two ways to handle the instability of small batch statistics: using moving average statistics to estimate population statistics, and reducing the number of statistics by modifying the formulation of normalization.
4. S UBSTITUTE BATCH STATISTICS BY M OVING A VERAGE S TATISTICS .
Moving average statistics seem to be a suitable substitute for batch statistics to estimate population statistics when batch is small.
We consider two types of moving average statistics: simple moving average statistics (SMAS) 2 and exponential moving average statistics (EMAS) 3 .
The following theorem shows under mild conditions, SMAS and EMAS are more stable than batch statistics:
Theorem 1 Assume there exists a sequence of random variable (r.v.) { ξ t } ∞ t =1 , which are independent, uniformly bounded, i.e. ∀ t, | ξ t | < C , and have uniformly bounded density.
Deﬁne:
[Equation]
where m ∈ R + .
If the sequence { ξ t } ∞ t =1 satisﬁes
[Equation]
then we have
[Equation]
If the sequence { ξ t } ∞ t =1 satisﬁes
[Equation]
) then we have
[Equation]
The proof of theorem 1 can be seen in appendix A.1.
Theorem 1 not only proves moving average statistics have lower variance compared with batch statistics, but also reveals that with large momentum α , EMAS is better than SMAS with lower variance.
However, using SMAS and EMAS request different conditions: Condition (8) means the sequence of the given statistics need to weakly converge to a speciﬁc random variable.
For { µ B t } ∞ t =1 , { σ 2 B t } ∞ t =1 , they converge to the ”ﬁnal” batch statistics µ B , σ 2 B (when training ﬁnished), hence condition (8) is satisﬁed, EMAS can be applied to replace { µ B t } ∞ t =1 , { σ 2 B t } ∞ t =1 ; Unfortunately { g B t } ∞ t =1 , { Ψ B t } ∞ t =1 don’t share the same property,
EMAS is not suitable to take replace of { g B t } ∞ t =1 , { Ψ B t } ∞ t =1 .
However, under the assumption that learning rate is extremely small, the difference between the distribution of ξ t − 1 and ξ t is tiny, thus condition (10) is satisﬁed, we can use SMAS to replace { g B t } ∞ t =1 , { Ψ B t } ∞ t =1 .
In a word, we can use
EMAS ˆ µ t , ˆ σ 2 t to replace µ B t , σ 2 B t , and use SMAS ¯ g t , ¯Ψ t to replace g B t , Ψ B t in (1) and (4), where
[Equation]
Notice neither of SMAS and EMAS is the unbiased substitute for batch statistics, but the bias can be extremely small comparing with expectation and variance of batch statistics, which is proven by equation 11 in theorem 1, our experiments also prove the effectiveness of moving average statistics as substitutes for small batch statistics (see Figure 3, 4 in appendix B.1).
Relation to Batch Renormalization Essentially, Batch Renormalization (BRN) (Ioffe, 2017) replaces batch statistics µ B t , σ 2 B t with EMAS ˆ µ t , ˆ σ 2 t both in FP (1) and BP (4).
The formulation of
BRN during training is written as:
[Equation] [Equation]
where r = clip [1 /λ,λ ] ( σ B t ˆ σ t ) , d = clip [ − d,d ] ( µ B t − ˆ µ t ˆ σ t ) .
Based on our analysis, BRN successfully eliminates the effect of small batch statistics µ B t and σ 2 B t by EMAS, but the small batch statistics associated with gradients g B t and Ψ B t remains during backward propagation, preventing BRN from completely restoring the performance of vanilla BN.
4. S TABILIZING N ORMALIZATION BY REDUCING THE NUMBER OF S TATISTICS
To further stabilize training procedure in small batch cases, we consider normalizing feature maps
X using E X 2 instead of E X and V ar ( X ) .
The formulation of normalization is modiﬁed as:
[Equation]
[Equation]
where χ 2 B t = 1 B (cid:80) b X 2 b, : .
Given ∂ L ∂ Y , the backward propagation is:
[Equation]
The beneﬁts of the modiﬁcation seems obvious: there’s only two batch statistics left during FP and BP, which will introduce less instability into the normalization layer compared with vanilla normalizing form.
In fact we can theoretically prove the beneﬁts of the modiﬁcation by following theorem:
Theorem
If the following assumptions hold:
V ar [ˆ σ ]
= o (1) , V ar [ˆ χ ]
= o (1) ; 2.
Cov ( { ∂ L ∂y , y } , { g B , Ψ B } ) =
o (1) ; 3.
E y
=
o (1) ;
Then we have:
[Equation]
The proof can be seen in appendix A.2.
According to (17), V ar [ ∂ L /∂ X (cid:12)(cid:12) vanilla ] is larger than that of V ar [ ∂ L /∂ X (cid:12)(cid:12) modified ] , the gap is at least V ar [ g B ] / ˆ σ 2 , which mainly caused by the variance of g B / ˆ σ .
So the modiﬁcation essentially reduces the variance of the gradient by eliminating the batch statistics g B during BP.
Since g B t is a Monte Carlo estimator, the gap is inversely proportional to batch size.
This can also explain why the improvement of modiﬁcation is signiﬁcant in small batch cases, but modiﬁed BN shows no superiority to vanilla BN within sufﬁcient batch size (see ablation study in section 5.1).
Centralizing weights of convolution kernel Notice theorem 2 relies on assumption 3.
The vanilla normalization naturally satisﬁes E y = 0 by centralizing feature maps, but the modiﬁed normalization doesn’t necessarily satisfy assumption 3.
To deal with that, inspired by Qiao et al.
, we ﬁnd centralizing weights W ∈ R q × p of convolution kernels, named as Weight Centralization (WC) can be a compensation for the absence of centralizing feature maps in practice:
[Equation]
where X input , X output are the input and output of the convolution layer respectively.
We conduct further ablation study to clarify the effectiveness of WC (see Table 4 in appendix B.2).
It shows that
WC has little beneﬁts to vanilla normalization, but it can signiﬁcantly improve the performance of modiﬁed normalization.
We emphasize that weight centralization is only a practical remedy for the absence of centralizing feature maps.
The theoretical analysis remains as a future work.
Clipping and renormalizing strategy.
In practice, we ﬁnd directly substituting batch statistics by moving average statistics in normalization layer will meet collapse during training.
Therefore we take use of the clipping and renormalizing strategy from BRN (Ioffe, 2017).
All in all, the formulation of proposed method MABN is:
[Equation]
[Equation]
where the EMAS ˆ χ t is computed as ˆ χ t
=
α ˆ χ t − 1 + (1 − α ) χ B t , SMAS ¯ χ t is deﬁned as ¯ χ 2 t = 1 m (cid:80) ms =1 χ 2 B t − m + s , SMAS ¯Ψ t is deﬁned as (13).
The renormalizing parameter is set as r = clip [1 /λ,λ ] ( ¯ χ t ˆ χ t ) .
E XPERIMENTS
This section presents main results of MABN on ImageNet (Russakovsky et al., 2015), COCO (Lin et al., 2014).
Further experiment results on ImangeNet, COCO and Cityscapes (Cordts et al., 2016) can be seen in appendix B.2, B.3, B.4 resepectively.
We also evaluate the computational overhead and memory footprint of MABN, the results is shown in appendix B.5.
5. I MAGE C LASSIFICATION IN I MAGENET
We evaluate the proposed method on ImageNet (Russakovsky et al., 2015) classiﬁcation datatsets with 1000 classes.
All classiﬁcation experiments are conducted with ResNet-50 (He et al., 2016).
More implementation details can be found in the appendix B.2.
[Table]
Comparison with other normalization methods.
Our baseline is BN using small ( |B| = 2 ) or regular ( |B| = 32 ) batch size, and BRN (Ioffe, 2017) with small batch size.
We don’t present the performance of instance-level normalization counterpart on ImageNet, because they are not linear-type method during inference time, and they also failed to restore the performance of BN (over +0 . 5% ), according to Wu & He (2018).
Table 1 shows vanilla BN with small batch size can severely worsen the performance of the model( +11 . 81% ); BRN (Ioffe, 2017) alleviates the issue to some extent, but there’s still remaining far from complete recovery( +6 . 88% ); While MABN almost completely restore the performance of vanilla BN( +0 . 17% ).
We also compared the performance of BN, BRN and MABN when varying the batch size (see Figure 1(b)).
BN and BRN are heavily relies on the batch size of training, though BRN performs better than vanilla BN.
MABN can always retain the best capacity of ResNet-50, regardless of batch size during training.
Ablation study on ImageNet.
We conduct ablation experiments on ImageNet to clarify the contribution of each part of MABN (see table 2).
With vanilla normalization form, replacing batch statistics in FP with EMAS (as BRN) will restore the performance to some extents( − 4 .
93% , comparing 3 (cid:13) and 4 (cid:13) ), but there’s still a huge gap ( +6 . 88% , comparing 1 (cid:13) and 4 (cid:13) ) from complete restore.
Directly using SMAS in BP with BRN will meet collapse during training ( 5 (cid:13) ), no matter how we tuned hyperparameters.
We think it’s due to the instability of vanilla normalization structure in small cases, so we modify the formulation of normalization shown in section 4.2.
The modiﬁed normalization even slightly outperforms BRN in small batch cases (comparing 4 (cid:13) and 6 (cid:13) ).
However, modiﬁed normalization shows no superiority to vanilla form (comparing 1 (cid:13) and 2 (cid:13) ), which can be interpreted by the result of theorem 2.
With EMAS in FP, modiﬁed normalization signiﬁcantly reduces the error rate further (comparing 6 (cid:13) and 7 (cid:13) ), but still fail to restore the performance completely ( +3 .
62% , comparing 1 (cid:13) and 7 (cid:13) ).
Applying SMAS in BP ﬁnally ﬁlls the rest of gap, almost completely restore the performance of vanilla BN in small batch cases ( +0 . 17 ,comparing 1 (cid:13) and 8 (cid:13) ).
[Table]
5. D ETECTION AND S EGMENTATION IN COCO FROM SCRATCH
We conduct experiments on Mask R-CNN (He et al., 2017) benchmark using a Feature Pyramid
Network(FPN)
(Lin et al., 2017a) following the basic setting in He et al.
We train the networks from scratch (He et al., 2018) for 2 × times.
Only the backbone contains normalization layers.
More implementation details and experiment results can be seen in the appendix B.
[Table]
Table 3 shows the result of MABN compared with vanilla BN, BRN and SyncBN (Peng et al., 2018).
It can be seen that MABN outperforms vanilla BN and BRN by a clear margin and get comparable performance with SyncBN.
Quite different from Imagenet experiments, we update the parameters every single batch (with B norm = 2 ).
With such a complex pipeline, MABN still achieves a comparable performance as SyncBN.
C ONCLUSION
This paper reveals the existence of the batch statistics g B and Ψ B involved in backward propagation of BN, and analysis their inﬂuence to training process.
This discovery provides a new perspective to understand why BN always fails in small batch cases.
Based on our analysis, we propose MABN to deal with small batch training problem.
MABN can completely restore the performance of vanilla
BN in small batch cases, and is extraordinarily efﬁcient compared with its counterpart like GN.
Our experiments on multiple computer vision tasks (classiﬁcation, detection, segmentation) have shown the remarkable performance of MABN.
A CKNOWLEDGEMENT
This research was partially supported by National Key RD Program of China (No.
2017YFA0700800), Beijing Academy of Artiﬁcial Intelligence (BAAI), and NSFC under Grant
No.
A S KETCH OF PROOF A. P ROOF OF THEOREM
If the condition (8) is satisﬁed
[Equation]
i.e. { ξ t } ∞ t =1 weakly converge to ξ .
Since { ξ t } ∞ t =1 has uniformly bounded density, we have:
[Equation]
Since { ξ t } ∞ t =1 are independently, hence we have:
[Equation]
) as t → ∞ .
Hence (9) has been proven.
If the condition (10) is satisﬁed.
Since { ξ t } ∞ t =1 is uniformly bounded
[Equation]
then ∃ C ∈ R + , ∀ , | ξ t | < C .
As t → ∞
[Equation]
We have
[Equation]
Similarly
[Equation]
we have
[Equation]
Therefore combining (24) and (25)
[Equation]
we have
[Equation] [Equation]
For a ﬁxed memory size m , as t → ∞ , we have
[Equation]
Therefore, (11) has been proven
[Equation]
A. P ROOF OF THEOREM
Without loss of generality
[Equation]
given the backward propagation of two normalizing form of a single input x with batch B :
[Equation]
where g B , Ψ B are the batch statistics
[Equation]
and ˆ σ , ˆ χ are the EMAS, deﬁned as before.
We omitted the subscript t for simplicity.
Then the variance of partial gradients w.r
[Equation]
t. inputs x is written as
[Equation] [Equation]
where (30) is satisﬁed due to assumption 1.
The variance of ˆ σ is so small that ˆ σ can be regarded as a ﬁxed number; (31) is satisﬁed because
[Equation]
Due to assumption
[Equation]
the correlation between individual sample and batch statistics is close to 0 , hence we have
[Equation]
Besides
[Equation]
E y is close to 0 according to assumption 3, hence
[Equation]
) (32) is satisﬁed due to the deﬁnition of ˆ χ and ˆ σ , we have
[Equation]
[Equation]
Similar to ˆ σ , the variance of ˆ χ is also too small that ˆ χ can be regarded as a ﬁxed number due to assumption 1, so (33) is satisﬁed.
B E XPERIMENTS B. S TATISTICS A NALYSIS
We analyze the difference between small batch statistics ( |B| = 2 ) and regular batch statistics ( |B| = 32 ) with the modiﬁed formulation of normalization (15) shown in Section 4.2.
[Figure]
[Figure]
Figure 3 illustrates the change of small batch statistics and regular batch statistics in FP and BP respectively.
The variance of small batch statistics is much higher than the regular one.
However, when we use SMAS as a approximation for regular batch statistics, the gap between SMAS and regular batch statistics is not obvious as shown in Figure 4.
B. E XPERIMENTS ON I MAGE N ET
Implementation details.
All experiments on ImageNet are conducted across 8 GPUs.
We train models with a gradient batch size of B g = 32 images per GPU.
To simulate small batch training, we split the samples on each GPU into B g / |B| groups where |B| denotes the normalization batch size.
The batch statistics are computed within each group individually.
All weights from convolutions are initialized as He et al.
We use 1 to initialize all γ and 0 to initialize all β in normalization layers.
We use a weight decay of 10 − 4 for all weight layers including γ and β (following Wu & He (2018)).
We train 600 , 000 iterations (approximately equal to 120 epoch when gradient batch size is 256 ) for all models, and divide the learning rate by 10 at 150 , 000 , 300 , 000 and 450 , 000 iterations.
The data augmentation follows Gross & Wilber (2016).
The models are evaluated by top-1 classiﬁcation error on center crops of 224 × 224 pixels in the validation set.
In vanilla BN or BRN, the momentum α = 0 .
9 , in MABN, the momentum α = 0 .
Additional ablation studies.
Table 4 shows the additional ablation results.
We test all possible combination of all three kinds of statistics (SMAS, EMAS, BS) in FP and BP.
The experiments results strongly prove our theoretical analysis in section 4.3.
Besides, we verify the necessity of centralizing weights with modiﬁed normalization form.
[Table]
B. E XPERIMENTS ON COCO
Implementation details.
We train the Mask-RCNN pipeline from scratch with MABN.
We train the model on 8 GPUs, with 2 images per GPU.
We train our model using COCO 2014 train and trainval35k dataset.
We evaluate the model on COCO 2014 minival dataset.
We set the momentum α = 0 .
98 for all MABN layers.
We report the standard COCO merics AP bbox , AP bbox 75 , AP bboxfor bounding box detection and AP mask , AP mask, AP maskfor instance segmentation.
Other basic settings follow He et al.
MABN used on heads.
We build mask-rcnn baseline using a Feature Pyramid Network(FPN)(Lin et al., 2017a) backbone.
The base model is ResNet-50.
We train the models for 2 × iterations.
We use 4conv1fc instead of 2fc as the box head.
Both backbone and heads contain normalization layers.
We replace all normalization layers in each experiments.
While training models with MABN, we use batch statistics in normalization layers on head during ﬁrst 10,000 iterations.
Table 5 shows the result.
The momentum are set to 0.
[Table]
Training from pretrained model.
We compare the performance of MABN and SyncBN when training model based on ImageNet pretrained weights for 2x iterations.
The results are shown in
Table
[Table]
Training from scratch for one-stage model.
We also compare MABN and SyncBN based on one-stage pipeline.
We build on retinanet(Lin et al., 2017b) benchmark.
We train the model from scratch for 2 × iterations.
The results are shown in Table 7.
[Table]
All experiment results shows MABN can get comparable as SyncBN, and signiﬁcantly outperform
BN
B. S EMANTIC S EGMENTATION IN C ITYSCAPES
We evaluate semantic segmentation in Cityscapes(Cordts et al., 2016).
It contains 5,000 high quality pixel-level ﬁnely annotated images collected from 50 cities in different seasons.
We conduct experiments on PSPNET baseline and follow the basic settings mentioned in Zhao et al.
For fair comparison, our backbone network is ResNet-101 as in Chen et al.
Since we centralize weights of convolutional kernel to use MABN, we have to re-pretrain our backbone model on Imagenet dataset.
During ﬁne-tuning process, we linearly increase the learning rate for 3 epoch (558 iterations) at ﬁrst.
Then we follow the ”poly” learning schedule as Zhao et al.
Table 8 shows the result of MABN compared with vanilla BN, BRN and SyncBN.
The buffer size ( m ) of
MABN is 16, the modementum of MABN and BRN is 0.98.
Since the statistics (mean and variance) is more stable in a pre-trained model than a random initialized one, the gap between vanilla BN and SyncBN is not signiﬁcant (+ 1 .
However, MABN
[Table]
still outperforms vanilla BN by a clear margin.(+ 1 . 09% ).
Besides, BRN shows no obvious superiority to vanilla BN(+ 0 .
19% ) on Cityscapes dataset.
B. C OMPUTATIONAL O VERHEAD
We compare the computational overhead and memory footprint of BN, GN and MABN.
We use maskrcnn with resnet50 and FPN as benchmark.
We compute the theoretical FLOPS during inference and measure the inference speed when a single image ( 3 × 224 × 224 ) goes through the backbone (resnet50 + FPN).
We assume BN and MABN can be absorbed in convolution layer during inference.
GN can not be absorbed in convolution layer, so its FLOPS is larger than BN and MABN.
Besides GN includes division and sqrt operation during inference, therefore it’s much slower than
BN and MABN during inference time.
We also monitor the training process of maskrcnn on COCO (8 GPUs, 2 images per GPU), and show its memory footprint and training speed.
Notice we have not optimized the implementation of
MABN, so its training speed is a little slower than BN and GN.
[Table]