Original: TTN: A D OMAIN -S HIFT A WARE B ATCH N ORMALIZATION IN T EST -T IME A DAPTATION
Revised: TTN: A D OMAIN -S HIFT A WARE B ATCH N ORMALIZATION IN T EST -T IME A DAPTATION

Original: A BSTRACT
Revised: A BSTRACT

Original: This paper proposes a novel batch normalization strategy for test-time adaptation.
Revised: This paper proposes a novel batch normalization strategy for test-time adaptation.

Original: Recent test-time adaptation methods heavily rely on the modified batch normalization, i.e., transductive batch normalization (TBN), which calculates the mean and the variance from the current test batch rather than using the running mean and variance obtained from source data, i.e., conventional batch normalization (CBN).
Revised: Recent test-time adaptation methods heavily rely on the modified batch normalization, i.e., transductive batch normalization (TBN), which calculates the mean and the variance from the current test batch rather than using the running mean and variance obtained from source data, i.e., conventional batch normalization (CBN).

Original: Adopting TBN that employs test batch statistics mitigates the performance degradation caused by the domain shift.
Revised: Adopting TBN that employs test batch statistics mitigates the performance degradation caused by the domain shift.

Original: However, re-estimating normalization statistics using test data depends on impractical assumptions that a test batch should be large enough and be drawn from i.i.d.
Revised: However, re-estimating normalization statistics using test data depends on impractical assumptions that a test batch should be large enough and be drawn from i.i.d.

Original: stream, and we observed that the previous methods with TBN show critical performance drop without the assumptions.
Revised: stream, and we observed that the previous methods with TBN show critical performance drop without the assumptions.

Original: In this paper, we identify that CBN and TBN are in a trade-off relationship and present a new test-time normalization (TTN) method that interpolates the standardization statistics by adjusting the importance between CBN and TBN according to the domain-shift sensitivity of each BN layer.
Revised: In this paper, we identify that CBN and TBN are in a trade-off relationship and present a new test-time normalization (TTN) method that interpolates the standardization statistics by adjusting the importance between CBN and TBN according to the domain-shift sensitivity of each BN layer.

Original: Our proposed TTN improves model robustness to shifted domains across a wide range of batch sizes and in various realistic evaluation scenarios.
Revised: Our proposed TTN improves model robustness to shifted domains across a wide range of batch sizes and in various realistic evaluation scenarios.

Original: TTN is widely applicable to other test-time adaptation methods that rely on updating model parameters via backpropagation.
Revised: TTN is widely applicable to other test-time adaptation methods that rely on updating model parameters via backpropagation.

Original: We demonstrate that adopting TTN further improves their performance and achieves state-of-the-art performance in various standard benchmarks.
Revised: We demonstrate that adopting TTN further improves their performance and achieves state-of-the-art performance in various standard benchmarks.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: When we deploy deep neural networks (DNNs) trained on the source domain into test environments ( i.e., target domains), the model performance on the target domain deteriorates due to the domain shift from the source domain.
Revised: When we deploy deep neural networks (DNNs) trained on the source domain into test environments ( i.e., target domains), the model performance on the target domain deteriorates due to the domain shift from the source domain.

Original: For instance, in autonomous driving, a well-trained DNNs model may exhibit significant performance degradation at test time due to environmental changes, such as camera sensors, weather, and region (Choi et al., 2021; Lee et al., 2022; Kim et al., 2022b).
Revised: For instance, in autonomous driving, a well-trained DNNs model may exhibit significant performance degradation at test time due to environmental changes, such as camera sensors, weather, and region (Choi et al., 2021; Lee et al., 2022; Kim et al., 2022b).

Original: Test-time adaptation (TTA) has emerged to tackle the distribution shift between source and target domains during test time (Sun et al., 2020; Wang et al., 2020).
Revised: Test-time adaptation (TTA) has emerged to tackle the distribution shift between source and target domains during test time (Sun et al., 2020; Wang et al., 2020).

Original: Recent TTA approaches (Wang et al., 2020; Choi et al., 2022; Liu et al., 2021) address this issue by 1) (re-)estimating normalization statistics from current test input and 2) optimizing model parameters in unsupervised manner, such as entropy minimization (Grandvalet & Bengio, 2004; Long et al., 2016; Vu et al., 2019) and self-supervised losses (Sun et al., 2020; Liu et al., 2021).
Revised: Recent TTA approaches (Wang et al., 2020; Choi et al., 2022; Liu et al., 2021) address this issue by 1) (re-)estimating normalization statistics from current test input and 2) optimizing model parameters in unsupervised manner, such as entropy minimization (Grandvalet & Bengio, 2004; Long et al., 2016; Vu et al., 2019) and self-supervised losses (Sun et al., 2020; Liu et al., 2021).

Original: In particular, the former focused on the weakness of conventional batch normalization (CBN) (Ioffe & Szegedy, 2015) for domain shift in a test time.
Revised: In particular, the former focused on the weakness of conventional batch normalization (CBN) (Ioffe & Szegedy, 2015) for domain shift in a test time.

Original: As described in Fig. 1(b), when standardizing target feature activations using source statistics, which are collected from the training data, the activations can be transformed into an unintended feature space, resulting in misclassification.
Revised: As described in Fig. 1(b), when standardizing target feature activations using source statistics, which are collected from the training data, the activations can be transformed into an unintended feature space, resulting in misclassification.

Original: To this end, the TTA approaches (Wang et al., 2020; Choi et al., 2022; Wang et al., 2022) have heavily depended on the direct use of test batch statistics to fix such an invalid transformation in BN layers, called transductive BN (TBN) (Nado et al., 2020; Schneider et al., 2020; Bronskill et al., 2020) (see Fig.
Revised: To this end, the TTA approaches (Wang et al., 2020; Choi et al., 2022; Wang et al., 2022) have heavily depended on the direct use of test batch statistics to fix such an invalid transformation in BN layers, called transductive BN (TBN) (Nado et al., 2020; Schneider et al., 2020; Bronskill et al., 2020) (see Fig.

Original: 1(c)).
Revised: 1(c)).

Original: The approaches utilizing TBN showed promising results but have mainly been assessed in limited evaluation settings (Wang et al., 2020; Choi et al., 2022;
Revised: The approaches utilizing TBN showed promising results but have mainly been assessed in limited evaluation settings (Wang et al., 2020; Choi et al., 2022;

Original: Liu et al., 2021).
Revised: Liu et al., 2021).

Original: For instance, such evalua-
Revised: For instance, such evaluation settings assume large test batch sizes ( e.g., 200 or more) and a single stationary distribution shift

Original: [Figure]
Revised: [Figure]

Original: from tion settings assume large test batch sizes ( e.g., 200 or more) and a single stationary distribution shift ( i.e., single corruption).
Revised: [Figure] [Figure] ( i.e., single corruption).

Original: Recent studies suggest more practical evaluation scenarios based on small batch sizes (Mirza et al., 2022; Hu et al., 2021; Khurana et al., 2021) or continuously changing data distribution during test time (Wang et al., 2022).
Revised: Recent studies suggest more practical evaluation scenarios based on small batch sizes (Mirza et al., 2022; Hu et al., 2021; Khurana et al., 2021) or continuously changing data distribution during test time (Wang et al., 2022).

Original: We show that the performance of existing methods significantly drops once their impractical assumptions of the evaluation settings are violated.
Revised: We show that the performance of existing methods significantly drops once their impractical assumptions of the evaluation settings are violated.

Original: For example, as shown in Fig. 1(d), TBN (Nado et al., 2020) and TBN applied methods suffer from severe performance drop when the test batch size becomes small, while CBN is irrelevant to the test batch sizes.
Revised: For example, as shown in Fig. 1(d), TBN (Nado et al., 2020) and TBN applied methods suffer from severe performance drop when the test batch size becomes small, while CBN is irrelevant to the test batch sizes.

Original: We identify that CBN and TBN are in a trade-off relationship (Fig. 1), in the sense that one of each shows its strength when the other falls apart.
Revised: We identify that CBN and TBN are in a trade-off relationship (Fig. 1), in the sense that one of each shows its strength when the other falls apart.

Original: To tackle this problem, we present a novel test-time normalization (TTN) strategy that controls the trade-off between CBN and TBN by adjusting the importance of source and test batch statistics according to the domain-shift sensitivity of each BN layer.
Revised: To tackle this problem, we present a novel test-time normalization (TTN) strategy that controls the trade-off between CBN and TBN by adjusting the importance of source and test batch statistics according to the domain-shift sensitivity of each BN layer.

Original: Intuitively, we linearly interpolate between CBN and TBN so that TBN has a larger weight than CBN if the standardization needs to be adapted toward the test data.
Revised: Intuitively, we linearly interpolate between CBN and TBN so that TBN has a larger weight than CBN if the standardization needs to be adapted toward the test data.

Original: We optimize the interpolating weight after the pre-training but before the test time, which we refer to as the post-training phase.
Revised: We optimize the interpolating weight after the pre-training but before the test time, which we refer to as the post-training phase.

Original: Specifically, given a pre-trained model, we first estimate channel-wise sensitivity of the affine parameters in BN layers to domain shift by analyzing the gradients from the back-propagation of two input images, clean input and its augmented one (simulating unseen distribution).
Revised: Specifically, given a pre-trained model, we first estimate channel-wise sensitivity of the affine parameters in BN layers to domain shift by analyzing the gradients from the back-propagation of two input images, clean input and its augmented one (simulating unseen distribution).

Original: Afterward, we optimize the interpolating weight using the channel-wise sensitivity replacing BN with the TTN layers.
Revised: Afterward, we optimize the interpolating weight using the channel-wise sensitivity replacing BN with the TTN layers.

Original: It is noteworthy that none of the pre-trained model weights are modified, but we only train newly added interpolating weight.
Revised: It is noteworthy that none of the pre-trained model weights are modified, but we only train newly added interpolating weight.

Original: We empirically show that TTN outperforms existing TTA methods in realistic evaluation settings, i.e., with a wide range of test batch sizes for single, mixed, and continuously changing domain adaptation through extensive experiments on image classification and semantic segmentation tasks.
Revised: We empirically show that TTN outperforms existing TTA methods in realistic evaluation settings, i.e., with a wide range of test batch sizes for single, mixed, and continuously changing domain adaptation through extensive experiments on image classification and semantic segmentation tasks.

Original: TTN as a stand-alone method shows compatible results with the state-of-the-art methods and combining our TTN with the baselines even boosts their performance in overall scenarios.
Revised: TTN as a stand-alone method shows compatible results with the state-of-the-art methods and combining our TTN with the baselines even boosts their performance in overall scenarios.

Original: Moreover,
Revised: Moreover,

Original: TTN applied methods flexibly adapt to new target domains while sufficiently preserving the source knowledge.
Revised: TTN applied methods flexibly adapt to new target domains while sufficiently preserving the source knowledge.

