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: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

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 mƒodified 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 assumptions.
Revised: stream, and we observed that the previous methods with TBN show critical performance drop without 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 evaluation settings assume large test batch sizes ( e.g., 200 or more) and a single stationary distribution shift ( i.e., single corruption).
Revised: For instance, such evaluation settings assume large test batch sizes ( e.g., 200 or more) and a single stationary distribution shift ( 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
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

Original: [Figure]
Revised: [Figure]

Original: distribution during test time (Wang et al., 2022).
Revised: 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 sensitivity to domain shift in order to flexibly adapt to new target domains while preserving the well-trained source knowledge.
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: • 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
Revised: • 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

Original: [Figure]
Revised: [Figure]

Original: Affine
Revised: Affine

Original: [Figure]
Revised: [Figure]

Original: S Ƹ𝑧
Revised: S Ƹ𝑧

Original: T 𝑧 𝑜𝑢𝑡
Revised: T 𝑧 𝑜𝑢𝑡

Original: [Figure]
Revised: [Figure]

Original: 𝑧 𝑖𝑛
Revised: 𝑧 𝑖𝑛

Original: S Ƹ𝑧
Revised: S Ƹ𝑧

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

Original: [Figure]
Revised: [Figure]

Original: S
Revised: S

Original: [Figure]
Revised: [Figure]

Original: T
Revised: T

Original: [Figure]
Revised: [Figure]

Original: 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: 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
Revised: • We evaluate our method through extensive experiments on image classification using

Original: CIFAR-10/100-C, and ImageNet-C (Hendrycks & Dietterich, 2018) and semantic segmentation task using 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).
Revised: CIFAR-10/100-C, and ImageNet-C (Hendrycks & Dietterich, 2018) and semantic segmentation task using 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).

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, (2) multi,
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, (2) multi,

Original: N -target domains, D T
Revised: N -target domains, D T

Original: = {D T,i } Ni =1 .
Revised: = {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 cyclically repeating 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 cyclically repeating target domains.

Original: 2. T EST -T IME N ORMALIZATION L AYER
Revised: 2. T EST -T IME N ORMALIZATION L 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]

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.
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.

