Learning Debiased and Disentangled Representations for Semantic Segmentation
Year: 2022

Abstract:
Deep neural networks are susceptible to learn biased models with entangled feature representations, which may lead to subpar performances on various downstream tasks. This is particularly true for under-represented classes, where a lack of diversity in the data exacerbates the tendency. This limitation has been addressed mostly in classification tasks, but there is little study on additional challenges that may appear in more complex dense prediction problems including semantic segmentation. To this end, we propose a model-agnostic and stochastic training scheme for semantic segmentation, which facilitates the learning of debiased and disentangled representations. For each class, we first extract class-specific information from the highly entangled feature map. Then, information related to a randomly sampled class is suppressed by a feature selection process in the feature space. By randomly eliminating certain class information in each training iteration, we effectively reduce feature dependencies among classes, and the model is able to learn more debiased and disentangled feature representations. Models trained with our approach demonstrate strong results on multiple semantic segmentation benchmarks, with especially notable performance gains on under-represented classes.

heading: 1 Introduction
text: Semantic segmentation is a pixelwise classification task that is applicable to a wide range of practical problems including autonomous driving, medical image diagnosis, scene understanding, and many others. Ever since deep neural networks have been adopted for semantic segmentation [1–5], its accuracy has increased gradually with the introduction of stronger network architectures, improved training schemes, and large-scale datasets.
Despite such phenomenal achievement, semantic segmentation approaches still suffer from the chronic limitations caused by class imbalance and stereotyped scene context in datasets. The class imbalance issues are prevalent in semantic segmentation, where certain classes occupy larger area and/or appear more frequently than others. For example, the “road” class in the Cityscapes dataset [6] accounts for over 36% of pixels of all training images while the “motorcycle” class does only 0.1% of pixels. Furthermore, the scene context is not sufficiently diversified in training datasets. For instance, the objects in the “motorcycle” class is always observed in the vicinity of the “road” class, and the spatial layout of the two classes are almost identical in all images. Consequently, the models often learn substantially correlated representations and fail to accurately delineate the boundaries in the absence of frequently co-located objects.
These issues cause the model to learn suboptimal feature representations, especially for classes that are under-represented. These feature representations are often entangled with one another, causing confusion between classes, and are also susceptible to encode adverse biases as well, which may be detrimental to the model’s overall performance. On the other hand, for classes with abundant labels, the model is able to leverage the large variations in the data and learn more robust feature
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
representations that are less dependent on the presence of other classes. As such, the model exhibits strong performance on classes with sufficient labels but weaker performances on rare classes.
We propose DropClass, a simple yet effective training scheme for semantic segmentation that aims to alleviate the vulnerability of dataset bias and feature entanglement. Given an input example, we first extract a class-specific feature map for each class using Grad-CAM [7]. Then, we drop the feature map corresponding to a randomly sampled class and aggregate the remaining feature maps to generate the predictions. Finally, we employ our proposed loss functions to facilitate training. This procedure is somewhat similar to Dropout [8], but is specifically designed with a different goal in mind; while Dropout aims to reduce co-adaptations among features, DropClass aims to disentangle the class representations and reduce the underlying biases that arise from inter-class relationships. Our training scheme requires no additional data or annotations. More importantly, since DropClass is model agnostic, it can be plugged into any existing network architecture straightforwardly.
Our contributions can be summarized as follows:
• Our work takes the first step to tackling dataset biases in the semantic segmentation task. We describe how dataset biases in semantic segmentation are different from those in classification, and devise a benchmark to better analyze the biases found in segmentation models.
• We propose DropClass, a model-agnostic training scheme that results in learning more debiased and disentangled feature representations for semantic segmentation.
• Our experimental results show that the model trained with DropClass exhibits stronger performance compared to the baseline across multiple network architectures and datasets. Furthermore, we observe significant performance gains especially on under-represented classes, and provide analysis that further validate the effectiveness of our training scheme.