Original: No action other than computing per batch statistics (which can be done simultaneously to the inference) is needed in test-time; TTN is compatible with other TTA methods without requiring additional computation cost.
Revised: No action other than computing per batch statistics (which can be done simultaneously to the inference) is needed in test-time; TTN is compatible with other TTA methods without requiring additional computation cost.

Original: Our contributions are summarized as follows:
Revised: Our contributions are summarized as follows:

Original: • We propose a novel domain-shift aware test-time normalization (TTN) layer that combines source and test batch statistics using channel-wise interpolating weights considering the [Figure] S Ƹ𝑧 T
Revised: • We propose a novel domain-shift aware test-time normalization (TTN) layer that combines source and test batch statistics using channel-wise interpolating weights considering the sensitivity to domain shift in order to flexibly adapt to new target domains while preserving the well-trained source knowledge.

Original: [Figure]
Revised: [Figure]

Original: 𝑧 𝑖𝑛
Revised: 𝑧 𝑖𝑛

Original: S Ƹ𝑧
Revised: S Ƹ𝑧

Original: T 𝑧 𝑜𝑢𝑡 𝜇 𝑠 ,𝜎 𝑠 𝛾,𝛽
Revised: T 𝑧 𝑜𝑢𝑡 𝜇 𝑠 ,𝜎 𝑠 𝛾

Original: [Figure]
Revised: [Figure]

Original: sensitivity to domain shift in order to flexibly adapt to new target domains while preserving the well-trained source knowledge.
Revised: 𝛽

Original:  • To show the broad applicability of our proposed TTN, which does not alter training or testtime schemes, we show that adding TTN to existing TTA methods significantly improves the performance across a wide range of test batch sizes (from 200 to 1) and in three realistic evaluation scenarios; stationary, continuously changing, and mixed domain adaptation.
Revised: [Figure] • To show the broad applicability of our proposed TTN, which does not alter training or testtime schemes, we show that adding TTN to existing TTA methods significantly improves the performance across a wide range of test batch sizes (from 200 to 1) and in three realistic evaluation scenarios; stationary, continuously changing, and mixed domain adaptation.