Original: Based on µ and σ 2 , the source statistics µ s , σ 2 s ∈ R C are usually estimated with exponential moving average over the training data.
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]
Revised: [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [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: 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 use current input batch statistics during training and use estimated source statistics µ s and σ 2 s at test time (Fig. 2(b)).
Revised: The standardization use current input batch statistics during training and use estimated source statistics µ s and σ 2 s at test time (Fig. 2(b)).

Original: To address a domain shift in a test time, we adjust the source statistics by combining source and test mini-batch statistics (Singh & Shrivastava, 2019; Summers & Dinneen, 2019) with a learnable interpolating weight α ∈ R C ranges [0 , 1] .
Revised: To address a domain shift in a test time, we adjust the source statistics by combining source and 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 same affine parameters, γ and β .
Revised: while using same affine parameters, γ and β .

Original: Note that we have different mixing ratio α c for every layer and channel.
Revised: Note that we have different mixing ratio α 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, post-training (after pre-training but before testing), to optimize the mixing parameters α in Eq.
Revised: (2022), we introduce an additional training phase, post-training (after pre-training 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 post-training.
Revised: Note that all parameters except α are frozen and we have access to the labeled source data during the post-training.

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

Original: Then, we optimize α with prior knowledge and an additional objective term.
Revised: Then, we optimize α with 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 pseudo code is provided in appendix A.3.
Revised: 3 and the pseudo code 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 shift, we simulate the domain shift by augmenting 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 shift, we simulate the domain shift by augmenting 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: While 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 simulated domain shift.
Revised: While 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 simulated domain shift.

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]
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 arbitrary target domain.
Revised: The goal of optimizing α is to make the combined statistics correctly standardize the features when the input is sampled from arbitrary target domain.

Original: After obtaining the prior A , we replace CBN with TTN layers while keeping the affine parameters.
Revised: After obtaining the prior 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 adopted 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 adopted using test batch statistics (see Fig. 3(b-1)).

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

Original: Expecting the model to make consistent prediction either given clean or augmented inputs, we use cross-entropy loss L CE .
Revised: Expecting the model to make consistent prediction 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 and Table 9).
Revised: L CE + λ L MSE (6) , where λ is a weighting hyperparameter (Details are provided in the appendix A.1 and Table 9).

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: In image classification, we evaluate TTN for corruption robustness in realistic evaluation settings, i.e., where 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 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 shift ( 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 shift ( 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 augmented source data in the post-training phase.
Revised: Given models pre-trained on clean source data, we optimize TTN parameter α with augmented source data in the post-training phase.

Original: Afterward, we evaluate our post-trained model on corrupted target data.
Revised: Afterward, we evaluate our post-trained model on 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 clean datasets, i.e., CIFAR-10/100 and ImageNet.
Revised: Each corruption is applied to test images of clean datasets, i.e., CIFAR-10/100 and ImageNet.

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

Original: As backbone models, we used WideResNet-40-2 (Hendrycks et al., 2019) trained on CIFAR-10/100, and ResNet-50 (He et al., 2016) trained on ImageNet.
Revised: As backbone models, we used WideResNet-40-2 (Hendrycks et al., 2019) trained on 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),
Revised: To validate our method in semantic segmentation, we conduct experiments on Cityscapes (Cordts et al., 2016), BDD-100K (Yu et al., 2020),

Original: 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: 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) MixNorm (Hu et al., 2021), which combines or takes the moving average of source and test batch statistics with a pre-defined hyperparameter ( i.e., a constant α ).
Revised: (You et al., 2021) and (3) MixNorm (Hu et al., 2021), which combines or takes the moving average of source and 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 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 affine parameters via entropy minimization.

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

Original: (6) CoTTA (Wang et al., 2022) ensembles the output of
Revised: (6) CoTTA (Wang et al., 2022) ensembles the output of

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

Original: augmented test inputs, updates the entire model parameter using a consistency loss between student and teacher models, and stochastically restores the pre-trained model.
Revised: augmented test inputs, updates the entire model parameter 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: Note that the α is shared across the settings.
Revised: Note that the α is shared across the settings.

Original: We conduct experiments in three evaluation scenarios; single , continuously changing , and mixed domain adaptation.
Revised: We conduct experiments in three evaluation scenarios; single , continuously changing , and mixed domain adaptation.

Original: In 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 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 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 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 a mixed domain adaptation setting, where a single batch containing multiple domains.
Revised: Finally, to simulate the non-stationary target domain where various domains coexist, we evaluate methods in a mixed domain adaptation setting, where a single batch containing multiple domains.

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

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 continuously changing (Table 2) settings are identical.
Revised: Note that the performance of normalization-based methods in the single (Table 1) and 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: See the supplementary material for more results, including results of ImageNet-C and analysis.
Revised: See the supplementary material for more results, including results of ImageNet-C and analysis.

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

Original: In Table 1, 2, 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 α , shows better results than defining α as a constant hyperparameter, which can be considered as a special case
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 case

Original: [Table]
Revised: [Table]

Original: of TTN
Revised: of TTN

Original: ; α = 1 is equal to TBN, and α = 0 .
Revised: ; α = 1 is equal to TBN, and α = 0 .

Original: 1 corresponds to α -BN.
Revised: 1 corresponds to α -BN.

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: Error rate ( ↓ ) on test split of CIFAR-10 using
Revised: Error rate ( ↓ ) on test split of CIFAR-10 using

Original: WideResNet-40-2.
Revised: WideResNet-40-2.

Original: [Table]
Revised: [Table]

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 use TBN layers as default, they also suffer from performance drops when the test batch size becomes small.
Revised: Since TENT, SWR, and CoTTA use TBN layers as default, 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 a 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 a 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 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 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 overall 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 overall compared to the TBN-based methods.

Original: With a batch size of 200, we can observe that combining the source with a current test batch can improve the performance of the source model (see 3rd row of Table 4).
Revised: With a batch size of 200, we can observe that combining the source with a current test batch can improve the performance of 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 5, we can observe that TTN is more robust to class imbalanced scenario than utilizing only test batch statistics ( i.e., TBN).
Revised: In Table 5, we can observe that TTN is more robust to class imbalanced scenario than utilizing only test batch statistics ( i.e., TBN).

Original: As explained in Section 3.5,
Revised: As explained in Section 3.5,

Original: [Table]
Revised: [Table]

Original: we are putting more importance on CBN than TBN
Revised: we are putting more importance on CBN than TBN

Original: [Table]
Revised: [Table]

Original: where semantic information is mainly handled,
Revised: where semantic information is mainly handled,

Original: i
Revised: i

Original: [Table]
Revised: [Table]

Original: e., in deeper layers
Revised: e., in deeper layers

Original: [Table]
Revised: [Table]

Original: so we can understand that TTN is less impacted by skewed label distribution.
Revised: 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 our proposed method.
Revised: Cityscapes → BDD-100K), to demonstrate the broad applicability of our proposed method.

Original: Tableshows 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,
Revised: Tableshows 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,