heading: 2 Proposed Method
text: We first define the semantic segmentation task and its relevant notations. For a dataset with a set of classes, C, we sample an input image x ∈ Rh×w×3 and its corresponding label y ∈ Rh×w×|C|. The feature extractor g(·) takes x as input and produces an intermediate feature representation A ∈ Rh1×w1×k, where k denotes an arbitrary channel size of the feature map that depends on the choice of network architecture. The feature map A is then fed into the classifier, h(·), to produce ŷ ∈ Rh×w×|C|, which serves as the final output of the model before the softmax operation, i.e., the logits. Altogether, we denote the entire model as a composition of the feature extractor and classifier: ŷ = h(A) = h(g(x)). Note that throughout the paper, we use subscripts to refer to specific spatial and channel locations on tensors.

heading: 2.1 Motivation
text: Dataset bias issues are introduced in a plethora of literature dealing with classification problems [9– 13], where the primary concerns are class imbalance in the dataset and spurious correlation between attributes in images. Although the dense prediction tasks including semantic segmentation may suffer from additional challenges related to dataset bias, their potential limitations have still been hardly discussed. Hence, this work first points out a critical drawback exposed to semantic segmentation algorithms caused by the stereotyped co-occurrence of multiple classes as well as the issues inherent from the classification tasks.
We argue that, besides the class imbalance and attribute correlation issues, inter-class relationships with spatial co-occurrence or feature similarity could be the culprit of dataset biases in semantic segmentation models. Consider the class relationship between the “car” and “road” classes in road scenes segmentation. The two classes have a strong spatial correlation since the vast majority of “car” samples will be spatially located above the “road” class. Models can easily exploit this spatial correlation in the process of maximizing the pixel-level accuracy. However, this could have adverse effects when the model encounters an image where “cars” do not appear above the “road” class. Moreover, the representations of a class are often entangled with one another since the features of co-occurring classes in an image are mixed in the convolution layers, and this tendency is aggravated with the semantic similarity between classes, e.g., “bicycle↔ motorcycle” and “person↔ rider”. In both cases, under-represented, rare classes typically become the victims of the feature entanglement.
In this sense, dataset bias and feature entanglement are not mutually exclusive, but dataset bias is manifested as feature entanglement in segmentation tasks.
The fundamental goal of our work is to develop a training scheme that allows the model to learn debiased and disentangled representations for each class, such that the model can make robust predictions for the under-represented classes without depending on the feature representations of other classes. In essence, this is achieved by removing the class-specific features of a random class at each iteration and providing a proper loss as described in Section 2.3. Our training process not only breaks up inter-class relationships through a stochastic training scheme, but also exposes the classifier to a diverse set of class-specific feature combinations given the same input.

heading: 2.2 DropClass for Debiasing and Disentangling
text: The feature representations of multiple classes should not be entangled with one another in order to facilitate less confusion and stronger discriminability. To achieve this, we remove the feature dependencies among classes by selectively discarding the information related to a randomly chosen class at each training iteration.
The difficulty is that neural networks are black-box in nature and produce highly entangled feature representations. To alleviate this issue, we leverage Grad-CAM [7], a well-known gradient-based method of highlighting important class-specific information from entangled feature representations. Grad-CAM uses the backpropagated gradients to produce a coarse localization map that highlights important regions in the image with respect to a certain label, and is widely used to visualize classdiscriminative features in deep neural networks. In similar fashion, we employ the gradients of feature Ai,j,k with respect to the class logit ŷc as the degree of importance that Ai,j,k has on the prediction for class c. Since semantic segmentation is a pixel-level classification task, we average the gradients ofAi,j,k with respect to every pixel location that corresponds to class c. This is used as the importance score of Ai,j,k for class c, and is denoted by Sci,j,k:
Sci,j,k = 1
h× w h∑ u=1 w∑ v=1 ∂ŷu,v,c ∂Ai,j,k . (1)
The importance score for a certain class can be calculated for all locations (i, j, k) of the feature map A to obtain an importance score map Sc, with the same dimensions. Then, we perform element-wise multiplication of the feature and importance score maps to obtain class-specific feature representations, Ac, which is given by Ac = ReLU(A Sc), (2) where denotes the Hadamard product. The ReLU activation is used to preserve all features of A that have a positive influence on ŷc and filter out all negative ones.
With the highlighted feature representation Ac, ∀c ∈ C, we are now able to discard information related to a certain class from the output of the feature extractor. In every iteration of the training
process, a class z is randomly sampled as
z ∼ U(1, |C|), (3) where U(1, |C|) denotes a discrete uniform distribution across elements of C. Through the stochastic drop of the class z, we deactivate Az and obtain a different combination of feature representations at each iteration, which is given by
A′drop = 1
|C| |C|∑ c=1 1[c 6= z] ·Ac, (4)
where 1[·] represents an indicator function. After passing A′drop through a convolutional layer to compensate missing information, we obtain a new feature representation Adrop = conv(A′drop) that contains information for all classes except class z. This feature is passed through the classifier to generate a new logit, ŷdrop. Since Adrop may still contain the information about the dropped class z, our approach attempts to suppress the information regarding class z in the other class-specific feature maps as well, using the objective function as defined in Section 2.3. Overall, our DropClass procedure is illustrated in Figure 1.