Original: • We evaluate our method through extensive experiments on image classification using CIFAR-10/100-C, and ImageNet-C (Hendrycks & Dietterich, 2018) and semantic segmentation task using CityScapes (Cordts et al., 2016), BDD-100K (
Revised: • We evaluate our method through extensive experiments on image classification using CIFAR-10/100-C, and ImageNet-C (Hendrycks & Dietterich and semantic segmentation task using CityScapes (Cordts et al. , BDD-100K (Yu et al.

Original: Yu et al., 2020), Mapillary (Neuhold et al., 2017), GTAV ( et al., ), and SYNTHIA (
Revised: , Mapillary (Neuhold et al GTAV (Richter et al., 2016), and SYNTHIA (Ros et al., 2016).

Original:  M ETHODOLOGY
Revised:  M ETHODOLOGY

Original: In this section, we describe our method, the Test-Time Normalization (TTN) layer, whose design is suitable for test-time adaptation (TTA) in practical usages out of the large batch size and i.i.d assumptions during a test time.
Revised: In this section, we describe our method, the Test-Time Normalization (TTN) layer, whose design is suitable for test-time adaptation (TTA) in practical usages out of the large batch size and i.i.d assumptions during a test time.

Original: We first define the problem setup in Section 2.1 and present our proposed TTN layers in Section 2.2.
Revised: We first define the problem setup in Section 2.1 and present our proposed TTN layers in Section 2.2.

Original: Finally, we discuss how we optimize TTN layers in Sections 2.3.
Revised: Finally, we discuss how we optimize TTN layers in Sections 2.3.

Original: 2. P ROBLEM S ETUP
Revised: 2. P ROBLEM S ETUP

Original: Let the train and test data be D S and D T and the corresponding probability distributions be P S and
Revised: Let the train and test data be D S and D T and the corresponding probability distributions be P S and

Original: P T , respectively, where D S and D T share the output space, i.e., { y i } ∼ D S =
Revised: P T , respectively, where D S and D T share the output space, i.e., { y i } ∼ D S =

Original: { y i } ∼ D T .
Revised: { y i } ∼ D T .

Original: The covariate shift in TTA is defined as P S ( x ) ̸ = P T ( x ) where P S ( y | x ) =
Revised: The covariate shift in TTA is defined as P S ( x ) ̸ = P T ( x ) where P S ( y | x ) =

Original: P T ( y | x ) (Quinonero-Candela et al., 2008).
Revised: P T ( y | x ) (Quinonero-Candela et al., 2008).

Original: A model, f θ , with parameters θ , is trained with a mini-batch, B S =
Revised: A model, f θ , with parameters θ , is trained with a mini-batch, B S =

Original: { ( x i , y i ) } |B S | i =1 , from source data D S , where x i is an example and y i is the corresponding label.
Revised: { ( x i , y i ) } |B S | i =1 , from source data D S , where x i is an example and y i is the corresponding label.

Original: During the test, f θ encounters a test batch B T ∼ D T , and the objective of TTA is correctly managing the test batch from the different distribution.
Revised: During the test, f θ encounters a test batch B T ∼ D T , and the objective of TTA is correctly managing the test batch from the different distribution.

Original: To simulate more practical TTA, we mainly consider two modifications: (1) various test batch sizes, |B T | , where small batch size indicates small latency while handling the test data online, and (2) multi, N -target domains, D T = {D T,i } Ni =1 .
Revised: To simulate more practical TTA, we mainly consider two modifications: (1) various test batch sizes, |B T | , where small batch size indicates small latency while handling the test data online, and (2) multi, N -target domains, D T = {D T,i } Ni =1 .

Original: Under this setting, each test batch B T is drawn by one of the test domains in D T , where D T may consist of a single target domain, multiple target domains, or mixture of target domains.
Revised: Under this setting, each test batch B T is drawn by one of the test domains in D T , where D T may consist of a single target domain, multiple target domains, or mixture of target domains

Original:  2. T EST -T IME N ORMALIZATION L 
Revised: . 2. T EST -T IME N ORMALIZATION L AYER

Original: AYER

Original: We denote an input of a BN layer as z ∈ R BCHW , forming a mini-batch size of B .
Revised: We denote an input of a BN layer as z ∈ R BCHW , forming a mini-batch size of B .

Original: The mean and variance of z are µ and σ 2 , respectively, which are computed as follows:
Revised: The mean and variance of z are µ and σ 2 , respectively, which are computed as follows:

Original: [Equation]
Revised: [Equation]

Revised: where µ and σ 2 are in R C , and C , H , and W stand for the number of channels, dimension of height, and that of width, respectively.

Revised: Based on µ and σ 2 , the source statistics µ s , σ 2 s ∈ R C are usually estimated with exponential moving average over the training data.

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure]
Revised: [Figure]

Original: Initializing α with prior A , (b-2) we optimize α using CE and MSE loss (Eq. 6) with augmented training data x ′ .
Revised: Initializing α with prior A , (b-2) we optimize α using CE and MSE loss (Eq. 6) with augmented training data x ′ .

Original: where µ and σ 2 are in R C , and C , H , and W stand for the number of channels, dimension of height, and that of width, respectively.

Original: Based on µ and σ 2 , the source statistics µ s , σ 2 s ∈ R C are usually estimated with exponential moving average over the training data.

Original: In BN layers, input z is first standardized with statistics µ and σ 2 and then is scaled and shifted with learnable parameters γ and β in R C .
Revised: In BN layers, input z is first standardized with statistics µ and σ 2 and then is scaled and shifted with learnable parameters γ and β in R C .

Original: The standardization uses current input batch statistics during training and uses estimated source statistics µ s and σ 2 s at test time (Fig. 2(b)).
Revised: The standardization uses current input batch statistics during training and uses estimated source statistics µ s and σ 2 s at test time (Fig. 2(b)).

Original: To address domain shifts in test time, we adjust the source statistics by combining the source and the test mini-batch statistics (Singh & Shrivastava, 2019; Summers & Dinneen, 2019) with a learnable interpolating weight α ∈ R C ranges [0 , 1] .
Revised: To address domain shifts in test time, we adjust the source statistics by combining the source and the test mini-batch statistics (Singh & Shrivastava, 2019; Summers & Dinneen, 2019) with a learnable interpolating weight α ∈ R C ranges [0 , 1] .

Original: Precisely, TTN standardizes a feature with
Revised: Precisely, TTN standardizes a feature with

Original: [Equation]
Revised: [Equation]

Original: while using the same affine parameters, γ and β .
Revised: while using the same affine parameters, γ and β .

Original: Note that we have different mixing ratios α c for every layer and channel.
Revised: Note that we have different mixing ratios α c for every layer and channel.

Original: 2. P OST T RAINING
Revised: 2. P OST T RAINING

Original: Like Choi et al.
Revised: Like Choi et al.

Original: (2022), we introduce an additional training phase, the post-training (after pretraining but before testing), to optimize the mixing parameters α in Eq.
Revised: (2022), we introduce an additional training phase, the post-training (after pretraining but before testing), to optimize the mixing parameters α in Eq.

Original: 2 (Fig. 2(a)).
Revised: 2 (Fig. 2(a)).

Original: Note that all parameters except α are frozen and we have access to the labeled source data during the posttraining.
Revised: Note that all parameters except α are frozen and we have access to the labeled source data during the posttraining.

Original: We first obtain prior knowledge A of α by identifying which layers and their channels are sensitive to domain shifts.
Revised: We first obtain prior knowledge A of α by identifying which layers and their channels are sensitive to domain shifts.

Original: Then, we optimize α with the prior knowledge and an additional objective term.
Revised: Then, we optimize α with the prior knowledge and an additional objective term.

Original: The overall procedure is depicted in Fig.
Revised: The overall procedure is depicted in Fig.

Original: 3 and the pseudocode is provided in appendix A.3.
Revised: 3 and the pseudocode is provided in appendix A.3.

Original: Obtain Prior A .
Revised: Obtain Prior A .

Original: To identify which BN layers and corresponding channels are sensitive to domain shifts, we simulate the domain shifts by augmenting 1 the clean image, i.e., original training data, and make a pair of (clean x , domain-shifted x ′ ) images, where the semantic information is shared.
Revised: To identify which BN layers and corresponding channels are sensitive to domain shifts, we simulate the domain shifts by augmenting 1 the clean image, i.e., original training data, and make a pair of (clean x , domain-shifted x ′ ) images, where the semantic information is shared.

Original: To analyze in which layer and channel the standardization statistics should be corrected, we consider the standardized features ˆ z ( l,c ) of z ( l,c ) , for a channel index c at a layer l , whose input is clean x .
Revised: To analyze in which layer and channel the standardization statistics should be corrected, we consider the standardized features ˆ z ( l,c ) of z ( l,c ) , for a channel index c at a layer l , whose input is clean x .

Original: We compare ˆ z ( l,c ) to that of domain-shifted one, ˆ z ′ ( l,c ) from x ′ .
Revised: We compare ˆ z ( l,c ) to that of domain-shifted one, ˆ z ′ ( l,c ) from x ′ .

Original: Since the pre-trained CBN uses the same µ ( l,c ) s and σ ( l,c ) s for both inputs, the difference between ˆ z ( l,c ) and ˆ z ′ ( l,c ) is caused by the domain discrepancy between x and x ′ .
Revised: Since the pre-trained CBN uses the same µ ( l,c ) s and σ ( l,c ) s for both inputs, the difference between ˆ z ( l,c ) and ˆ z ′ ( l,c ) is caused by the domain discrepancy between x and x ′ .

Original: We argue that if the difference is significant, the parameter at ( l, c ) is sensitive to the domain shift, i.e., intensely affected by the domain shift, and hence the standardization statistics at ( l, c ) should be adapted towards the shifted input.
Revised: We argue that if the difference is significant, the parameter at ( l, c ) is sensitive to the domain shift, i.e., intensely affected by the domain shift, and hence the standardization statistics at ( l, c ) should be adapted towards the shifted input.

Original: Drawing inspiration from Choi et al.
Revised: Drawing inspiration from Choi et al.

Original: (2022), we measure the domain-shift sensitivity by comparing gradients.
Revised: (2022), we measure the domain-shift sensitivity by comparing gradients.

Original: Since the standardized feature ˆ z is scaled and shifted by γ and β in each BN layer, we compare the gradients of affine parameters γ and β , ∇ γ and ∇ β , respectively, to measure the dissimilarity of ˆ z and ˆ z ′ .
Revised: Since the standardized feature ˆ z is scaled and shifted by γ and β in each BN layer, we compare the gradients of affine parameters γ and β , ∇ γ and ∇ β , respectively, to measure the dissimilarity of ˆ z and ˆ z ′ .

Original: As described in Fig. 3(a-1), we collect the ∇ γ and ∇ β using cross-entropy loss, L CE .
Revised: As described in Fig. 3(a-1), we collect the ∇ γ and ∇ β using cross-entropy loss, L CE .

Original: To this end, we introduce a gradient distance score , d ( l,c ) ∈ R for each channel c at layer l as follows:
Revised: To this end, we introduce a gradient distance score , d ( l,c ) ∈ R for each channel c at layer l as follows:

Original: [Equation]
Revised: [Equation]

Original: where ( g, g ′ ) is ( ∇ ( l,c ) γ , ∇ ( l,c ) γ ′ ) and ( ∇ ( l,c ) β , ∇ ( l,c ) β ′ ) for s ( l,c ) γ and s ( l,c ) β , respectively, N is the number of training data, and the resulting d ( l,c ) ∈ [0 , 1] .
Revised: where ( g, g ′ ) is ( ∇ ( l,c ) γ , ∇ ( l,c ) γ ′ ) and ( ∇ ( l,c ) β , ∇ ( l,c ) β ′ ) for s ( l,c ) γ and s ( l,c ) β , respectively, N is the number of training data, and the resulting d ( l,c ) ∈ [0 , 1] .

Original: Once we obtain s γ and s β from Eq.
Revised: Once we obtain s γ and s β from Eq.

Original: 3, we conduct min-max normalization over all s ( l,c ) γ and s ( l,c ) β , before computing Eq. 4.
Revised: 3, we conduct min-max normalization over all s ( l,c ) γ and s ( l,c ) β , before computing Eq. 4.

Original: To magnify the relative difference, we take the square as a final step and denote the result as a prior
Revised: To magnify the relative difference, we take the square as a final step and denote the result as a prior

Original: A (Fig. 3(a-2)):
Revised: A (Fig. 3(a-2)):

Original: [Equation]

Original: [Equation]
Revised: [Equation]

Original: where d ( l,. )
Revised: where d ( l,. )

Original: =
Revised: =

Original: [ d ( l,c ) ]
Revised: [ d ( l,c ) ]

Original: C l c =1 .
Revised: C l c =1 .

Original: Optimize α .
Revised: Optimize α .

Original: The goal of optimizing α is to make the combined statistics correctly standardize the features when the input is sampled from an arbitrary target domain.
Revised: The goal of optimizing α is to make the combined statistics correctly standardize the features when the input is sampled from an arbitrary target domain.

Original: After obtaining the prior
Revised: After obtaining the prior

Original: A , we replace CBN with TTN layers while keeping the affine parameters.
Revised: A , we replace CBN with TTN layers while keeping the affine parameters.

Original: Then, we initialize the interpolating weights α with A , which represents in which layer and channel the standardization statistics need to be adapted using test batch statistics (see Fig. 3(b-1)).
Revised: Then, we initialize the interpolating weights α with A , which represents in which layer and channel the standardization statistics need to be adapted using test batch statistics (see Fig. 3(b-1)).

Original: To simulate distribution shifts, we use augmented training data.
Revised: To simulate distribution shifts, we use augmented training data.

Original: Expecting the model to make consistent predictions either given clean or augmented inputs, we use cross-entropy loss L CE .
Revised: Expecting the model to make consistent predictions either given clean or augmented inputs, we use cross-entropy loss L CE .

Original: Furthermore, to prevent α from moving too far from the initial value A , we use mean-squared error loss L MSE between α and the prior A , i.e., L MSE =
Revised: Furthermore, to prevent α from moving too far from the initial value A , we use mean-squared error loss L MSE between α and the prior A , i.e., L MSE =

Original: ∥
Revised: ∥

Original: α −A∥ 2 as a constraint.
Revised: α −A∥ 2 as a constraint.

Original: Total loss L can be written as L =
Revised: Total loss L can be written as L =

Original: L CE + λ L MSE (6) , where λ is a weighting hyperparameter (Details are provided in the appendix A.1 & B.1).
Revised: L CE + λ L MSE (6) , where λ is a weighting hyperparameter (Details are provided in the appendix A.1 & B.1).

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: In image classification, we evaluate TTN for corruption robustness in realistic evaluation settings, i.e., where the test batch size can be variant and where the target domain can be either stationary, continuously changing, or mixed with multiple domains.
Revised: In image classification, we evaluate TTN for corruption robustness in realistic evaluation settings, i.e., where the test batch size can be variant and where the target domain can be either stationary, continuously changing, or mixed with multiple domains.

Original: Additionally, we further validate TTN on domain generalization benchmarks incorporating natural domain shifts ( e.g., changes in camera sensors, weather, time, and region) in semantic segmentation.
Revised: Additionally, we further validate TTN on domain generalization benchmarks incorporating natural domain shifts ( e.g., changes in camera sensors, weather, time, and region) in semantic segmentation.

Original: 3. E XPERIMENTAL S ETUP
Revised: 3. E XPERIMENTAL S ETUP

Original: Given models pre-trained on clean source data, we optimize TTN parameter α with the augmented source data in the post-training phase.
Revised: Given models pre-trained on clean source data, we optimize TTN parameter α with the augmented source data in the post-training phase.

Original: Afterward, we evaluate our post-trained model on the corrupted target data.
Revised: Afterward, we evaluate our post-trained model on the corrupted target data.

Original: Implementation details are provided in the appendix A.1.
Revised: Implementation details are provided in the appendix A.1.

Original: Datasets and models.
Revised: Datasets and models.

Original: We use corruption benchmark datasets CIFAR-10/100-C and ImageNet-C, which consist of 15 types of common corruptions at five severity levels (Hendrycks & Dietterich, 2018).
Revised: We use corruption benchmark datasets CIFAR-10/100-C and ImageNet-C, which consist of 15 types of common corruptions at five severity levels (Hendrycks & Dietterich, 2018).

Original: Each corruption is applied to test images of the clean datasets (CIFAR-10/100 and ImageNet).
Revised: Each corruption is applied to test images of the clean datasets (CIFAR-10/100 and ImageNet).

Original: We use a training set of the clean dataset for post-training and the corrupted dataset for evaluation.
Revised: We use a training set of the clean dataset for post-training and the corrupted dataset for evaluation.

Original: As backbone models, we used WideResNet-40-2 (Hendrycks et al., 2019) trained on
Revised: As backbone models, we used WideResNet-40-2 (Hendrycks et al., 2019) trained on

Original: CIFAR-10/100, and ResNet-50 (He et al., 2016) trained on ImageNet.
Revised: CIFAR-10/100, and ResNet-50 (He et al., 2016) trained on ImageNet.

Original: To validate our method in semantic segmentation, we conduct experiments on Cityscapes (Cordts et al., 2016), BDD-100K (Yu et al., 2020), Mapillary (Neuhold et al., 2017), GTAV (Richter et al., 2016), and SYNTHIA (Ros et al., 2016) datasets, in accordance with the experimental setup for domain generalization proposed in RobustNet (Choi et al., 2021).
Revised: To validate our method in semantic segmentation, we conduct experiments on Cityscapes (Cordts et al., 2016), BDD-100K (Yu et al., 2020), Mapillary (Neuhold et al., 2017), GTAV (Richter et al., 2016), and SYNTHIA (Ros et al., 2016) datasets, in accordance with the experimental setup for domain generalization proposed in RobustNet (Choi et al., 2021).

Original: Baselines.
Revised: Baselines.

Original: To demonstrate that TTN successfully controls the trade-off between CBN and TBN, we compare TTN with (1)
Revised: To demonstrate that TTN successfully controls the trade-off between CBN and TBN, we compare TTN with (1)

Original: AdaptiveBN (Schneider et al., 2020), (2)
Revised: AdaptiveBN (Schneider et al., 2020), (2)

Original: α -BN
Revised: α -BN

Original: (You et al., 2021) and (3)
Revised: (You et al., 2021) and (3)

Original: [Table] [Table] MixNorm (Hu et al., 2021), which combines or takes the moving average of the source and the test batch statistics with a pre-defined hyperparameter ( i.e., a constant α ).
Revised: MixNorm (Hu et al., 2021), which combines or takes the moving average of the source and the test batch statistics with a pre-defined hyperparameter ( i.e., a constant α ).

Original: The following baselines are suggested on top of TBN (Nado et al., 2020); (4) TENT (Wang et al., 2020) optimizes BN affine parameters via entropy minimization.
Revised: The following baselines are suggested on top of TBN (Nado et al., 2020); (4) TENT (Wang et al., 2020) optimizes BN affine parameters via entropy minimization.

Original: (5) SWR (Choi et al., 2022) updates the entire model parameters considering the domain-shift sensitivity.
Revised: (5) SWR (Choi et al., 2022) updates the entire model parameters considering the domain-shift sensitivity.

Original: (6) CoTTA (Wang et al., 2022) ensembles the output of  augmented test inputs, updates the entire model parameters using a consistency loss between student and teacher models, and stochastically restores the pre-trained model.
Revised: (6) CoTTA (Wang et al., 2022) ensembles the output of [Table] [Table] augmented test inputs, updates the entire model parameters using a consistency loss between student and teacher models, and stochastically restores the pre-trained model.

Original: We refer to TBN, (1), (2), and (3) as normalization -based methods (Norm), the other as optimization -based methods (Optim.), and denote the pre-trained model using CBN as ‘source’.
Revised: We refer to TBN, (1), (2), and (3) as normalization -based methods (Norm), the other as optimization -based methods (Optim.), and denote the pre-trained model using CBN as ‘source’.

Original: Evaluation scenarios.
Revised: Evaluation scenarios.

Original: To show that TTN performs robust on various test batch sizes, we conduct experiments with test batch sizes of 200, 64, 16, 4, 2, and 1.
Revised: To show that TTN performs robust on various test batch sizes, we conduct experiments with test batch sizes of 200, 64, 16, 4, 2, and 1.

Original: We evaluate our method in three evaluation scenarios; single , continuously changing , and mixed domain adaptation.
Revised: We evaluate our method in three evaluation scenarios; single , continuously changing , and mixed domain adaptation.

Original: In the single domain adaptation, the model is optimized for one corruption type and then reset before adapting to the subsequent corruption, following the evaluation setting from TENT and SWR.
Revised: In the single domain adaptation, the model is optimized for one corruption type and then reset before adapting to the subsequent corruption, following the evaluation setting from TENT and SWR.

Original: In the continuously changing adaptation (Wang et al., 2022), the model is continuously adapted to 15 corruption types (w/o the reset), which is more realistic because it is impractical to precisely indicate when the data distribution has shifted in the real world.
Revised: In the continuously changing adaptation (Wang et al., 2022), the model is continuously adapted to 15 corruption types (w/o the reset), which is more realistic because it is impractical to precisely indicate when the data distribution has shifted in the real world.

Original: Finally, to simulate the non-stationary target domain where various domains coexist, we evaluate methods in the mixed domain adaptation setting, where a single batch contains multiple domains.
Revised: Finally, to simulate the non-stationary target domain where various domains coexist, we evaluate methods in the mixed domain adaptation setting, where a single batch contains multiple domains.

Original: We use a severity level of 5 (Hendrycks & Dietterich, 2018) for all experiments.
Revised: We use a severity level of 5 (Hendrycks & Dietterich, 2018) for all experiments.

Original: It is noteworthy that we use a single checkpoint of TTN parameter α for each dataset across all experimental settings.
Revised: It is noteworthy that we use a single checkpoint of TTN parameter α for each dataset across all experimental settings.

Original: 3. E XPERIMENTS ON I MAGE C LASSIFICATION
Revised: 3. E XPERIMENTS ON I MAGE C LASSIFICATION

Original: Tables 1, 2, and 3 show error rates on corruption benchmark datasets in three different evaluation scenarios; single domain, continuously changing, and mixed domain adaptation, respectively.
Revised: Tables 1, 2, and 3 show error rates on corruption benchmark datasets in three different evaluation scenarios; single domain, continuously changing, and mixed domain adaptation, respectively.

Original: Note that the performance of normalization-based methods in the single (Table 1) and in the continuously changing (Table 2) settings are identical.
Revised: Note that the performance of normalization-based methods in the single (Table 1) and in the continuously changing (Table 2) settings are identical.

Original: Tables 4 and 5 show the adaptation performance on the source and class imbalanced target domains, respectively.
Revised: Tables 4 and 5 show the adaptation performance on the source and class imbalanced target domains, respectively.

Original: More results and discussions are provided in the appendix B, importantly, including results on ImageNet-C (B.5).[Table] [Table]
Revised: More results and discussions are provided in the appendix B, importantly, including results on ImageNet-C (B.5).

Original: Robustness to practical settings.
Revised: Robustness to practical settings.

Original: In Table 1, [Table] and 3, TTN and TTN applied methods show robust performance over the test batch size ranges from 200 to 1.
Revised: In Table 1, 2, and 3, TTN and TTN applied methods show robust performance over the test batch size ranges from 200 to 1.

Original: Comparing with normalization-based baselines, we demonstrate that TTN, which uses channel-wisely optimized combining rate α 
Revised: Comparing with normalization-based baselines, we demonstrate that TTN, which uses channel-wisely optimized combining rate α , shows better results than defining α as a constant hyperparameter, which can be considered as a special

Original: [Table]
Revised: [Table]

Original: shows better results than defining α as a constant hyperparameter, which can be considered as a special case of TTN; TBN and α -BN corresponds to α = 1 and 0 . 1 , respectively.
Revised: case of TTN; TBN and α -BN corresponds to α = 1 and 0 . 1 , respectively.

Original: More comparisons with different constant α are provided in the appendix B.2.
Revised: More comparisons with different constant α are provided in the appendix B.2.

Original: It is noteworthy that TTN as a stand-alone method favorably compares with optimization-based baselines in all three scenarios
Revised: It is noteworthy that TTN as a stand-alone method favorably compares with optimization-based baselines in all three scenarios.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: severity level 5 using WideResNet-40-

Original: Details are provided in the appendix A.2.

Original: [Table]
Revised: [Table]

Original: Adopting TTN improves other TTA methods.
Revised: Adopting TTN improves other TTA methods.

Original: We compare optimization-based methods with and without TTN layers.
Revised: We compare optimization-based methods with and without TTN layers.

Original: Since TENT, SWR, and CoTTA optimize model parameters on top of using TBN layers, they also suffer from performance drops when the test batch size becomes small.
Revised: Since TENT, SWR, and CoTTA optimize model parameters on top of using TBN layers, they also suffer from performance drops when the test batch size becomes small.

Original: Adopting TTN reduces the dependency on large test batch size, i.e., makes robust to small batch size, and even improves their performance when using large test batch.
Revised: Adopting TTN reduces the dependency on large test batch size, i.e., makes robust to small batch size, and even improves their performance when using large test batch.

Original: Furthermore, in continual (Table 2) and mixed domain (Table 3) adaptation scenario, TENT and SWR shows higher error rate than in single domain (Table 1) adaptation.
Revised: Furthermore, in continual (Table 2) and mixed domain (Table 3) adaptation scenario, TENT and SWR shows higher error rate than in single domain (Table 1) adaptation.

Original: We interpret that because they update the model parameters based on the current output and predict the next input batch using the updated model, the model will not perform well if the consecutive batches have different corruption types ( i.e., mixed domain adaptation).
Revised: We interpret that because they update the model parameters based on the current output and predict the next input batch using the updated model, the model will not perform well if the consecutive batches have different corruption types ( i.e., mixed domain adaptation).

Original: Moreover, the error from the previous input batch propagates to the future input stream, and thus they may fall apart rapidly once they have a strongly wrong signal, which can happen in continual adaptation ( i.e., long-term adaptation without resetting).
Revised: Moreover, the error from the previous input batch propagates to the future input stream, and thus they may fall apart rapidly once they have a strongly wrong signal, which can happen in continual adaptation ( i.e., long-term adaptation without resetting).

Original: Applying TTN significantly accelerates their model performance regardless of the evaluation scenarios.
Revised: Applying TTN significantly accelerates their model performance regardless of the evaluation scenarios.

Original: TTN preserves knowledge on source domain.
Revised: TTN preserves knowledge on source domain.

Original: In practice, data driven from the source domain (or a merely different domain) can be re-encountered in test time.
Revised: In practice, data driven from the source domain (or a merely different domain) can be re-encountered in test time.

Original: We used clean domain test data in the single domain adaptation scenario to show how TTN and other TTA methods adapt to the seen source domain data (but unseen instance).
Revised: We used clean domain test data in the single domain adaptation scenario to show how TTN and other TTA methods adapt to the seen source domain data (but unseen instance).

Original: As shown in Table 4, all baseline methods using TBN layers, show performance drops even with large batch sizes.
Revised: As shown in Table 4, all baseline methods using TBN layers, show performance drops even with large batch sizes.

Original: We can conclude that it is still better to rely on source statistics collected from the large training data than using only current input statistics, even if its batch size is large enough to obtain reliable statistics ( i.e., 200).
Revised: We can conclude that it is still better to rely on source statistics collected from the large training data than using only current input statistics, even if its batch size is large enough to obtain reliable statistics ( i.e., 200).

Original: However, since TTN utilizes source statistics while leveraging the current input, TTN itself and TTN adopted methods well preserve the source knowledge compared to the TBN-based methods.
Revised: However, since TTN utilizes source statistics while leveraging the current input, TTN itself and TTN adopted methods well preserve the source knowledge compared to the TBN-based methods.

Original: With a batch size of 200, we observe that combining the source and a current test batch statistics outperforms the source model (see 3rd row of Table 4).[Table]
Revised: With a batch size of 200, we observe that combining the source and a current test batch statistics outperforms the source model (see 3rd row of Table 4).

Original: TTN is robust to class imbalanced scenario.
Revised: TTN is robust to class imbalanced scenario.

Original: Heavily depending on current test batch statistics are especially vulnerable when the class labels are imbalanced (Boudiaf et al., 2022;
Revised: Heavily depending on current test batch statistics are especially vulnerable when the class labels are imbalanced (Boudiaf et al., 2022;

Original: Gong et al., 2022).
Revised: Gong et al., 2022).

Original: To simulate this situation, we sorted test images in class label order and then sampled test batches following the sorted data order.
Revised: To simulate this situation, we sorted test images in class label order and then sampled test batches following the sorted data order.

Original: In Table 
Revised: In Table 5, we observe that TTN is more robust to the class imbalanced scenario than utilizing only test batch statistics ( i.e., TBN). As explained in Section 3.5,

Original: [Table]
Revised: [Table]

Original: we observe that TTN is more robust to the class imbalanced scenario than utilizing only test batch statistics ( i
Revised: we are putting more importance on CBN than TBN

Original: [Table]
Revised: [Table]

Original: e., TBN). As explained in Section 3.5, we are putting more importance on CBN than TBN, where semantic information is mainly handled,
Revised: where semantic information is mainly handled,

Original: i
Revised: i

Original: [Table]
Revised: [Table]

Revised: e.

Original: e., in deeper layers, so we can understand that TTN is less impacted by skewed label distribution.
Revised: [Table] in deeper layers [Table] so we can understand that TTN is less impacted by skewed label distribution.

Original: 3. E XPERIMENTS ON S EMANTIC S EGMENTATION
Revised: 3. E XPERIMENTS ON S EMANTIC S EGMENTATION

Original: We additionally conduct experiments on domain generalization (DG) benchmarks (Choi et al., 2021; Pan et al., 2018) for semantic segmentation, including natural domain shifts ( e
Revised: We additionally conduct experiments on domain generalization (DG) benchmarks (Choi et al., 2021; Pan et al., 2018) for semantic segmentation, including natural domain shifts ( e

Original: [Table]
Revised: [Table]

Original: g.,
Revised: g.,

Original: Cityscapes → BDD-100K), to demonstrate the broad applicability of TTN.
Revised: Cityscapes → BDD-100K) [Table] to demonstrate the broad applicability of TTN.

Original: Table 6 shows the results of evaluating the ResNet-50-based DeepLabV3 + (Chen et al., 2018) model trained on the Cityscapes training set using the validation set of real-world datasets such as Cityscapes, BDD-100K, and Mapillary, and synthetic datasets including GTAV and SYNTHIA.
Revised: Table 6 shows the results of evaluating the ResNet-50-based DeepLabV3 + (Chen et al., 2018) model trained on the Cityscapes training set using the validation set of real-world datasets such as Cityscapes, BDD-100K [Table] and Mapillary, and synthetic datasets including GTAV and SYNTHIA.

Original: We employ a test batch size of 2 for test-time adaptation in semantic segmentation.
Revised: We employ a test batch size of 2 for test-time adaptation in semantic segmentation.

Original: We observe that even when exploiting test batch statistics for standardization in BN layers (TBN) or updating the model parameters on top of TBN (TENT, SWR) does not improve the model performance ( i.e. , perform worse than the source model), adopting TTN helps the model make good use of the strength of the test batch statistics.
Revised: We observe that even when exploiting test batch statistics for standardization in BN layers (TBN) or updating the model parameters on top of TBN (TENT, SWR) does not improve the model performance ( i.e. , perform worse than the source model), adopting TTN helps the model make good use of the strength of the test batch statistics.

Original: Implementation details and additional results are provided in the appendix A.1 and B.7, respectively.
Revised: Implementation details and additional results are provided in the appendix A.1 and B.7, respectively.

Original: 3. A BLATION S TUDIES
Revised: 3. A BLATION S TUDIES

Original: Prior A regularizes α to be robust to overall test batch sizes.
Revised: Prior A regularizes α to be robust to overall test batch sizes.

Original: We conduct an ablation study on the importance of each proposed component, i.e., initializing α with prior A , optimizing α using CE and MSE losses, and the results are shown in Table 7.
Revised: We conduct an ablation study on the importance of each proposed component, i.e., initializing α with prior A , optimizing α using CE and MSE losses, and the results are shown in Table 7.

Original: Using A for initialization and MSE loss aims to optimize α following our intuition that we discussed in Section 2.3.
Revised: Using A for initialization and MSE loss aims to optimize α following our intuition that we discussed in Section 2.3.

Original: Optimizing α using CE loss improves the overall performance, but without regularizing with MSE loss, α may overfit to large batch size (rows 2 & 3).
Revised: Optimizing α using CE loss improves the overall performance, but without regularizing with MSE loss, α may overfit to large batch size (rows 2 & 3).

Original: Initialization with A or not does not show a significant difference, but A provides a better starting point than random initialization when comparing the left and right of the 2nd row.
Revised: Initialization with A or not does not show a significant difference, but A provides a better starting point than random initialization when comparing the left and right of the 2nd row.

Original: We observe that when using MSE loss, regardless of initialization using A , the optimized α sufficiently reflects our intuition resulting in a low error rate to overall batch sizes (row 3).
Revised: We observe that when using MSE loss, regardless of initialization using A , the optimized α sufficiently reflects our intuition resulting in a low error rate to overall batch sizes (row 3).

Original: [Table]
Revised: [Table]

Original: 3. V ISUALIZATION OF α
Revised: 3. V ISUALIZATION OF α

Original: Fig.
Revised: Fig.

Original: 4 shows the visualization of optimized α for CIFAR-10 using WideResNet-40-2.
Revised: 4 shows the visualization of optimized α for CIFAR-10 using WideResNet-40-2.

Original: We observe that α decreases from shallow to deep layers (left to right), which means CBN is more active in deeper layers [Table] and TBN is vice versa.
Revised: We observe that α decreases from shallow to deep layers (left to right), which means CBN is more active in deeper layers, and TBN is vice versa.

Original: As shown in Table 4 and 6, CBN employing source statistics is superior to TBN when the distribution shift between source and target domains is small.
Revised: As shown in Table 4 and 6, CBN employing source statistics is superior to TBN when the distribution shift between source and target domains is small.

Original: Assuming that the α we obtained is optimal, we can conjecture that CBN is more active ( i [Table] e., α closer to [Figure]
Revised: Assuming that the α we obtained is optimal, we can conjecture that CBN is more active ( i.e., α closer to 0) in deeper layers because domain information causing the distribution shift has been diminished.

Original: 0) in deeper layers because domain information causing the distribution shift has been diminished.

Original: In contrast, TBN has a larger weight ( i.e., α closer to 1) in shallower layers since the domain information induces a large distribution shift.
Revised: In contrast, TBN has a larger weight ( i.e., α closer to 1) in shallower layers since the domain information induces a large distribution shift.

Original: This interpretation is consistent with the observations of previous studies (Pan et al., 2018;
Revised: This interpretation is consistent with the observations of previous studies (Pan et al., 2018;

Original: Wang et al., 2021; Kim et al., 2022a) that style information mainly exists in shallower layers, whereas only content information remains in deeper layers. 
Revised: Wang et al., 2021; Kim et al., 2022a) that style information mainly exists in shallower layers, whereas only content information remains in deeper layers. [Figure]

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Test-time adaptation/training (TTA) aims to adapt models towards test data to overcome the performance degradation caused by distribution shifts (Sun et al., 2020;
Revised: Test-time adaptation/training (TTA) aims to adapt models towards test data to overcome the performance degradation caused by distribution shifts (Sun et al., 2020;

Original: Wang et al., 2020).
Revised: Wang et al., 2020).

Original: There are other related problems, unsupervised domain adaptation (UDA) (Sun & Saenko, 2016;
Revised: There are other related problems, unsupervised domain adaptation (UDA) (Sun & Saenko, 2016;

Original: Ganin et al., 2016) and source-free domain adaptation (SFDA) (Liang et al., 2020; Huang et al., 2021; Liu et al., 2021).
Revised: Ganin et al., 2016) and source-free domain adaptation (SFDA) (Liang et al., 2020; Huang et al., 2021; Liu et al., 2021).

Original: Both UDA and SFDA have access to sufficiently large enough unlabeled target datasets, and their objective is to achieve high performance on that particular target domain.
Revised: Both UDA and SFDA have access to sufficiently large enough unlabeled target datasets, and their objective is to achieve high performance on that particular target domain.

Original: Unlike UDA and
Revised: Unlike UDA and

Original: SFDA, TTA utilizes test data in an online manner.
Revised: SFDA, TTA utilizes test data in an online manner.

Original: There are two key factors of recent approaches: adapting standardization statistics in normalization layers and adapting model parameters.
Revised: There are two key factors of recent approaches: adapting standardization statistics in normalization layers and adapting model parameters.

Original: Normalization in Test Time.
Revised: Normalization in Test Time.

Original: Nado et al.
Revised: Nado et al.

Original: (2020) suggested prediction-time BN, which uses test batch statistics for standardization and Schneider et al.
Revised: (2020) suggested prediction-time BN, which uses test batch statistics for standardization and Schneider et al.

Original: (2020) introduced to adapt BN statistics by combining source and test batch statistics considering the the test batch size to mitigate the intermediate covariate shift.
Revised: (2020) introduced to adapt BN statistics by combining source and test batch statistics considering the the test batch size to mitigate the intermediate covariate shift.

Original: In this paper, we refer to the former method as TBN.
Revised: In this paper, we refer to the former method as TBN.

Original: Similarly, You et al.
Revised: Similarly, You et al.

Original: (2021) and Khurana et al.
Revised: (2021) and Khurana et al.

Original: (2021) mixed the statistics using predefined hyperparameter.
Revised: (2021) mixed the statistics using predefined hyperparameter.

Original: Also, Mirza et al.
Revised: Also, Mirza et al.

Original: (2022) and Hu et al.
Revised: (2022) and Hu et al.

Original: (2021) adapted the statistics using moving average while augmenting the input to form a pseudo test batch when only a single instance is given.
Revised: (2021) adapted the statistics using moving average while augmenting the input to form a pseudo test batch when only a single instance is given.

Original: The primary difference with the existing approaches is that we consider the channel-wise domain-shift sensitivity of BN layers to optimize the interpolating weights between CBN and TBN.
Revised: The primary difference with the existing approaches is that we consider the channel-wise domain-shift sensitivity of BN layers to optimize the interpolating weights between CBN and TBN.

Original: Concurrently, Zou et al.
Revised: Concurrently, Zou et al.

Original: (2022) proposed to adjust the standardization statistics using a learnable calibration strength and showed its effectiveness focusing on the semantic segmentation task.
Revised: (2022) proposed to adjust the standardization statistics using a learnable calibration strength and showed its effectiveness focusing on the semantic segmentation task.

Original: Optimization in Test Time.
Revised: Optimization in Test Time.

Original: TENT (Wang et al., 2020), SWR (Choi et al., 2022), and CoTTA (Wang et al., 2022) updated model parameters while using TBN.
Revised: TENT (Wang et al., 2020), SWR (Choi et al., 2022), and CoTTA (Wang et al., 2022) updated model parameters while using TBN.

Original: TENT optimized affine parameters in
Revised: TENT optimized affine parameters in

Original: BN layers using entropy minimization while freezing the others.
Revised: BN layers using entropy minimization while freezing the others.

Original: To maximize the adaptability,
Revised: To maximize the adaptability,

Original: SWR updated the entire model parameters minimizing the entropy loss based on the domain-shift sensitivity.
Revised: SWR updated the entire model parameters minimizing the entropy loss based on the domain-shift sensitivity.

Original: To stabilize the adaptation in continuously changing domains, CoTTA used consistency loss between student and teacher models and stochastically restored random parts of the pre-trained model.
Revised: To stabilize the adaptation in continuously changing domains, CoTTA used consistency loss between student and teacher models and stochastically restored random parts of the pre-trained model.

Original: Liu et al.
Revised: Liu et al.

Original: (2021) and Chen et al.
Revised: (2021) and Chen et al.

Original: (2022) suggested to update the model through contrastive learning.
Revised: (2022) suggested to update the model through contrastive learning.

Original: We focus on correcting the standardization statistics using domain-shift aware interpolating weight α .
Revised: We focus on correcting the standardization statistics using domain-shift aware interpolating weight α .

Original: Similar to Choi et al.
Revised: Similar to Choi et al.

Original: (2022), we measure the domain-shift sensitivity by comparing gradients.
Revised: (2022), we measure the domain-shift sensitivity by comparing gradients.

Original: The principle difference is that we use channel-wise sensitivity when optimizing α in post-training, while SWR used layer-wise sensitivity regularizing the entire model update in test time.
Revised: The principle difference is that we use channel-wise sensitivity when optimizing α in post-training, while SWR used layer-wise sensitivity regularizing the entire model update in test time.

Original:  C ONCLUSIONS
Revised:  C ONCLUSIONS

Original: This paper proposes TTN, a novel domain-shift aware batch normalization layer, which combines the benefits of CBN and TBN that have a trade-off relationship.
Revised: This paper proposes TTN, a novel domain-shift aware batch normalization layer, which combines the benefits of CBN and TBN that have a trade-off relationship.

Original: We present a strategy for mixing
Revised: We present a strategy for mixing

Original: CBN and TBN based on the interpolating weight derived from the optimization procedure utilizing the sensitivity to domain shift and show that our method significantly outperforms other normalization techniques in various realistic evaluation settings.
Revised: CBN and TBN based on the interpolating weight derived from the optimization procedure utilizing the sensitivity to domain shift and show that our method significantly outperforms other normalization techniques in various realistic evaluation settings.

Original: Additionally, our method is highly practical because it can complement other optimization-based TTA methods.
Revised: Additionally, our method is highly practical because it can complement other optimization-based TTA methods.

Original: The oracle mixing ratio between
Revised: The oracle mixing ratio between

Original: CBN and TBN can vary depending on the domain gap difference.
Revised: CBN and TBN can vary depending on the domain gap difference.

Original: However, our proposed method employs a fixed mixing ratio during test time, where the mixing ratio is optimized before model deployment.
Revised: However, our proposed method employs a fixed mixing ratio during test time, where the mixing ratio is optimized before model deployment.

Original: If we could find the optimal mixing ratio according to the distribution shift during test time, we can expect further performance improvement.
Revised: If we could find the optimal mixing ratio according to the distribution shift during test time, we can expect further performance improvement.

Original: We consider it as future work.
Revised: We consider it as future work.

Original: In this regard, our efforts encourage this field to become more practical and inspire new lines of research.
Revised: In this regard, our efforts encourage this field to become more practical and inspire new lines of research.

Original: R EPRODUCIBILITY S TATEMENT
Revised: R EPRODUCIBILITY S TATEMENT

Original: To ensure the reproducibility of our method, we provide the experimental setup in Section 3.1.
Revised: To ensure the reproducibility of our method, we provide the experimental setup in Section 3.1.

Original: Moreover, the details on implementation and evaluation settings can be found in the appendix A. and A.2, respectively.
Revised: Moreover, the details on implementation and evaluation settings can be found in the appendix A. and A.2, respectively.

Original: The pseudocode for overall training and testing scheme is provided in the appendix A.3.
Revised: The pseudocode for overall training and testing scheme is provided in the appendix A.3.

Original: Together with related references and publicly available codes, we believe our paper contains sufficient information for reimplementation
Revised: Together with related references and publicly available codes, we believe our paper contains sufficient information for reimplementation

Original: A CKNOWLEDGEMENT
Revised: A CKNOWLEDGEMENT

Original: We would like to thank Kyuwoong Hwang, Simyung Chang and Seunghan Yang of the Qualcomm
Revised: We would like to thank Kyuwoong Hwang, Simyung Chang and Seunghan Yang of the Qualcomm

Original: AI Research team for their valuable discussions.
Revised: AI Research team for their valuable discussions.

Original: A A PPENDIX : F OR R EPRODUCIBILITY
Revised: A A PPENDIX : F OR R EPRODUCIBILITY

Original: This section provides supplemental material for Section 2 and 3.1.
Revised: This section provides supplemental material for Section 2 and 3.1.

Original: A. I MPLEMENTATION D ETAILS
Revised: A. I MPLEMENTATION D ETAILS

Original: Datasets and Models.
Revised: Datasets and Models.

Original: For CIFAR-10/100-C, we optimized α using augmented CIFAR-10/ training set on the pre-trained WideResNet-40-2 (WRN-40) (Hendrycks et al., 2019).
Revised: For CIFAR-10/100-C, we optimized α using augmented CIFAR-10/ training set on the pre-trained WideResNet-40-2 (WRN-40) (Hendrycks et al., 2019).

Original: For ImageNetC, we used augmented ImageNet training set (randomly sampled 64000 instances per epoch) on the pre-trained ResNet-50.
Revised: For ImageNetC, we used augmented ImageNet training set (randomly sampled 64000 instances per epoch) on the pre-trained ResNet-50.

Original: Augmentation.
Revised: Augmentation.

Original: Following the setting of SWR (Choi et al., 2022), we used color jittering, random invert and random grayscale when obtaining the prior A .
Revised: Following the setting of SWR (Choi et al., 2022), we used color jittering, random invert and random grayscale when obtaining the prior A .

Original: When optimizing α , we followed the augmentation choice of CoTTA (Wang et al., 2022), which are color jittering, padding, random affine, gaussian blur, center crop and random horizontal flip.
Revised: When optimizing α , we followed the augmentation choice of CoTTA (Wang et al., 2022), which are color jittering, padding, random affine, gaussian blur, center crop and random horizontal flip.

Original: We excluded for gaussian noise to avoid any overlap with corruption type of common corruptions (Hendrycks & Dietterich, 2018).
Revised: We excluded for gaussian noise to avoid any overlap with corruption type of common corruptions (Hendrycks & Dietterich, 2018).

Original: For
Revised: For

Original: ImageNet, we only used the same augmentation both for obtaining A and optimizing α following the SWR augmentation choices.
Revised: ImageNet, we only used the same augmentation both for obtaining A and optimizing α following the SWR augmentation choices.

Original: Post-training.
Revised: Post-training.

Original: When obtaining prior, we used randomly selected 1024 samples from the training set, following the setting of SWR.
Revised: When obtaining prior, we used randomly selected 1024 samples from the training set, following the setting of SWR.

Original: We used Adam (Kingma & Ba, 2015) optimizer using a learning rate (LR) of 1e-3, which is decayed with cosine schedule (Loshchilov & Hutter, 2017) for 30 epochs and used 200 training batch for CIFAR-10/100.
Revised: We used Adam (Kingma & Ba, 2015) optimizer using a learning rate (LR) of 1e-3, which is decayed with cosine schedule (Loshchilov & Hutter, 2017) for 30 epochs and used 200 training batch for CIFAR-10/100.

Original: For ImageNet, we lowered LR to 2.5e-4 and used 64 batch size.
Revised: For ImageNet, we lowered LR to 2.5e-4 and used 64 batch size.

Original: For semantic segmentation task, we trained TTN using Cityscapes training set, and training batch size of 2.
Revised: For semantic segmentation task, we trained TTN using Cityscapes training set, and training batch size of 2.

Original: We resized the image height to 800 while preserving the original aspect ratio Cordts et al.
Revised: We resized the image height to 800 while preserving the original aspect ratio Cordts et al.

Original: We can terminate the training when MSE loss saturates (We observed that α does not show significant difference after the MSE loss is saturated).
Revised: We can terminate the training when MSE loss saturates (We observed that α does not show significant difference after the MSE loss is saturated).

Original: We used the weighting hyperparmeter
Revised: We used the weighting hyperparmeter

Original: to
Revised: to

Original: MSE
Revised: MSE

Original: loss λ as
Revised: loss λ as

Original: Test time.
Revised: Test time.

Original: For AdaptiveBN, which adjusts the interpolating weight using two factors: hyperparameter N and test batch size n , we followed the suggested N , which is empirically obtained best hyperparameter from the original paper, for each n (Figure 11, ResNet architecture from Schneider et al.
Revised: For AdaptiveBN, which adjusts the interpolating weight using two factors: hyperparameter N and test batch size n , we followed the suggested N , which is empirically obtained best hyperparameter from the original paper, for each n (Figure 11, ResNet architecture from Schneider et al.

Original: In detail, we set N as 256, 128, 64, 32, and 16 for test batch size 200, 64, 16, 4, 2, and 1, which yields α as 0.44, 0.33, 0.2, 0.11, 0.06, and 0.06, respectively.
Revised: In detail, we set N as 256, 128, 64, 32, and 16 for test batch size 200, 64, 16, 4, 2, and 1, which yields α as 0.44, 0.33, 0.2, 0.11, 0.06, and 0.06, respectively.

Original: For optimization-based TTA methods, we followed default setting in TENT, SWR, and CoTTA for test-time adaptation.
Revised: For optimization-based TTA methods, we followed default setting in TENT, SWR, and CoTTA for test-time adaptation.

Original: We used LR of 1e-3 to test batch size of 200 for CIFAR-10/100-C in single domain (TENT, SWR) and continuously changing domain (CoTTA) scenarios.
Revised: We used LR of 1e-3 to test batch size of 200 for CIFAR-10/100-C in single domain (TENT, SWR) and continuously changing domain (CoTTA) scenarios.

Original: To avoid rapid error accumulation, we lowered LR to 1e-4 for TENT and SWR in continual and mixed domain scenarios.
Revised: To avoid rapid error accumulation, we lowered LR to 1e-4 for TENT and SWR in continual and mixed domain scenarios.

Original: Moreover, we updated model parameters after accumulating the gradients forsamples for CIFAR-10/100-C.
Revised: Moreover, we updated model parameters after accumulating the gradients forsamples for CIFAR-10/100-C.

Original: In other words, we compute gradients per batch, but update, i.e., optimizer.step() , after seeing 200 data samples.
Revised: In other words, we compute gradients per batch, but update, i.e., optimizer.step() , after seeing 200 data samples.

Original: Exceptionally, we used LR of 5e-5 for
Revised: Exceptionally, we used LR of 5e-5 for

Original: SWR and SWR+TTN in mixed domain setting.
Revised: SWR and SWR+TTN in mixed domain setting.

Original: Additionally, in continuously changing and mixed domain scenarios, we used the stable version of SWR, which updates the model parameter based on the frozen source parameters instead of previously updated parameters (original SWR).
Revised: Additionally, in continuously changing and mixed domain scenarios, we used the stable version of SWR, which updates the model parameter based on the frozen source parameters instead of previously updated parameters (original SWR).

Original: For semantic segmentation, we set the test batch size as 2 and learning rate for optimization-based methods as 1e-6 for all datasets.
Revised: For semantic segmentation, we set the test batch size as 2 and learning rate for optimization-based methods as 1e-6 for all datasets.

Original: For SWR, we set the importance of the regularization term λ r as 500.
Revised: For SWR, we set the importance of the regularization term λ r as 500.

Original: The other hyperparameters are kept the same as Choi et al.
Revised: The other hyperparameters are kept the same as Choi et al.

Original: (2022) choices.
Revised: (2022) choices.

Original: For all test-time adaptation, we used constant learning rate without scheduling.
Revised: For all test-time adaptation, we used constant learning rate without scheduling.

Original: A. E VALUATION S CENARIO D ETAILS
Revised: A. E VALUATION S CENARIO D ETAILS

Original: Class imbalanced setting.
Revised: Class imbalanced setting.

Original: In the main paper Table 5, we show the results under class imbalanced settings.
Revised: In the main paper Table 5, we show the results under class imbalanced settings.

Original: In the setting, we sorted the test dataset of each corruption in the order of class labels, i.e., from class 0 to 9 for CIFAR-10-C.
Revised: In the setting, we sorted the test dataset of each corruption in the order of class labels, i.e., from class 0 to 9 for CIFAR-10-C.

Original: Then, we comprised test batches following the sorted order.
Revised: Then, we comprised test batches following the sorted order.

Original: Therefore, most batches consist of single class input data, which leads to biased test batch statistics.
Revised: Therefore, most batches consist of single class input data, which leads to biased test batch statistics.

Original: For larger batch size, the statistics are more likely to be extremely skewed, and that explains why error rates are higher with larger batch sizes than with the small ones.
Revised: For larger batch size, the statistics are more likely to be extremely skewed, and that explains why error rates are higher with larger batch sizes than with the small ones.

Original: A. P SEUDOCODE
Revised: A. P SEUDOCODE

Original: Pseudocode for post-training, i.e., obtaining A and optimizing α , is provided in Algorithms 1 and 2, respectively, and that for test time is in Algorithm 3.
Revised: Pseudocode for post-training, i.e., obtaining A and optimizing α , is provided in Algorithms 1 and 2, respectively, and that for test time is in Algorithm 3.

Original: Moreover, we provide PyTorch-friendly pseudocode for obtaining A in Listing 1.
Revised: Moreover, we provide PyTorch-friendly pseudocode for obtaining A in Listing 1.

Original: Please see Section 2 for equations and terminologies used in the algorithms.
Revised: Please see Section 2 for equations and terminologies used in the algorithms.

Original: Algorithm
Revised: Algorithm

Original: # average over data samples for n, p in params.items(): grad_sim[n].data /= len(train_data) 18# min max normalization max_grad =
Revised: # average over data samples for n, p in params.items(): grad_sim[n].data /= len(train_data) 18# min max normalization max_grad =

Original: get_max_value(grad_sim)
Revised: get_max_value(grad_sim)

Original: # scalar min_grad = get_min_value(grad_sim)
Revised: # scalar min_grad = get_min_value(grad_sim)

Original: # scalar grad_dist = {} for n, p in grad_sim.items(): grad_dist[n] =
Revised: # scalar grad_dist = {} for n, p in grad_sim.items(): grad_dist[n] =

Original: (p - min_grad) /
Revised: (p - min_grad) /

Original: (max_grad - min_grad) 25prior
Revised: (max_grad - min_grad) 25prior

Original: = [] j = # integrate gradients of weight(gamma) and bias(beta) for each BN layer for n, p in grad_dist.items(): if "weight" in n: prior.append(p) elif "bias" in n: prior[j] += p prior[j] /=
Revised: = [] j = # integrate gradients of weight(gamma) and bias(beta) for each BN layer for n, p in grad_dist.items(): if "weight" in n: prior.append(p) elif "bias" in n: prior[j] += p prior[j] /=

Original: prior[j] = (1-prior[j])*
Revised: prior[j] = (1-prior[j])*

Original: *  j +=37return prior 39 40 def collect_grad(model, x, y, params): model.zero_grad() out = model(x) loss =
Revised: *  j +=37return prior 39 40 def collect_grad(model, x, y, params): model.zero_grad() out = model(x) loss =

Original: ce_loss(out, y) loss.backward() 45grad
Revised: ce_loss(out, y) loss.backward() 45grad

Original: = {} for n, p in params.items(): grad[n].data = p.data 49return grad
Revised: = {} for n, p in params.items(): grad[n].data = p.data 49return grad

Original: Listing
Revised: Listing

Original: for obtaining prior B A PPENDIX : E XPERIMENTAL R ESULTS B. A BLATION S TUDIES
Revised: for obtaining prior B A PPENDIX : E XPERIMENTAL R ESULTS B. A BLATION S TUDIES

Original: Channel-wise α .
Revised: Channel-wise α .

Original: In Table 8, we compared different granularity levels of interpolating weight α , i.e., channel-wise, layer-wise, and a constant value with CIFAR-10-C and backbone WRN-40.
Revised: In Table 8, we compared different granularity levels of interpolating weight α , i.e., channel-wise, layer-wise, and a constant value with CIFAR-10-C and backbone WRN-40.

Original: We observed that channel-wise optimized α shows the best performance.
Revised: We observed that channel-wise optimized α shows the best performance.

Original: We take average of the channelwisely optimized α (the 1st row) over channels to make a layer-wise α (the 2nd row), and take average over all channels and layers to make a constant value (the 3rd row).
Revised: We take average of the channelwisely optimized α (the 1st row) over channels to make a layer-wise α (the 2nd row), and take average over all channels and layers to make a constant value (the 3rd row).

Original: α of the 1st and 2nd rows are visualized in the main paper Figure 4 colored in blue and red, respectively.
Revised: α of the 1st and 2nd rows are visualized in the main paper Figure 4 colored in blue and red, respectively.

Original: The constant value α (the 3rd row) is 0.3988.
Revised: The constant value α (the 3rd row) is 0.3988.

Original: We also optimized α layer-wisely (the 4th row).
Revised: We also optimized α layer-wisely (the 4th row).

Original: [Table]
Revised: [Table]

Original: MSE loss strength λ .
Revised: MSE loss strength λ .

Original: We empirically set the MSE loss strength λ in Eq.
Revised: We empirically set the MSE loss strength λ in Eq.

Original: 6 as 1 through the ablation study using CIFAR-10-C and WRN-40 (Table 9).
Revised: 6 as 1 through the ablation study using CIFAR-10-C and WRN-40 (Table 9).

Original: Using the MSE regularizer prevents the learnable α from moving too far from the prior, thus letting α follow our intuition, i.e., putting smaller importance on the test batch statistics if the layer or channel is invariant to domain shifts.
Revised: Using the MSE regularizer prevents the learnable α from moving too far from the prior, thus letting α follow our intuition, i.e., putting smaller importance on the test batch statistics if the layer or channel is invariant to domain shifts.

Original: However, with too strong regularization ( λ =10.0), the overall error rates are high, which means the α needs to be sufficiently optimized.
Revised: However, with too strong regularization ( λ =10.0), the overall error rates are high, which means the α needs to be sufficiently optimized.

Original: On the other hand, with too small regularization, the α may overfit to the training batch size (B=200) and lose the generalizability to the smaller batch size.
Revised: On the other hand, with too small regularization, the α may overfit to the training batch size (B=200) and lose the generalizability to the smaller batch size.

Original: [Table]
Revised: [Table]

Original: M ORE COMPARISONS ON CIFAR10-C
Revised: M ORE COMPARISONS ON CIFAR10-C

Original: Constant α .
Revised: Constant α .

Original: Table 10 shows results of simple baseline for normalization-based methods where the α is a constant value ranging from 0 to 1.
Revised: Table 10 shows results of simple baseline for normalization-based methods where the α is a constant value ranging from 0 to 1.

Original: α = 0 is identical to CBN (Ioffe & Szegedy, 2015), and α = 1 is identical to TBN (Nado et al., 2020).
Revised: α = 0 is identical to CBN (Ioffe & Szegedy, 2015), and α = 1 is identical to TBN (Nado et al., 2020).

Original: We observe that the lower α , i.e., using less test batch statistics, shows better performance for small test batch sizes.
Revised: We observe that the lower α , i.e., using less test batch statistics, shows better performance for small test batch sizes.

Original: This observation is analogous to the finding of the previous work (Schneider et al., 2020).
Revised: This observation is analogous to the finding of the previous work (Schneider et al., 2020).

Original: α
Revised: α

Original: [Table]
Revised: [Table]

Original: size
Revised: size

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: B. V ARIANTS OF TTN FOR SMALL TEST BATCH SIZE
Revised: B. V ARIANTS OF TTN FOR SMALL TEST BATCH SIZE

Original: Online TTN.
Revised: Online TTN.

Original: TTN interpolating weight α can also be adapted during test time.
Revised: TTN interpolating weight α can also be adapted during test time.

Original: Table 11 shows the results of the TTN online version, which further optimizes the post-trained alpha using the entropy minimization and mean-squared error (MSE) loss between the updated alpha and the initial posttrained alpha.
Revised: Table 11 shows the results of the TTN online version, which further optimizes the post-trained alpha using the entropy minimization and mean-squared error (MSE) loss between the updated alpha and the initial posttrained alpha.

Original: We followed entropy minimization loss used in TENT (Wang et al., 2020), and the
Revised: We followed entropy minimization loss used in TENT (Wang et al., 2020), and the

Original: MSE loss can be written as L MSE =
Revised: MSE loss can be written as L MSE =

Original: ∥
Revised: ∥

Original: α − α 0 ∥ 2 , where α 0 is the post-trained α .
Revised: α − α 0 ∥ 2 , where α 0 is the post-trained α .

Original: We set the learning rate as 1e-2, 2.5e-3, 5e-4, 1e-4, 5e-5, and 2.5e-5 by linearly decreasing according to the test batch size of 200, 64, 16, 4, 2, and 1 (Goyal et al., 2017).
Revised: We set the learning rate as 1e-2, 2.5e-3, 5e-4, 1e-4, 5e-5, and 2.5e-5 by linearly decreasing according to the test batch size of 200, 64, 16, 4, 2, and 1 (Goyal et al., 2017).

Original: The online TTN shows improvements compared to the offline TTN in all three evaluation scenarios (single, continuously changing, and mixed).
Revised: The online TTN shows improvements compared to the offline TTN in all three evaluation scenarios (single, continuously changing, and mixed).

Original: Scaled TTN.
Revised: Scaled TTN.

Original: Following the observation from Table 10, we lowered the interpolating weight by multiplying a constant scale value, ranging (0 , 1) , to the optimized TTN α .
Revised: Following the observation from Table 10, we lowered the interpolating weight by multiplying a constant scale value, ranging (0 , 1) , to the optimized TTN α .

Original: In Table 11, we empirically set the scale value as 0.4.
Revised: In Table 11, we empirically set the scale value as 0.4.

Original: Dynamic training batch size.
Revised: Dynamic training batch size.

Original: We observe that using the dynamic batch size in the post-training stage also improves the performance for small test batch sizes (2 or 1), while slightly deteriorating the performance for large test batch sizes (200 or 64).
Revised: We observe that using the dynamic batch size in the post-training stage also improves the performance for small test batch sizes (2 or 1), while slightly deteriorating the performance for large test batch sizes (200 or 64).

Original: We randomly sampled training batch size from the range of [4 , 200] for each iteration.
Revised: We randomly sampled training batch size from the range of [4 , 200] for each iteration.

Original: Other hyperparameters are kept as the same.
Revised: Other hyperparameters are kept as the same.

Original: [Table]
Revised: [Table]

Original: S TUDY ON AUGMENTATION TYPE
Revised: S TUDY ON AUGMENTATION TYPE

Original: TTN is robust to the data augmentation.
Revised: TTN is robust to the data augmentation.

Original: We used data augmentation in the post-training phase to simulate domain shifts.
Revised: We used data augmentation in the post-training phase to simulate domain shifts.

Original: The rationale for the simulation is to expose the model to different input domains.
Revised: The rationale for the simulation is to expose the model to different input domains.

Original: Especially when obtaining the prior, we compare the outputs from shifted domains with the clean (original) domain in order to analyze which part of the model is affected by the domain discrepancy.
Revised: Especially when obtaining the prior, we compare the outputs from shifted domains with the clean (original) domain in order to analyze which part of the model is affected by the domain discrepancy.

Original: Therefore, changing the domain itself is what matters, not which domain the input is shifted to.
Revised: Therefore, changing the domain itself is what matters, not which domain the input is shifted to.

Original: We demonstrated this by conducting ablation studies by varying the augmentation type.
Revised: We demonstrated this by conducting ablation studies by varying the augmentation type.

Original: We analyzed various augmentation types when obtaining prior and when optimizing alpha and the results are shown in Figure 5 (a) and (b), respectively.
Revised: We analyzed various augmentation types when obtaining prior and when optimizing alpha and the results are shown in Figure 5 (a) and (b), respectively.

Original: We use a true corruption, i.e., one ofcorruption types in the corruption benchmark, as an augmentation type in the post-training phase to analyze how TTN works if the augmentation type and test corruption type are misaligned or perfectly aligned.
Revised: We use a true corruption, i.e., one ofcorruption types in the corruption benchmark, as an augmentation type in the post-training phase to analyze how TTN works if the augmentation type and test corruption type are misaligned or perfectly aligned.

Original: Specifically, we used the true corruption when obtaining the prior while keeping the augmentation choices when optimizing alpha as described in the appendix A.1, and vice versa.
Revised: Specifically, we used the true corruption when obtaining the prior while keeping the augmentation choices when optimizing alpha as described in the appendix A.1, and vice versa.

Original: Expectedly, the diagonal elements, i.e., where the same corruption type is used both for in posttraining and in test time, tend to show the lowest error rate in Figure 5(b).
Revised: Expectedly, the diagonal elements, i.e., where the same corruption type is used both for in posttraining and in test time, tend to show the lowest error rate in Figure 5(b).

Original: The row-wise standard deviation is lower than 1 in most cases and even lower than 0.5 in Figure 5(a), which means the prior is invariant to the augmentation choice.
Revised: The row-wise standard deviation is lower than 1 in most cases and even lower than 0.5 in Figure 5(a), which means the prior is invariant to the augmentation choice.

Original: Moreover, we observe that the average error rate over all elements, 11.74% in ablation for obtaining prior and 11.67% in ablation for optimizing alpha, is almost as same as TTN result 11.67% (See Table 14 and Figure 5).
Revised: Moreover, we observe that the average error rate over all elements, 11.74% in ablation for obtaining prior and 11.67% in ablation for optimizing alpha, is almost as same as TTN result 11.67% (See Table 14 and Figure 5).

Original: Moreover, we conducted an ablation study on the choice of the augmentation type using CIFAR-10-C and WRN-40 (Table12).
Revised: Moreover, we conducted an ablation study on the choice of the augmentation type using CIFAR-10-C and WRN-40 (Table12).

Original: We observe that obtaining prior and optimizing alpha steps are robust to the augmentation types.
Revised: We observe that obtaining prior and optimizing alpha steps are robust to the augmentation types.

Original: [Table]
Revised: [Table]

Original: B. R ESULTS ON I MAGE N ET -C
Revised: B. R ESULTS ON I MAGE N ET -C

Original: Table 13 shows the experimental results using ResNet-50 (He et al., 2016) on ImageNetC (Hendrycks & Dietterich, 2018) dataset.
Revised: Table 13 shows the experimental results using ResNet-50 (He et al., 2016) on ImageNetC (Hendrycks & Dietterich, 2018) dataset.

Original: We emphasized the effectiveness of our proposed method by showing the significant improvement in large-scale dataset experiment.
Revised: We emphasized the effectiveness of our proposed method by showing the significant improvement in large-scale dataset experiment.

Original: Similar to the results in
Revised: Similar to the results in

Original: CIFAR-10/100-C, TTN showed the best performance compared to normalization-based methods (TBN (Nado et al., 2020), AdaptiveBN Schneider et al.
Revised: CIFAR-10/100-C, TTN showed the best performance compared to normalization-based methods (TBN (Nado et al., 2020), AdaptiveBN Schneider et al.

Original: (2020), and α -BN (You et al., 2021))
Revised: (2020), and α -BN (You et al., 2021))

Original: and improved TTA performance when it is applied to optimization-based methods (TENT (Wang et al., 2020) and SWR (Choi et al., 2022)).
Revised: and improved TTA performance when it is applied to optimization-based methods (TENT (Wang et al., 2020) and SWR (Choi et al., 2022)).

Original: During post-training, we used LR of 2.5e-4 and batch size of 64.
Revised: During post-training, we used LR of 2.5e-4 and batch size of 64.

Original: In test time, we used the learning rate of 2.5e-4 for TENT following the setting from the original paper, and used 5e-6 for TENT+TTN.
Revised: In test time, we used the learning rate of 2.5e-4 for TENT following the setting from the original paper, and used 5e-6 for TENT+TTN.

Original: For SWR and SWR+TTN, we used learning rate of 2.5e-4 for B=64, and 2.5e-6 for B=16, 4, 2, and 1.
Revised: For SWR and SWR+TTN, we used learning rate of 2.5e-4 for B=64, and 2.5e-6 for B=16, 4, 2, and 1.

Original: We had to carefully tune the learning rate especially for SWR, since the method updates the entire model parameters in an unsupervised manner and hence is very sensitive to the learning rate when the test batch size becomes small.
Revised: We had to carefully tune the learning rate especially for SWR, since the method updates the entire model parameters in an unsupervised manner and hence is very sensitive to the learning rate when the test batch size becomes small.

Original: Other hyperparameters and details are kept same (See the appendix A.1 for more details).
Revised: Other hyperparameters and details are kept same (See the appendix A.1 for more details).

Original: Moreover, to avoid rapid accumulation, we stored gradients for sufficiently large test samples and then updated the model parameters (for example, we conducted adaptation in every 64 iterations in the case of batch size of 1) in both TENT and SWR.
Revised: Moreover, to avoid rapid accumulation, we stored gradients for sufficiently large test samples and then updated the model parameters (for example, we conducted adaptation in every 64 iterations in the case of batch size of 1) in both TENT and SWR.

Original: [Table]
Revised: [Table]

Original: B. E RROR R ATES OF E ACH C ORRUPTION
Revised: B. E RROR R ATES OF E ACH C ORRUPTION

Original: In Table
Revised: In Table

Original: [Table]
Revised: [Table]

Original: we show the error rates of TTN for each corruption of CIFAR-10-C using the WRNbackbone.
Revised: we show the error rates of TTN for each corruption of CIFAR-10-C using the WRNbackbone.

Original: The averaged results over the corruptions are in Table 1.
Revised: The averaged results over the corruptions are in Table 1.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: B. S EGMENTATION R ESULTS
Revised: B. S EGMENTATION R ESULTS

Original: For more comparisons, we add segmentation results for TBN and TTN using test batch size (B) of 4 and 8 (Table 15).
Revised: For more comparisons, we add segmentation results for TBN and TTN using test batch size (B) of 4 and 8 (Table 15).

Original: The results demonstrate that TTN is robust to the test batch sizes.
Revised: The results demonstrate that TTN is robust to the test batch sizes.

Original: In other words, the performance difference across the test batch size is small when using TTN (TTN with
Revised: In other words, the performance difference across the test batch size is small when using TTN (TTN with

Original: B=2, 4, and 8).
Revised: B=2, 4, and 8).

Original: The results are averaged over 3 runs (i.e., using 3 independently optimized α ), and the standard deviation is denoted with a ± sign.
Revised: The results are averaged over 3 runs (i.e., using 3 independently optimized α ), and the standard deviation is denoted with a ± sign.

Original: We omitted the standard deviation for TBN, which is 0.0 for every result since no optimization is required.
Revised: We omitted the standard deviation for TBN, which is 0.0 for every result since no optimization is required.

Original: Since the backbone network is trained with a train batch size of 8, we assume that test batch statistics estimated from the test batch with B= are sufficiently reliable.
Revised: Since the backbone network is trained with a train batch size of 8, we assume that test batch statistics estimated from the test batch with B= are sufficiently reliable.

Original: Accordingly, TBN with B=8 shows compatible results.
Revised: Accordingly, TBN with B=8 shows compatible results.

Original: However, when B becomes small (i
Revised: However, when B becomes small (i

Original: [Table]
Revised: [Table]

Original: e., in a more practical scenario), problematic test batch statistics are estimated
Revised: e., in a more practical scenario), problematic test batch statistics are estimated

Original: [Table]
Revised: [Table]

Original: and thus TBN suffers from the performance drop while TTN keeps showing robust performance.
Revised: and thus TBN suffers from the performance drop while TTN keeps showing robust performance.

Original: It is worth noting that TTN outperforms TBN by 3.77% in average accuracy when B=2,
Revised: It is worth noting that TTN outperforms TBN by 3.77% in average accuracy when B=2,

Original: i
Revised: i

Original: [Table]
Revised: [Table]

Original: e., in the most practical evaluation setting, and by 2.54% and 1.99% for B=4 and 8, respectively.
Revised: e., in the most practical evaluation setting, and by 2.54% and 1.99% for B=4 and 8, respectively.

Original: [Table]
Revised: [Table]

Original: T e s t
Revised: T e s t

Original: c o rr up t i o n t
Revised: c o rr up t i o n t

Original: y p e obtaining prior
Revised: y p e obtaining prior

Original: T e s t
Revised: T e s t

Original: c o rr up t i o n t
Revised: c o rr up t i o n t

Original: y p
Revised: y p

Original: e
Revised: e

Original: Error rate
Revised: Error rate

Original: Colored by value (across test corruption type) avg.
Revised: Colored by value (across test corruption type) avg.

Original: std.
Revised: std.