Original: BDD-100K
Revised: BDD-100K

Original: [Table]
Revised: [Table]

Original: and Mapillary, and synthetic datasets including GTAV and SYNTHIA, respectively.
Revised: and Mapillary, and synthetic datasets including GTAV and SYNTHIA, respectively.

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: More details are provided in appendix A.1.
Revised: More details are provided in appendix A.1.

Original: We observe that even when exploiting test batch statistics for standardization in BN layers (TBN) or updating the model parameter 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 test batch statistics.
Revised: We observe that even when exploiting test batch statistics for standardization in BN layers (TBN) or updating the model parameter 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 test batch statistics.

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 conducted an ablation study on the importance of each proposed component,
Revised: We conducted an ablation study on the importance of each proposed component,

Original: i
Revised: i

Original: [Table]
Revised: [Table]

Original: e., initializing α with prior A , optimizing α using CE and MSE loss, and the results are shown in Table 7.
Revised: e., initializing α with prior A , optimizing α using CE and MSE loss, and the results are shown in Table 7.

Original: Initialization and MSE loss using A both aim to optimize α following our intuition that we discussed in Section 2.3.
Revised: Initialization and MSE loss using A both aim 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 (see rows 2 & 3).
Revised: Optimizing α using CE loss improves the overall performance, but without regularizing with MSE loss, α may overfit to large batch size (see rows 2 & 3).

Original: Initialization with A or not does not show a significant difference
Revised: Initialization with A or not does not show a significant difference

Original: [Table]
Revised: [Table]

Original: but we can see that A provides a better starting point than random initialization when comparing the left and right of the 2nd row.
Revised: but we can see that 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, with or without A , the optimized α sufficiently reflects our intuition resulting in a low error rate to overall batch sizes (see row 3).
Revised: We observe that when using MSE loss, with or without A , the optimized α sufficiently reflects our intuition resulting in a low error rate to overall batch sizes (see 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 with backbone WRN-40.
Revised: 4 shows the visualization of optimized α for CIFAR-10 with backbone WRN-40.

Original: 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.
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.e., α closer to 0) in deeper layers because domain information causing distribution shift is diminished, whereas TBN has a larger weight ( i.e., α closer to 1) in shallower layers since the domain information induces large distribution shift.
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 distribution shift is diminished, whereas TBN has a larger weight ( i.e., α closer to 1) in shallower layers since the domain information induces 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 (or domain) 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 (or domain) information mainly exists in shallower layers, whereas only content information remains in deeper layers.

Original: [Figure]
Revised: [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 shift (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 shift (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 SFDA,
Revised: Unlike UDA and SFDA,

Original: TTA utilizes test data in an online manner.
Revised: 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) also mix the statistics using predefined hyperparameter.
Revised: (2021) also mix 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) adapt the statistics using moving average while augmenting the input to form a pseudo test batch when only a single instance is given.
Revised: (2021) adapt 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) also proposed to adjust the standardization statistics using a learnable calibration strength and showed its effectiveness focusing on the semantic segmentation task.
Revised: (2022) also 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) update model parameters while using TBN.
Revised: TENT (Wang et al., 2020), SWR (Choi et al., 2022), and CoTTA (Wang et al., 2022) update model parameters while using TBN.

Original: TENT optimized affine parameters in BN layers using entropy minimization while freezing the others.
Revised: TENT optimized affine parameters in BN layers using entropy minimization while freezing the others.

Original: To maximize the adaptability, SWR updated the entire model parameters minimizing the entropy loss based on the domain-shift sensitivity.
Revised: To maximize the adaptability, 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 restore random part 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 restore random part 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 uses 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 uses 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, although the mixing ratio is optimized before model deployment.
Revised: However, our proposed method employs a fixed mixing ratio during test time, although the mixing ratio is optimized before model deployment.

Original: If we adjust the mixing ratio according to the distribution shift during test time, we can expect a further performance improvement.
Revised: If we adjust the mixing ratio according to the distribution shift during test time, we can expect a 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 Appendix A. and A.2, respectively.
Revised: Moreover, the details on implementation and evaluation settings can be found in Appendix A. and A.2, respectively.

Original: The pseudo code for overall training and testing scheme is provided in Appendix A.3.
Revised: The pseudo code for overall training and testing scheme is provided in 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 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-

Revised: For CIFAR-10/100-C, we optimized α using augmented CIFAR-10/ training set on the pre-trained WideResNet-40-

Original: (Hendrycks et al., 2019).
Revised: (Hendrycks et al., 2019).

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