heading: 2.3 Objective Function
text: We train the model with multiple loss functions, each with a specific goal in mind. We first evaluate the cross-entropy loss:
LCE = − 1
h× w h∑ u=1 w∑ v=1 |C|∑ c=1 yu,v,c · log(p̂u,v,c), (5)
where p̂ = softmax(ŷ) applied over the channel dimension. To account for the dropped class z, we design a modified cross-entropy loss that masks the pixel-wise loss at all locations, where class z is the ground-truth:
LCE_drop = − 1
h× w h∑ u=1 w∑ v=1 |C|∑ c=1 yu,v,c · log(p̃u,v,c) · 1[yu,v,z 6= 1], (6)
where p̃ = softmax(ŷdrop) applied over the channel dimension. Then, LCE for the model’s original output and LCE_drop for the DropClass output are combined by a weighted sum:
Lseg = (1− λ) · LCE + λ · LCE_drop, (7) where λ is a scaling constant that balances the two loss terms.
The scaling constant λ plays an important role in ensuring the stability and effectiveness of training. The process outlined in Section 2.2 is based on the assumption that the gradient of Ai,j,k with respect to ŷc accurately quantifies the importance of Ai,j,k on the prediction of class c. In the initial stages of training, however, ŷ is likely to be largely inaccurate, and thus, the gradient may not accurately reflect the relationship between the feature and class prediction. Hence, relying on this gradient to perform DropClass from the early stages of training may lead to an unstable training process. To alleviate this issue, we train the model primarily with LCE at the early stages of training and linearly decrease its weight as training progresses. Conversely, we gradually increase the weight for LCE_drop, thereby facilitating learning of debiased and disentangled representations towards the end of training. This is achieved by linearly increasing the value of λ from 0 to 1 across the duration of training. To further stabilize training, we linearly increase the probability of dropping out any class from 0 to 1 as well.
Finally, we add an additional objective term Lsup that helps suppress the output probability of the dropped class z:
Lsup = 1
h× w h∑ u=1 w∑ v=1 p̃u,v,z. (8)
Even after removing information about class z, some information could still persist in the dropped feature Adrop, which would allow the model to predict a score for class z, albeit with low confidence. Hence, by suppressing the probability for class z directly, the model is encouraged to learn
Algorithm 1 Training scheme for DropClass. Require: Dataset D = {(x(i), y(i)}, set of classes C, feature extractor g(·) and classifier h(·).
1: for i = 1, 2, . . . do 2: Compute A = g(x(i)), ŷ = h(A). 3: for c = 1, 2, . . . do 4: Compute Sci,j,k = 1 h×w ∑h u=1 ∑w v=1 ∂ŷu,v,c ∂Ai,j,k
. . Eq. (1) 5: Compute Ac = ReLU(A Sc). . Eq. (2) 6: end for 7: Sample a class z to drop and deactivate Az . . Eq. (3) 8: Gather all Ac for ∀c ∈ C \ {z} and feed them into the classifier h(·). . Eq. (4) 9: Compute loss function and update parameters. . Eq. (9)
10: end for
class-specific representations, i.e., purge any redundant information related to class z from feature representations of all other classes c ∈ C \ {z}. Note that this loss is only calculated when a class is dropped. Altogether, the final objective function proposed for DropClass is:
Ltotal = Lseg + αLsup, (9)
where α is a hyper-parameter that weighs the relative importance of Lsup. A summary of our proposed training scheme can be found in Algorithm 1.

heading: 3 Experiments
text: To evaluate the effectiveness of DropClass, we experiment on a well-known semantic segmentation dataset: Cityscapes [6] with a few reasons. First, it is relatively small, with 2975 train images. Second, it has large class imbalances, with the pixel frequency ranging from 0.1% to 36.9%. These two commonalities make it difficult for an ordinary model to learn robust, debiased representations. We also conduct experiments on the Pascal VOC dataset [14], and the results can be found in the supplementary document.

heading: 3.1 Implementation Details
text: Network architectures We employ two recent segmentation network architectures, HRNet [1] and DeepLabV3 [2] with a MobileNetV3 [15] backbone, to highlight the model-agnostic property of our method. For HRNet, we use the code provided by the authors1, and use two different versions of HRNet: HRNetV1-W18 and HRNetV2-W18. For DeepLabV3, we use the official PyTorch [16] code2 and change the default backbone to MobileNetV3. All backbones are trained on the ImageNet [17] dataset.
Computational overhead Calculating gradients for each class imposes a heavy computational burden, which may lead to slow training. However, we take advantage of a simple trick that allows us to calculate the gradient in Eq. (1) efficiently. Since convolution layers are linear operations, ∂ŷu,v,c/∂Ai,j,k conveniently reduces to the weight of the convolution kernel. Thus, we employ a 1 × 1 convolution as the final classification layer, h, which is a common design choice in most semantic segmentation models. Using this trick reduces both the computational and memory overhead of the gradient calculation, and allows it to be processed in parallel as well.
Hyperparameters We compare our model with a baseline, where the model is trained with an ordinary cross-entropy loss (Eq. (5)) only. We use the same set of hyperparameters for both experiments to ensure fair comparison. The value of the loss weighing term α in Eq. (9) is set to 10 for all experiments, which is based on the scale of the two loss terms. As mentioned in Section 2.3, the value of λ is initialized as 0 and scaled linearly up to 1 until the end of training. Since DropClass depends on gradient computations to generate disentangled features, it takes more iterations for the model to fully converge under the DropClass training scheme. We sample a new class z for the entire batch at
1https://github.com/HRNet/HRNet-Semantic-Segmentation 2https://github.com/pytorch/vision/blob/master/torchvision/models/segmentation/
deeplabv3.py
each training iteration. The rest of our hyperparameters are organized as a table in the supplementary materials, where we detail the number of iterations, batch size, learning rate, learning rate decay, image size, and type of GPU used for each of our experiments.

heading: 3.2 Quantitative and Qualitative Results
text: Tables 1 presents the categorical Intersection-over-Union (IoU) and mean-IoU (mIoU) scores on the Cityscapes dataset. The absolute change in IoU (∆), as well as the relative change in IoU (∆(%)) are reported, to compare our method with the baseline. For better interpretability of our results, the classes are sorted in order of increasing pixel frequency, and we also calculate a separate mIoU score for the least frequent 50% of classes, which is denoted by mIoU†.
Our method consistently outperforms the baseline across all models, with 2.0%, 2.0%, and 0.7% gains on the mIoU for HRNetV1, HRNetV2, and DeepLabV3 models, respectively. More importantly, we observe even larger improvements on the mIoU for the 9 most under-represented classes, which account for merely 2.8% of all pixels: 2.9% on HRNetV1, 3.8% on HRNetV2, and 2.3% on DeepLabV3. These empirical results supports our claim that DropClass helps the model learn debiased feature representations that benefit the model’s overall performance, especially for under-represented classes. There are a few more interesting details we observe from Table 1. First, the IoU improves on most classes, albeit with smaller margins on well-represented classes. Also, we notice especially large improvements across all models on the “train” and “wall” categories, which also happen to be two of the least frequently appearing categories: “train” is the least frequent class, appearing in only 0.4% of all images, and “wall” is the fifth least frequent class, appearing in only 2.8% of all images. Figure 2 illustrates the qualitative results of the proposed model in comparison to the baseline on the Cityscapes dataset.

heading: 3.3 Comparisons with Other Debiasing Techniques
text: Many works on debiasing focus on the image classification task, and are not easily applicable to the semantic segmentation task. To emphasize that DropClass is better suited for semantic segmentation, we provide comparisons with two baseline debiasing techniques: reweighting and resampling.
Reweighting In Table 1, the results of both the baseline and our model employ median frequency balancing, which is widely used for the Cityscapes dataset. In median frequency balancing, the cross-entropy term is reweighted according to the frequency of classes. We train the model without this reweighting scheme on both the baseline and the model trained with DropClass. As shown in Table 2, even without the reweighting scheme, the model trained with DropClass outperforms the baseline model with the reweighting scheme.
Table 2: Comparison with the reweighting baselines on HRNetV1.
mIoU mIoU†
Baseline w/o reweighting 69.2 57.0 Baseline 69.3 58.1
Ours w/o reweighting 70.1 58.6 Ours 70.7 59.7
Table 3: Comparison with “motorcycle" resampling on HRNetV1 without reweighting.
IoU (motor.) mIoU Baseline 39.9 69.2
Baseline + 2x “motorcycle” 46.9 69.1 Ours 49.7 70.1
Resampling Resampling is not straightforward to implement in semantic segmentation since the training images contain multiple classes. For this experiment, we focus solely on the class with least pixel frequency of Cityscapes (“motorcycle”), without any reweighting scheme. To increase the sampling frequency of the “motorcycle” class, we enlarge the training set such that each image containing the “motorcycle” class is sampled twice at every training epoch. We observe a +7%p increase of IoU (39.9%→ 46.9%) in the baseline by resampling the “motorcycle” class. However, the baseline with “motorcycle” resampling loses mIoU by 0.1%p, meaning that the improvement of the “motorcycle” class comes at the cost of performance on other classes. To the contrary, our model outperforms the baseline with “motorcycle” resampling in terms of both the metrics, by +2.8%p, +1.0%p, respectively. The results are shown in Table 3.

heading: 3.4 Analysis
text: Robustness to harmful bias effects To demonstrate the debiasing effects of DropClass, we conduct a simple experiment to analyze the co-location effects between classes. Since it is difficult to rigorously quantify the co-location and analyze the bias vulnerability of the classes in real-world segmentation datasets, we define a simple proxy instead: the drop in IoU for each class pair (e.g., IoU of “person” after erasing “road”) of the baseline model. To achieve this, we design an unbiased test set (I*), where the validation set is copied 19 times, and one of the 19 classes in Cityscapes is erased from each copy. By observing how the IoU of class Y is affected by masking out the pixels of class X, we can quantify the harmful effects of co-location. For example, the “person” class is most affected by the absence of “road”, “sidewalk” and “bicycle” classes, which suggests that these classes are highly co-located with the “person” class. For each evaluated class, we first identify the Top3 most influential classes, then average IoUs after removing those classes. The same sets of Top3 classes are used to evaluate the model trained with DropClass on the unbiased test set. The results are shown in Table 4, where the baseline model obtains the mIoU of 68.9% while our model achieves the mIoU of 70.9%. Across the majority classes, we observe that our model suffers from less performance degradation, which verifies that the model trained with DropClass is less susceptible to the negative effects of co-location during inference. Also, note that the “rider” class, by definition, is dependent on the presence of “motorcycle” or “bicycle” class, which may rationalize the reason behind the smaller difference between the baseline and our model.
Correlation analysis We find that the baseline model is not only prone to learning biases due to the co-location of classes, but also susceptible to learning correlated representations, especially on under-represented classes. Thus, to better illustrate the benefits of DropClass, we plot the correlation matrix of both models, where the element at (i, j) corresponds to the cosine similarity between weight vectors of the i-th and j-th clasees in the final classification layer. We notice that the most frequent “road” class has low similarities with all classes, while the least frequent “motorcycle” class has high similarities with multiple classes, such as “bicycle” and “rider”. To this end, we calculate the row-wise non-diagonal sum, which is a measure of how correlated a class representation is with respect to all other classes and report the numbers in Table 5. We observe that more frequently appearing classes tend to be less correlated with other classes. Note that there is a clear trend between increasing frequency and decreasing correlations among classes. Furthermore, we observe that the model trained with DropClass shows lower inter-class correlations for all class pairs, as summarized in the last row of Table 5. The full correlation matrix is shown at Figure 3.
Grad-CAM visualizations We further analyze our method by examining Grad-CAM visualizations of trained models. We first select three pairs of classes that are likely to confuse a segmentation model: “motorcycle ↔ bicycle”, “truck ↔ train”, and ‘bus ↔ truck”. Then we generate the Grad-CAM visualizations with the baseline and the model trained with DropClass (HRNetV1 on Cityscapes), and compare the results in Figure 4, where each row corresponds to a different class pair. The second and third columns correspond to the visualizations of the two models when visualizing the Grad-CAMs for the ground-truth (GT) classes while the next two columns present the Grad-CAMs with respect to non-GT classes. Compared to the visualizations of the baseline model, the visualizations of our model
Table 5: Class correlations. Classes are sorted in order of increasing pixel frequency. ∆ indicates correlations of the baseline model subtracted by correlations of the model trained with DropClass.
m ot
or cy
cl e†
ri de
r†
t.l ig
ht †
tr ai
n†
bu s†
tr uc
k†
bi cy
cl e†
t.s ig
n†
w al
l†
fe nc
e
te rr
ai n
pe rs
on
po le
sk y
si de
w al
k
ca r
ve ge
ta tio
n
bu ild
in g
ro ad
Baseline 1.24 1.20 0.97 0.65 0.91 0.88 0.85 0.60 0.46 0.45 0.53 0.48 0.63 0.16 0.45 0.30 0.35 0.33 0.20 Ours 0.74 0.77 0.65 0.47 0.63 0.58 0.52 0.39 0.24 0.23 0.26 0.31 0.28 0.08 0.25 0.19 0.16 0.09 0.12 ∆ 0.50 0.43 0.32 0.18 0.28 0.30 0.33 0.21 0.22 0.22 0.27 0.17 0.35 0.08 0.20 0.11 0.19 0.24 0.08
Input Baseline: GT Ours: GT Baseline: non-GT Ours: non-GT
Figure 4: Examples of Grad-CAM visualizations. From top to bottom, the input images contain “motorcycle", "truck", and "bus". The Grad-CAMs of the baseline and the model trained with DropClass with respect to the ground-truth (GT) classes are presented in the second and third columns respectively, while the Grad-CAMs of the two models with respect to the non-GT classes—“bicycle”, “train”, and “truck”—are shown in the fourth and fifth columns.
consistently display lower activations for the non-GT classes. Furthermore, our model exhibits strong gradients for the GT classes as well, which indicates that the model maintains better discriminability in the process of debiasing.
Ablations To better understand our proposed method and its effectiveness, we conduct ablation experiments on the Cityscapes dataset with the HRNetV1 model. First, we omit Lsup defined in Eq (8), which has the purpose of suppressing outputs for the dropped class. We observe that when we remove this loss term, the effectiveness of our method decreases slightly in terms of the total mIoU and the under-represented class mIoU (mIoU†), by 0.5%p and 1.1%p, respectively. However, it still outperforms the baseline by 0.9%p and 0.5%p on the two metrics. Next, we also test the effects of dropping the labels of a randomly selected class, without DropClass or any of its accompanying loss functions. In other words, a model is trained only with the ordinary cross-entropy loss, Eq. (5), while random class labels are not used (e.g., ignored) at each iteration. Unsurprisingly, we observe that this model performs worse than the baseline
model, by 0.1%p in both metrics. Thus, our ablation experiments highlight the importance of the suppression loss and validate the effectiveness of DropClass.

heading: 4 Related Works
text: Dataset bias Dataset bias is a critical issue in modern machine learning because trained models often achieve outstanding accuracy simply by capturing the correlated features instead of identifying the proper representations of target classes. To tackle the limitation, various debiasing techniques have been proposed under supervised [19–22] and unsupervised [13, 23, 24] settings, but most of existing approaches are for simple classification tasks. Technically, they are limited to sample reweighting [24– 27] and loss adjustment [19–24]. The proposed algorithm is unique in the sense that we aim to learn a classifier for dense prediction. One previous work [28] argues that feature entanglement in the early layers can enhance the discriminative power of the model. However, they experiment on the classification task, and the conclusion may not be applicable to semantic segmentation, where data samples contain multiple classes per image. We suspect that explicitly entangling features in a segmentation model may have an adverse effect on the model’s ability to identify class boundaries within a given image.
Semantic segmentation Semantic segmentation works have attempted to improve performance with diverse operations that aim to widen the receptive field, while maintaining details in the features from different resolutions. To this end, DeconvNet [3] learns deconvolution layers to replace fixed upsampling operations and DeepLabV3 [2] employs atrous convolution to capture objects at multiple scales. Furthermore, PSPNet [29] proposes a pyramid pooling module to capture different sub-region representations and HRNet [1] aggregates four different resolution of feature maps to preserve details, especially for the deeper layers with lower resolutions.
Visual explanations Even with extensive results in broad domains, non-convexity and highdimensionality of deep neural networks restrict human-level understandings of its internal process. To remedy this issue, [7, 30–32] attempt to make visual explanations of deep models. CAM [30] first proposes to find discriminative regions relevant to target classes, but has architectural restriction due to the use of the global average pooling layer. Grad-CAM [7] visualizes the importance of each class by leveraging the gradient information, and [31] extends Grad-CAM for semantic segmentation. CAM and Grad-CAM have often been employed in weakly supervised object detection [33, 34] and segmentation [35–37], where they highlight relevant objects or regions without full supervision for target tasks. We compute Grad-CAM for each class, but employ the estimated class-specific feature maps for learning debiased and disentangled representations.

heading: 5 Conclusion and Discussion
text: We presented a model agnostic training scheme that helps the model learn more debiased and disentangled feature representations for the semantic segmentation task. Our method is based on the simple and intuitive idea of randomly dropping disentangled class-specific features at each iteration of training. The new combination of features removes certain inter-class dependencies, which leads to learning debiased and disentangled feature representations. Our experimental results on two distinct network architectures and datasets validate our method’s effectiveness, and our analysis reflect that our method achieves the intended goals.
One limitation of the proposed DropClass training scheme is that it requires more iterations for the model to fully converge. This is because DropClass depends on the model’s ability to generate disentangled feature representations and has more complex training process.

heading: Acknowledgments
text: We truly thank the anonymous reviewers for their valuable comments throughout the review process. This paper was improved significantly through the communication with them. This work was partly supported by Samsung Advanced Institute of Technology, Korean ICT R&D programs of the MSIT/IITP grant [2017-0-01779, XAI, 2021-0-01343, Artificial Intelligence Graduate School Program (Seoul National University)], and the Bio & Medical Technology Development Program of the National Research Foundation (NRF) funded by the Korea government (MSIT) [2021M3A9E4080782].

Review summaries:
Recent semantic segmentation methods often learn biased representation from the dataset with highly co-located objects (e.g., motorcycle and road) as well as the class imbalance. This paper proposes a training scheme of dropping the class-specific representations in the highly-entangled features, mitigating the bias induced by the dropped class. The proposed DropClass is also model-agnostic and demonstrates the improved segmentation results in Cityscapes and Pascal VOC datasets.

This paper presents DropClass, a new training scheme for reducing feature dependencies among classes to learn debiased and disentangled feature representations. Toward this, the paper  consider Grad-CAM for obtaining the class-specific information, and then randomly discard such information to remove any bias towards a certain class.   A set of experiments on benchmark datasets demonstrate the model’s effectiveness, primarily on under-represented classes. 

This paper proposes a DropClass training scheme where class-specific feature maps are used to obtain debased and disentangled representations. This is achieved by randomly dropping out class-specific representation from the feature maps, implemented in an annealing manner, reinforced with a regularization term to further remove class-specific information from the remaining information. Experiments are performed on three segmentation networks on two distinct data sets. The presented method seems to achieves an improvement of performance in most classes, with the most noticeable margin of improvement in minority classes.