Original: ResNet-50.
Revised: 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 to MSE
Revised: We used the weighting hyperparmeter to 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 continual and mixed domain scenarios.
Revised: To avoid rapid error accumulation, we lowered LR to 1e-4 for continual and mixed domain scenarios.

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

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 SWR and SWR+TTN in mixed domain setting.
Revised: Exceptionally, we used LR of 5e-5 for 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 adaptaion, we used constant learning rate without scheduling.
Revised: For all test-time adaptaion, 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 In the main paper Table 5, we show the results under class imbalanced settings.
Revised: Class imbalanced setting 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.
Revised: A.

Original: P SEUDO C ODE
Revised: P SEUDO C ODE

Original: Pseudo code 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: Pseudo code 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 pseudo code for obtaining A in Listing 1.
Revised: Moreover, we provide PyTorch-friendly pseudo code 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: 1: Require
Revised: 1: Require

Original: Pre
Revised: Pre

Original: S
Revised: S

Original: 2: Output : Prior
Revised: 2: Output : Prior

Original: 3: for
Revised: 3: for

Original: S do 4:
Revised: S do 4:

Original: Augment x : x
Revised: Augment x : x

Original: Collect gradients from f using clean x and augmented x
Revised: Collect gradients from f using clean x and augmented x

Original: 6: end for 7: Compute gradient distance score d using Eq
Revised: 6: end for 7: Compute gradient distance score d using Eq

Original: 8: Define prior A using Eq end
Revised: 8: Define prior A using Eq end

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 1: PyTorch-friendly pseudo code for obtaining prior
Revised: Listing 1: PyTorch-friendly pseudo code for obtaining prior

Original: B A PPENDIX : E XPERIMENTAL R ESULTS
Revised: B A PPENDIX : E XPERIMENTAL R ESULTS

Original: This section provides additional experimental results supplementing the Section 3.2 and 3.4.
Revised: This section provides additional experimental results supplementing the Section 3.2 and 3.4.

Original: B. A BLATION S TUDIES
Revised: 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-2.
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-2.

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 channel-wisely 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 channel-wisely 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 Table 4 colored in blue and red, respectively.
Revised: α of the 1st and 2nd rows are visualized in the main paper Table 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: 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 (Table 9).
Revised: 6 as 1 through the ablation study (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] [Table]
Revised: [Table] [Table]

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

Original: Constant α .
Revised: Constant α .

Original: We added baselines for normalization-based methods where the α is a constant value ranging from 0 to 1.
Revised: We added baselines for normalization-based methods where the α is a constant value ranging from 0 to 1.

Original: α = 0 is identical to CBN (Ioffe & Szegedy, 2015)
Revised: α = 0 is identical to CBN (Ioffe & Szegedy, 2015)

Original: [Table]
Revised: [Table]

Original: and α = 1 is identical to
Revised: and α = 1 is identical to

Original: TBN (Nado et al., 2020).
Revised: 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: [Table]
Revised: [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 showed improvements compared to the original offline TTN in all three evaluation scenarios (single, continuously changing, and mixed).
Revised: The online TTN showed improvements compared to the original 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 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 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 same.
Revised: Other hyperparameters are kept same.

Original: [Table]
Revised: [Table]

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

Original: TTN is robust and invariant to the choice of the augmentation type.
Revised: TTN is robust and invariant to the choice of 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 of 15 corruption 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 of 15 corruption 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 descripted in 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 descripted in Appendix A.1, and vice versa.

Original: Expectedly, the diagonal elements, i.e., where the same corruption type is used both for in post-training 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 post-training 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
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

Original: Table 14 and Figure 5).Moreover
Revised: Table 14 and Figure 5).Moreover

Original: [Table]
Revised: [Table]

Original: we conducted ablation study on the choice of the augmentation type.
Revised: we conducted ablation study on the choice of the augmentation type.

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

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
Revised: Other hyperparameters and details are kept same (See

Original: Appendix A.1 for more details).
Revised: 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 per each corruption of CIFAR-10-C using the
Revised: we show the error rates of TTN per each corruption of CIFAR-10-C using the

Original: WideResNet-40-2 backbone.
Revised: WideResNet-40-2 backbone.

Original: The averaged results over the corruptions are in the main manuscript,
Revised: The averaged results over the corruptions are in the main manuscript,

Original: Table
Revised: Table

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
Revised: y p

Original: e
Revised: e

Original: Error rate .
Revised: Error rate .

Original: Colored value (across type) avg.
Revised: Colored value (across type) avg.

Original: std.
Revised: std.

Original: (a
Revised: (a

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 normalized value (across test corruption type) avg.
Revised: Colored by normalized value (across test corruption type) avg.

Original: std.
Revised: std.