Original: CAFEN ET : C LASS -A GNOSTIC F EW -S HOT E DGE D ETECTION N ETWORK
Revised: CAFEN ET : C LASS -A GNOSTIC F EW -S HOT E DGE D ETECTION N ETWORK

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: We tackle a novel few-shot learning challenge, few-shot semantic edge detection, aiming to localize boundaries of novel categories using only a few labeled samples.
Revised: We tackle a novel few-shot learning challenge, few-shot semantic edge detection, aiming to localize boundaries of novel categories using only a few labeled samples.

Original: Reliable boundary information has been shown to boost the performance of semantic segmentation and localization, while also playing a key role in its own right in object reconstruction, image generation and medical imaging.
Revised: Reliable boundary information has been shown to boost the performance of semantic segmentation and localization, while also playing a key role in its own right in object reconstruction, image generation and medical imaging.

Original: Few-shot semantic edge detection allows recovery of accurate boundaries with just a few examples.
Revised: Few-shot semantic edge detection allows recovery of accurate boundaries with just a few examples.

Original: In this work, we present a Class-Agnostic Few-shot Edge detection
Revised: In this work, we present a Class-Agnostic Few-shot Edge detection

Original: Network (CAFENet) based on meta-learning strategy.
Revised: Network (CAFENet) based on meta-learning strategy.

Original: CAFENet employs a semantic segmentation module in small-scale to compensate for lack of semantic information in edge labels.
Revised: CAFENet employs a semantic segmentation module in small-scale to compensate for lack of semantic information in edge labels.

Original: The predicted segmentation mask is used to generate an attention map to highlight the target object region, and make the decoder module concentrate on that region.
Revised: The predicted segmentation mask is used to generate an attention map to highlight the target object region, and make the decoder module concentrate on that region.

Original: We also propose a new regularization method based on multi-split matching.
Revised: We also propose a new regularization method based on multi-split matching.

Original: In meta-training, the metric-learning problem with highdimensional vectors are divided into smaller subproblems with low-dimensional sub-vectors.
Revised: In meta-training, the metric-learning problem with highdimensional vectors are divided into smaller subproblems with low-dimensional sub-vectors.

Original: Since there are no existing datasets for few-shot semantic edge detection, we construct two new datasets, FSE-1000 and SBD- 5 i , and evaluate the performance of the proposed CAFENet on them.
Revised: Since there are no existing datasets for few-shot semantic edge detection, we construct two new datasets, FSE-1000 and SBD- 5 i , and evaluate the performance of the proposed CAFENet on them.

Original: Extensive simulation results conﬁrm that the proposed CAFENet achieves better performance compared to the baseline methods using ﬁne-tuning or few-shot segmentation.
Revised: Extensive simulation results conﬁrm that the proposed CAFENet achieves better performance compared to the baseline methods using ﬁne-tuning or few-shot segmentation.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Semantic edge detection aims to identify pixels that belong to boundaries of predeﬁned categories.
Revised: Semantic edge detection aims to identify pixels that belong to boundaries of predeﬁned categories.

Original: Boundary information has been shown to be effective for boosting the performance of semantic segmentation (Bertasius et al., 2016;
Revised: Boundary information has been shown to be effective for boosting the performance of semantic segmentation (Bertasius et al., 2016;

Original: Chen et al., 2016) and localization (Yu et al., 2018a; Wang et al., 2015).
Revised: Chen et al., 2016) and localization (Yu et al., 2018a; Wang et al., 2015).

Original: It also plays a key role in applications such as object reconstruction (Ferrari et al., 2007; Zhu et al., 2018), image generation (Isola et al., 2017; Wang et al., 2018) and medical imaging (Abbass & Mousa, 2017; Mehena, 2019).
Revised: It also plays a key role in applications such as object reconstruction (Ferrari et al., 2007; Zhu et al., 2018), image generation (Isola et al., 2017; Wang et al., 2018) and medical imaging (Abbass & Mousa, 2017; Mehena, 2019).

Original: Early edge detection algorithms interpret the problem as a low-level grouping problem exploiting hand-crafted features and local information (Canny, 1986;
Revised: Early edge detection algorithms interpret the problem as a low-level grouping problem exploiting hand-crafted features and local information (Canny, 1986;

Original: Sugihara, 1986).
Revised: Sugihara, 1986).

Original: Recently, there have been signiﬁcant improvements on edge detection thanks to the advances in deep learning.
Revised: Recently, there have been signiﬁcant improvements on edge detection thanks to the advances in deep learning.

Original: Moreover, beyond previous boundary detection, category-aware semantic edge detection became possible (Acuna et al., 2019; Hu et al., 2019; Yu et al., 2018b).
Revised: Moreover, beyond previous boundary detection, category-aware semantic edge detection became possible (Acuna et al., 2019; Hu et al., 2019; Yu et al., 2018b).

Original: However, it is impossible to train deep neural networks without massive amounts of annotated data.
Revised: However, it is impossible to train deep neural networks without massive amounts of annotated data.

Original: To overcome the data scarcity issue in image classiﬁcation, few-shot learning has been actively discussed for recent years (Finn et al., 2017; Lifchitz et al., 2019).
Revised: To overcome the data scarcity issue in image classiﬁcation, few-shot learning has been actively discussed for recent years (Finn et al., 2017; Lifchitz et al., 2019).

Original: Few-shot learning algorithms train machines to learn previously unseen classiﬁcation tasks using only a few relevant labeled examples.
Revised: Few-shot learning algorithms train machines to learn previously unseen classiﬁcation tasks using only a few relevant labeled examples.

Original: More recently, the idea of few-shot learning is applied to computer vision tasks requiring highly laborious and expensive data labeling such as semantic segmentation (Dong & Xing, 2018;
Revised: More recently, the idea of few-shot learning is applied to computer vision tasks requiring highly laborious and expensive data labeling such as semantic segmentation (Dong & Xing, 2018;

Original: Wang et al., 2019) and object detection (Fu et al., 2019; Karlinsky et al., 2019).
Revised: Wang et al., 2019) and object detection (Fu et al., 2019; Karlinsky et al., 2019).

Original: Based on meta-learning across varying tasks, the machines can adapt to unencountered environments and demonstrate robust performance in various computer vision problems.
Revised: Based on meta-learning across varying tasks, the machines can adapt to unencountered environments and demonstrate robust performance in various computer vision problems.

Original: In this paper, we consider a novel few-shot learning challenge, few-shot semantic edge detection, to detect the semantic boundaries using only a few labeled samples.
Revised: In this paper, we consider a novel few-shot learning challenge, few-shot semantic edge detection, to detect the semantic boundaries using only a few labeled samples.

Original: Through experiments, we show that few-shot semantic edge detection can not be simply solved by ﬁne-tuning a pretrained semantic edge detector or utilizing a nonparametric edge detector in a few-shot segmentation setting.
Revised: Through experiments, we show that few-shot semantic edge detection can not be simply solved by ﬁne-tuning a pretrained semantic edge detector or utilizing a nonparametric edge detector in a few-shot segmentation setting.

Original: To tackle this elusive challenge, we propose a class-agnostic few-shot edge detector (CAFENet) and present new datasets for evaluating few-shot semantic edge detection.
Revised: To tackle this elusive challenge, we propose a class-agnostic few-shot edge detector (CAFENet) and present new datasets for evaluating few-shot semantic edge detection.

Original: [Figure]
Revised: [Figure]

Original: Fig.
Revised: Fig.

Original: 1 shows the architecture of the proposed CAFENet.
Revised: 1 shows the architecture of the proposed CAFENet.

Original: Since the edge labels do not contain enough semantic information due to the sparsity of labels, performance of the edge detector severely degrades when the training dataset is very small.
Revised: Since the edge labels do not contain enough semantic information due to the sparsity of labels, performance of the edge detector severely degrades when the training dataset is very small.

Original: To overcome this, we adopt the segmentation process in advance of detecting edge with downsized feature and segmentation labels generated from boundaries labels.
Revised: To overcome this, we adopt the segmentation process in advance of detecting edge with downsized feature and segmentation labels generated from boundaries labels.

Original: We utilize a simple metric-based segmentator generating a segmentation mask through pixel-wise feature matching with class prototypes, which are computed by masked average pooling of (Zhang et al., 2018).
Revised: We utilize a simple metric-based segmentator generating a segmentation mask through pixel-wise feature matching with class prototypes, which are computed by masked average pooling of (Zhang et al., 2018).

Original: The predicted segmentation mask provides the semantic information to the edge detector.
Revised: The predicted segmentation mask provides the semantic information to the edge detector.

Original: The multi-scale attention maps are generated from the segmentation mask, and applied to corresponding multi-scale features.
Revised: The multi-scale attention maps are generated from the segmentation mask, and applied to corresponding multi-scale features.

Original: The edge detector predicts the semantic boundaries using the attended features.
Revised: The edge detector predicts the semantic boundaries using the attended features.

Original: Using this attention mechanism, the edge detector can focus on relevant regions while alleviating the noise effect of external details.
Revised: Using this attention mechanism, the edge detector can focus on relevant regions while alleviating the noise effect of external details.

Original: For meta-training of CAFENet, we introduce a simple yet powerful regularization method, Multi-Split Matching Regularization (MSMR), performing metric learning on multiple low-dimensional embedding sub-spaces during meta-training.
Revised: For meta-training of CAFENet, we introduce a simple yet powerful regularization method, Multi-Split Matching Regularization (MSMR), performing metric learning on multiple low-dimensional embedding sub-spaces during meta-training.

Original: The main contributions of this paper are as follows.
Revised: The main contributions of this paper are as follows.

Original: First, we introduce a few-shot semantic edge detection problem for performing semantic edge detection on previously unseen objects using only a few training examples.
Revised: First, we introduce a few-shot semantic edge detection problem for performing semantic edge detection on previously unseen objects using only a few training examples.

Original: Second, we introduce two new datasets of SBD- 5 i and FSE-1000 for few-shot edge detection.
Revised: Second, we introduce two new datasets of SBD- 5 i and FSE-1000 for few-shot edge detection.

Original: Third, we propose a few-shot edge detector, CAFENet and validate the performance of the proposed method through experiments.
Revised: Third, we propose a few-shot edge detector, CAFENet and validate the performance of the proposed method through experiments.

Original:  R ELATED W ORK 2. F EW - SHOT L EARNING
Revised:  R ELATED W ORK 2. F EW - SHOT L EARNING

Original: To tackle the few-shot learning challenge, many methods have been proposed based on metalearning.
Revised: To tackle the few-shot learning challenge, many methods have been proposed based on metalearning.

Original: Optimization-based methods (Finn et al., 2017; Ravi & Larochelle, 2016) train the metalearner which updates the parameters of the actual learner so that the learner can easily adapt to a new task within a few labeled samples.
Revised: Optimization-based methods (Finn et al., 2017; Ravi & Larochelle, 2016) train the metalearner which updates the parameters of the actual learner so that the learner can easily adapt to a new task within a few labeled samples.

Original: Metric-based methods (Vinyals et al., 2016; Snell et al., 2017;
Revised: Metric-based methods (Vinyals et al., 2016; Snell et al., 2017;

Original: Yoon et al., 2019) train the feature extractor to assemble features from the same class together on the embedding space while keeping features from different classes far apart.
Revised: Yoon et al., 2019) train the feature extractor to assemble features from the same class together on the embedding space while keeping features from different classes far apart.

Original: Recent metric-based approaches propose dense classiﬁcation (Hou et al., 2019; Kye et al., 2020).
Revised: Recent metric-based approaches propose dense classiﬁcation (Hou et al., 2019; Kye et al., 2020).

Original: Dense classiﬁcation trains an instance-wise classiﬁer on pixel-wise classiﬁcation loss which imposes coherent predictions over the spatial dimension and prevents overﬁtting as a result.
Revised: Dense classiﬁcation trains an instance-wise classiﬁer on pixel-wise classiﬁcation loss which imposes coherent predictions over the spatial dimension and prevents overﬁtting as a result.

Original: Our model adopts the metric-based method for few-shot learning.
Revised: Our model adopts the metric-based method for few-shot learning.

Original: Inspired by dense classiﬁcation, we propose multi-split matching regularization which divides the feature vector into sub-vector splits and performs split-wise classiﬁcation for regularization in meta-learning.
Revised: Inspired by dense classiﬁcation, we propose multi-split matching regularization which divides the feature vector into sub-vector splits and performs split-wise classiﬁcation for regularization in meta-learning.

Original: 2. F EW - SHOT S EMANTIC S EGMENTATION
Revised: 2. F EW - SHOT S EMANTIC S EGMENTATION

Original: The goal of few-shot segmentation is to perform semantic segmentation within a few labeled samples based on meta-learning (Shaban et al., 2017; Dong & Xing, 2018;
Revised: The goal of few-shot segmentation is to perform semantic segmentation within a few labeled samples based on meta-learning (Shaban et al., 2017; Dong & Xing, 2018;

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

Original: OSLSM of (Shaban et al., 2017) adopts a two-branch structure: conditioning branch generating element-wise scale and shift factors using the support set and segmentation branch performing segmentation with a fully convolutional network and task-conditioned features.
Revised: OSLSM of (Shaban et al., 2017) adopts a two-branch structure: conditioning branch generating element-wise scale and shift factors using the support set and segmentation branch performing segmentation with a fully convolutional network and task-conditioned features.

Original: Co-FCN (Rakelly et al., 2018) also utilizes a two-branch structure.
Revised: Co-FCN (Rakelly et al., 2018) also utilizes a two-branch structure.

Original: The globally pooled prediction is generated using support set in conditioning branch, and fused with query features to predict the mask in segmentation branch.
Revised: The globally pooled prediction is generated using support set in conditioning branch, and fused with query features to predict the mask in segmentation branch.

Original: SGOne of (Zhang et al., 2018) proposes a masked average pooling to compute prototypes from pixels of support features.
Revised: SGOne of (Zhang et al., 2018) proposes a masked average pooling to compute prototypes from pixels of support features.

Original: The cosine similarity scores are computed between the prototypes and pixels of query feature, and the similarity map guides the segmentation process.
Revised: The cosine similarity scores are computed between the prototypes and pixels of query feature, and the similarity map guides the segmentation process.

Original: CANet of (Zhang et al., 2019) also adopts masked average pooling to generate the global feature vector, and concatenate it with every location of the query feature for dense comparison in predicting the segmentation mask.
Revised: CANet of (Zhang et al., 2019) also adopts masked average pooling to generate the global feature vector, and concatenate it with every location of the query feature for dense comparison in predicting the segmentation mask.

Original: PANet of (Wang et al., 2019) introduces prototype alignment, predicting the segmentation mask of support samples using query prediction results as labels of query samples, for regularization. 
Revised: PANet of (Wang et al., 2019) introduces prototype alignment, predicting the segmentation mask of support samples using query prediction results as labels of query samples, for regularization. PMM of Yang et al.

Revised: (2020) utilizes multiple prototypes generated using Expectation-Maximization (EM) algorithm to effectively leverage the semantic information from the few labeled samples.

Original: 2. S EMANTIC E DGE D ETECTION
Revised: 2. S EMANTIC E DGE D ETECTION

Original: Semantic edge detection aims to ﬁnd the boundaries of objects from image and classify the objects at the same time.
Revised: Semantic edge detection aims to ﬁnd the boundaries of objects from image and classify the objects at the same time.

Original: The history of semantic edge detection (Acuna et al., 2019; Hu et al., 2019) dates back to the work of (Prasad et al., 2006) which adopts the support vector machine as a semantic classiﬁer on top of the traditional canny edge detector.
Revised: The history of semantic edge detection (Acuna et al., 2019; Hu et al., 2019) dates back to the work of (Prasad et al., 2006) which adopts the support vector machine as a semantic classiﬁer on top of the traditional canny edge detector.

Original: Recently, many semantic edge detection algorithms rely on deep neural network and multi-scale feature fusion.
Revised: Recently, many semantic edge detection algorithms rely on deep neural network and multi-scale feature fusion.

Original: CASENET of (Yu et al., 2017) addresses the semantic edge detection as a multi-label problem where each boundary pixel is labeled into categories of adjacent objects.
Revised: CASENET of (Yu et al., 2017) addresses the semantic edge detection as a multi-label problem where each boundary pixel is labeled into categories of adjacent objects.

Original: Dynamic Feature Fusion (DFF) of (Hu et al., 2019) proposes a novel way to leverage multi-scale features.
Revised: Dynamic Feature Fusion (DFF) of (Hu et al., 2019) proposes a novel way to leverage multi-scale features.

Original: The multi-scale features are fused by weighted summation with fusion weights generated dynamically for each images and each pixel.
Revised: The multi-scale features are fused by weighted summation with fusion weights generated dynamically for each images and each pixel.

Original: Meanwhile, Simultaneous
Revised: Meanwhile, Simultaneous

Original: Edge Alignment and Learning (SEAL) of (Yu et al., 2018b) deals with severe annotation noise of the existing edge dataset (Hariharan et al., 2011).
Revised: Edge Alignment and Learning (SEAL) of (Yu et al., 2018b) deals with severe annotation noise of the existing edge dataset (Hariharan et al., 2011).

Original: SEAL treats edge labels as latent variables and jointly trains them to align noisy misaligned boundary annotations.
Revised: SEAL treats edge labels as latent variables and jointly trains them to align noisy misaligned boundary annotations.

Original: Semantically Thinned Edge
Revised: Semantically Thinned Edge

Original: Alignment Learning (STEAL) of (Acuna et al., 2019) improves the computation efﬁciency of edge label alignment through a lightweight level set formulation.
Revised: Alignment Learning (STEAL) of (Acuna et al., 2019) improves the computation efﬁciency of edge label alignment through a lightweight level set formulation.

Original:  P ROBLEM S ETUP
Revised:  P ROBLEM S ETUP

Original: For few-shot semantic edge detection, we use train set D train and test set D test consisting of nonoverlapping categories C train and C test .
Revised: For few-shot semantic edge detection, we use train set D train and test set D test consisting of nonoverlapping categories C train and C test .

Original: The model is trained only using C train , and the test categories C test are never seen during the training phase.
Revised: The model is trained only using C train , and the test categories C test are never seen during the training phase.

Original: For meta-training of the model, we adopt episodic training as done in many previous few-shot learning works.
Revised: For meta-training of the model, we adopt episodic training as done in many previous few-shot learning works.

Original: Each episode is composed of a support set with a few-labeled samples and a query set.
Revised: Each episode is composed of a support set with a few-labeled samples and a query set.

Original: When an episode is given, the model adapts to the given episode using the support set and detect semantic boundaries of the query set.
Revised: When an episode is given, the model adapts to the given episode using the support set and detect semantic boundaries of the query set.

Original: By episodic training, the model is learned so that it adapts to the unseen class using only a few labeled samples and predict semantic edges of query samples.
Revised: By episodic training, the model is learned so that it adapts to the unseen class using only a few labeled samples and predict semantic edges of query samples.

Original: For N c -way N s -shot setting, each training episode is constructed by N c classes sampled from
Revised: For N c -way N s -shot setting, each training episode is constructed by N c classes sampled from

Original: C train .
Revised: C train .

Original: When N c categories are given, N s support samples and N q query samples are randomly chosen from D train for each class.
Revised: When N c categories are given, N s support samples and N q query samples are randomly chosen from D train for each class.

Original: In evaluation, the performance of the model is evaluated using test episodes.
Revised: In evaluation, the performance of the model is evaluated using test episodes.

Original: The test episodes are constructed in the same way as the training episodes, except N c classes and corresponding support and query samples are sampled from C test and D test .
Revised: The test episodes are constructed in the same way as the training episodes, except N c classes and corresponding support and query samples are sampled from C test and D test .

Original: In this work, we address N c -way N s -shot semantic edge detection.
Revised: In this work, we address N c -way N s -shot semantic edge detection.

Original: The goal is training the model to generalize to N c unseen classes given only N s images and their edge labels.
Revised: The goal is training the model to generalize to N c unseen classes given only N s images and their edge labels.

Original: Based on the few labeled support samples, the model should produce edge predictions of query images which belong to N c unencountered classes.
Revised: Based on the few labeled support samples, the model should produce edge predictions of query images which belong to N c unencountered classes.

Original:  M ETHOD
Revised:  M ETHOD

Original: We propose a novel algorithm for few-shot semantic edge detection.
Revised: We propose a novel algorithm for few-shot semantic edge detection.

Original: Fig.
Revised: Fig.

Original: 2 illustrates the network architecture of the proposed method.
Revised: 2 illustrates the network architecture of the proposed method.

Original: The proposed CAFENet adopts the semantic segmentation module to compensate for the lack of semantic information in edge labels.
Revised: The proposed CAFENet adopts the semantic segmentation module to compensate for the lack of semantic information in edge labels.

Original: The predicted segmentation mask is utilized for attention in skip connection.
Revised: The predicted segmentation mask is utilized for attention in skip connection.

Original: The ﬁnal edge detection is done using attentive multi-scale features.
Revised: The ﬁnal edge detection is done using attentive multi-scale features.

Original: 4. S EMANTIC S EGMENTATOR
Revised: 4. S EMANTIC S EGMENTATOR

Original: Most previous works on semantic edge detection directly predict edges from the given input im- age.
Revised: Most previous works on semantic edge detection directly predict edges from the given input im- age.

Original: However, direct edge prediction is a hard task when only a few labeled samples are given.
Revised: However, direct edge prediction is a hard task when only a few labeled samples are given.

Original: To overcome this difﬁculty in few-shot edge detection, we adopt a semantic segmentation module in ad- vance of edge prediction.
Revised: To overcome this difﬁculty in few-shot edge detection, we adopt a semantic segmentation module in ad- vance of edge prediction.

Original: With the assistance of the segmentation module, CAFENet can effectivelylocalize the target object and extract semantic features from query samples. For few-shot segmen- tation, we employ the metric-learning which utilizes prototypes for foreground and background as
Revised: With the assistance of the segmentation module, CAFENet can effectively

Original: [Figure]
Revised: [Figure]

Original: 2x 2x 2x 2x
Revised: 2x 2x 2x 2x

Original: Query sample
Revised: Query sample

Original: Prediction 320 ×320 ×320 ×160 ×160 ×160 ×80 ×80 ×80 ×40 ×40 ×40 ×20 ×20 ×20 ×
Revised: Prediction 320 ×320 ×320 ×160 ×160 ×160 ×80 ×80 ×80 ×40 ×40 ×40 ×20 ×20 ×20 ×

Original: Support set
Revised: Support set

Original: MAP
Revised: MAP

Original: Segmentator
Revised: Segmentator

Original: Attention map
Revised: Attention map

Original: E E
Revised: E E

Original: E E
Revised: E E

Original: S S
Revised: S S

Original: S
Revised: S

Original: S S
Revised: S S

Original: D D
Revised: D D

Original: D D
Revised: D D

Original: D2x
Revised: D2x

Original: MAP
Revised: MAP

Original: Up-sampling Multiplication
Revised: Up-sampling Multiplication

Original: Concatenation Masked Average Pooling 2x 2x
Revised: Concatenation Masked Average Pooling 2x 2x

Original: D_conv
Revised: D_conv

Original: D_conv D_conv
Revised: D_conv D_conv

Original: D 3,
Revised: D 3,

Original: D 3, 𝐷 4, 𝐷 4, 𝑆  done in (Dong & Xing, 2018; Wang et al., 2019).
Revised: D 3, 𝐷 4, 𝐷 4, 𝑆 localize the target object and extract semantic features from query samples. For few-shot segmen- tation, we employ the metric-learning which utilizes prototypes for foreground and background as done in (Dong & Xing, 2018; Wang et al., 2019).

Original: Given the support set S = { x si , y si } N s i =1 , the encoder E extracts features { E ( x si ) }
Revised: Given the support set S = { x si , y si } N s i =1 , the encoder E extracts features { E ( x si ) }

Original: N s i =1 from S .
Revised: N s i =1 from S .

Original: Also, for support labels { y si } N s i =1 , we generate the dense segmentation mask { M si } N s i
Revised: Also, for support labels { y si } N s i =1 , we generate the dense segmentation mask { M si } N s i

Original: =
Revised: =

Original: 1 using a rule-based preprocessor, considering the pixels inside the boundary as foreground pixels in the segmentation label.
Revised: 1 using a rule-based preprocessor, considering the pixels inside the boundary as foreground pixels in the segmentation label.

Original: Using down-sampled segmentation labels { m si } N s i =1 , the prototype for foreground pixels P FG is computed as
Revised: Using down-sampled segmentation labels { m si } N s i =1 , the prototype for foreground pixels P FG is computed as

Original: [Equation]
Revised: [Equation]

Original: where j indexes the pixel location, E j ( x ) and m si,j denote the j th pixel of feature E ( x ) and segmentation mask m si .
Revised: where j indexes the pixel location, E j ( x ) and m si,j denote the j th pixel of feature E ( x ) and segmentation mask m si .

Original: H, W denote height and width of the images.
Revised: H, W denote height and width of the images.

Original: Likewise, the background prototype P
Revised: Likewise, the background prototype P

Original: BG is computed as
Revised: BG is computed as

Original: [Equation]
Revised: [Equation]

Original: Following the prototypical networks of (Snell et al., 2017), the probability that pixel j belongs to foreground for the query sample x qi is
Revised: Following the prototypical networks of (Snell et al., 2017), the probability that pixel j belongs to foreground for the query sample x qi is

Original: [Equation]
Revised: [Equation]

Original: where d ( · , · ) is squared Euclidean distance between two vectors and τ is a learnable temperature parameter.
Revised: where d ( · , · ) is squared Euclidean distance between two vectors and τ is a learnable temperature parameter.

Original: With query samples { x qi } N q i =1 and the down-sampled segmentation labels for query { m qi } N q i =1 , the segmentation loss L Seg is calculated as the mean-squared error (MSE) loss between predicted probabilities and the down-sized segmentation mask
Revised: With query samples { x qi } N q i =1 and the down-sampled segmentation labels for query { m qi } N q i =1 , the segmentation loss L Seg is calculated as the mean-squared error (MSE) loss between predicted probabilities and the down-sized segmentation mask

Original: [Equation]
Revised: [Equation]

Original: Note that the segmentation mask is generated in down-sized scale so that any pixel near the boundaries can be classiﬁed into the foreground to some extent, as well as the background.
Revised: Note that the segmentation mask is generated in down-sized scale so that any pixel near the boundaries can be classiﬁed into the foreground to some extent, as well as the background.

Original: Therefore, we approach the problem as a regression using MSE loss rather than cross entropy loss.
Revised: Therefore, we approach the problem as a regression using MSE loss rather than cross entropy loss.

Original: 4. M ULTI -S PLIT M ATCHING R EGULARIZATION
Revised: 4. M ULTI -S PLIT M ATCHING R EGULARIZATION

Original: The metric-based few-shot segmentation method utilizes distance metrics between the highdimensional feature vectors and prototypes, as seen in Fig. 3a.
Revised: The metric-based few-shot segmentation method utilizes distance metrics between the highdimensional feature vectors and prototypes, as seen in Fig. 3a.

Original: However, this approach is proneto overﬁt due to the massive number of parameters in feature vectors. To get around this issue,
Revised: However, this approach is prone

Original: [Figure]
Revised: [Figure]

Revised: to overﬁt due to the massive number of parameters in feature vectors.

Original:  we propose a novel regularization method, multi-split matching regularization (MSMR).
Revised: To get around this issue, we propose a novel regularization method, multi-split matching regularization (MSMR).

Original: In MSMR, high-dimensional feature vectors are split into several low-dimensional feature vectors, and the metric learning is conducted on each vector split as Fig.
Revised: In MSMR, high-dimensional feature vectors are split into several low-dimensional feature vectors, and the metric learning is conducted on each vector split as Fig.

Original: 3b.
Revised: 3b.

Original: With the query feature E ( x qi ) ∈ R C × W × H , where C is channel dimension and H, W are spatial dimensions, we divide E ( x qi ) into K sub-vectors { E k ( x qi ) } Kk =1 along channel dimension.
Revised: With the query feature E ( x qi ) ∈ R C × W × H , where C is channel dimension and H, W are spatial dimensions, we divide E ( x q i ) into K sub-vectors { E k ( x q i ) } Kk =1 along channel dimension.

Original: Each sub-vector E k ( x q i ) is in R CK × W × H .
Revised: Each sub-vector E k ( x qi ) is in R CK × W × H .

Original: Likewise, the prototypes P FG and P BG are also disassembled into K sub-vectors { P kFG } Kk =1 and { P kBG } Kk =1 along channel dimension where P kFG , P kBG ∈ R CK .
Revised: Likewise, the prototypes P FG and P BG are also disassembled into K sub-vectors { P kFG } Kk =1 and { P kBG } Kk =1 along channel dimension where P kFG , P kBG ∈ R CK .

Original: For the k th sub-vector of query feature E k ( x qi ) , the probability that the j th pixel belongs to the foreground class is computed as follows:
Revised: For the k th sub-vector of query feature E k ( x qi ) , the probability that the j th pixel belongs to the foreground class is computed as follows:

Original: [Equation]
Revised: [Equation]

Original: MSMR divides the original metric learning problem into K small sub-problems composed of a fewer parameters and acts as regularizer for high-dimensional embeddings.
Revised: MSMR divides the original metric learning problem into K small sub-problems composed of a fewer parameters and acts as regularizer for high-dimensional embeddings.

Original: The prediction results of K sub-problems are reﬂected on learning by combining the split-wise segmentation losses to original segmentation loss in Eq.
Revised: The prediction results of K sub-problems are reﬂected on learning by combining the split-wise segmentation losses to original segmentation loss in Eq.

Original: The total segmentation loss is calculated as
Revised: The total segmentation loss is calculated as

Original: L Seg = 1 N q H × W N q (cid:88) i = H × W (cid:88)
Revised: [Equation]

Original: j = { ( p i,j − m qi,j ) 2 + K (cid:88) i = ( p ki,j − m qi,j ) 2 } . (6) where p i,j = p ( y qi,j = FG | x qi ; E ) and p ki,j = p k ( y qi,j = FG | x qi ; E ) .
Revised: (6) where p i,j = p ( y qi,j = FG | x qi ; E ) and p ki,j = p k ( y qi,j = FG | x qi ; E ) .

Original: 4. A TTENTIVE E DGE D ETECTOR
Revised: 4. A TTENTIVE E DGE D ETECTOR

Original: As shown in Fig.
Revised: As shown in Fig.

Original: 2, we adopt the nested encoder structure to extract rich hierarchical features.
Revised: 2, we adopt the nested encoder structure to extract rich hierarchical features.

Original: The multi-scale side outputs from encoder E (1) ∼ E (4) are post-processed through bottleneck blocks
Revised: The multi-scale side outputs from encoder E (1) ∼ E (4) are post-processed through bottleneck blocks

Original: S (1) ∼ S (4) .
Revised: S (1) ∼ S (4) .

Original: Since ResNet-34 gives side outputs of down-sized scale, we pass the original image through bottleneck block S (0) to extract local details in original scale.
Revised: Since ResNet-34 gives side outputs of down-sized scale, we pass the original image through bottleneck block S (0) to extract local details in original scale.

Original: In front of S (3) , we employ the Atrous Spatial Pyramid Pooling (ASPP) block of (Chen et al., 2017).
Revised: In front of S (3) , we employ the Atrous Spatial Pyramid Pooling (ASPP) block of (Chen et al., 2017).

Original: We have empirically found that locating ASPP there shows better performance.
Revised: We have empirically found that locating ASPP there shows better performance.

Original: In utilizing multi-scale features, we employ the predicted segmentation mask ˆ M from the segmentator where the j th pixel of ˆ M is the predicted probability from Eq. 3.
Revised: In utilizing multi-scale features, we employ the predicted segmentation mask ˆ M from the segmentator where the j th pixel of ˆ M is the predicted probability from Eq. 3.

Original: Note that we generate ˆ M based on the entire feature vectors and the prototypes instead of utilizing sub-vectors, since the splitwise metric learning is used only for regularizing the segmentation module.
Revised: Note that we generate ˆ M based on the entire feature vectors and the prototypes instead of utilizing sub-vectors, since the splitwise metric learning is used only for regularizing the segmentation module.

Original: For each layer l , ˆ M ( l ) denotes the segmentation mask upscaled to the corresponding feature size by bilinear interpolation.
Revised: For each layer l , ˆ M ( l ) denotes the segmentation mask upscaled to the corresponding feature size by bilinear interpolation.

Original: Using segmentation prediction mask ˆ M ( l ) , we generate attention map A ( l ) , as follows.
Revised: Using segmentation prediction mask ˆ M ( l ) , we generate attention map A ( l ) , as follows.

Original: First, the prediction with a value lower than threshold λ is rounded down to zero, to ignore activation in re- gions with low conﬁdence.
Revised: First, the prediction with a value lower than threshold λ is rounded down to zero, to ignore activation in re- gions with low conﬁdence.

Original: Second, we broaden the attention map using morphological dilation of (Feng et al., 2019) as a second chance, since the segmentation module may not always guarantee ﬁne results.
Revised: Second, we broaden the attention map using morphological dilation of (Feng et al., 2019) as a second chance, since the segmentation module may not always guarantee ﬁne results.

Original: The ﬁnal attention map of l th layer A ( l ) is computed as follows
Revised: The ﬁnal attention map of l th layer A ( l ) is computed as follows

Original: [Equation]
Revised: [Equation]

Original: where 1 ( ˆ M ( l ) > λ ) ˆ M ( l ) is the rounded value of prediction mask ˆ M ( l ) .
Revised: where 1 ( ˆ M ( l ) > λ ) ˆ M ( l ) is the rounded value of prediction mask ˆ M ( l ) .

Original: The attention maps are applied to the multi-scale features of corresponding bottleneck blocks S (0) ∼ S (4) .
Revised: The attention maps are applied to the multi-scale features of corresponding bottleneck blocks S (0) ∼ S (4) .

Original: We apply the  residual attention of (Hou et al., 2019), where the initial multi-level side outputs from S ( l ) are pixelwisely weighted by 1+ A ( l ) , to strengthen the activation value of the semantically important region.
Revised: We apply the [Figure] residual attention of (Hou et al., 2019), where the initial multi-level side outputs from S ( l ) are pixelwisely weighted by 1+ A ( l ) , to strengthen the activation value of the semantically important region.

Original: We visualize the effect of semantic attention in Fig.
Revised: We visualize the effect of semantic attention in Fig.

Original: [Figure]

Original: As shown in Fig.
Revised: As shown in Fig.

Original: 2, the decoder network is composed of ﬁve consecutive convolutional blocks.
Revised: 2, the decoder network is composed of ﬁve consecutive convolutional blocks.

Original: Each decoder block D ( l ) contains three 3 × 3 convolution layers.
Revised: Each decoder block D ( l ) contains three 3 × 3 convolution layers.

Original: The outputs of decoder blocks
Revised: The outputs of decoder blocks

Original: D (1) ∼ D (4) are bilinearly upsampled by two and passed to the next block.
Revised: D (1) ∼ D (4) are bilinearly upsampled by two and passed to the next block.

Original: Similar to (Feng et al., 2019), the up-sampled decoder outputs are then concatenated to the skip connection features from bottleneck blocks S (0) ∼ S (4) and previous decoder blocks.
Revised: Similar to (Feng et al., 2019), the up-sampled decoder outputs are then concatenated to the skip connection features from bottleneck blocks S (0) ∼ S (4) and previous decoder blocks.

Original: Multi-scale semantic information and local details are transmitted through skip architectures.
Revised: Multi-scale semantic information and local details are transmitted through skip architectures.

Original: The hierarchical decoder network in turn reﬁnes the outputs of the previous decoder blocks and ﬁnally produces the edge prediction ˆ y qi of query samples x qi .
Revised: The hierarchical decoder network in turn reﬁnes the outputs of the previous decoder blocks and ﬁnally produces the edge prediction ˆ y qi of query samples x qi .

Original: Following the work of (Deng et al., 2018), we combine cross-entropy loss and Dice loss to produce crisp boundaries.
Revised: Following the work of (Deng et al., 2018), we combine cross-entropy loss and Dice loss to produce crisp boundaries.

Original: Given a query set Q = { x qi , y qi } N q
Revised: Given a query set Q = { x qi , y qi } N q

Original: i
Revised: i

Original: =1 and prediction mask ˆ y qi , the cross-entropy loss is computed as
Revised: =1 and prediction mask ˆ y qi , the cross-entropy loss is computed as

Original: [Equation]
Revised: [Equation]

Original:  where Y + and Y − denote the sets of foreground and background pixels.
Revised: 8) where Y + and Y − denote the sets of foreground and background pixels.

Original: The Dice loss is then computed as
Revised: The Dice loss is then computed as

Original: [Equation]
Revised: [Equation]

Original: where j denotes the pixels of a label.
Revised: where j denotes the pixels of a label.

Original: The ﬁnal loss for meta-training is given by
Revised: The ﬁnal loss for meta-training is given by

Original: [Equation]
Revised: [Equation]

Original:  E XPERIMENTS 5. D ATASETS 5.1. SBD- 5 i
Revised:  E XPERIMENTS 5. D ATASETS 5.1. SBD- 5 i

Original: Based on the SBD dataset of (Hariharan et al., 2011) for semantic edge detection, we propose a new SBD- 5 i dataset.
Revised: Based on the SBD dataset of (Hariharan et al., 2011) for semantic edge detection, we propose a new SBD- 5 i dataset.

Original: With reference to the setting of Pascal- 5 i , 20 classes of the SBD dataset are divided into 4 splits.
Revised: With reference to the setting of Pascal- 5 i , 20 classes of the SBD dataset are divided into 4 splits.

Original: In the experiment with split i , 5 classes in the i th split are used as test classes C test .
Revised: In the experiment with split i , 5 classes in the i th split are used as test classes C test .

Original: The remaining 15 classes are utilized as training classes C train .
Revised: The remaining 15 classes are utilized as training classes C train .

Original: The training set
Revised: The training set

Original: D train is constructed with all image-annotation pairs whose annotation include at least one pixel from the classes in C train .
Revised: D train is constructed with all image-annotation pairs whose annotation include at least one pixel from the classes in C train .

Original: For each class, the boundary pixels which do not belong to that class are considered as background.
Revised: For each class, the boundary pixels which do not belong to that class are considered as background.

Original: The test set D test is also constructed in the same way as D train , using
Revised: The test set D test is also constructed in the same way as D train , using

Original: C test this time.
Revised: C test this time.

Original: Considering the difﬁculty of few-shot setting and severe annotation noise of the
Revised: Considering the difﬁculty of few-shot setting and severe annotation noise of the

Original: SBD dataset, we extract thicker edges.
Revised: SBD dataset, we extract thicker edges.

Original: We utilize edges extracted from the segmentation mask as ground truth instead of original boundary labels of the SBD dataset, and thickness of extracted edge lies between 3 ∼ 4 pixels on average.
Revised: We utilize edges extracted from the segmentation mask as ground truth instead of original boundary labels of the SBD dataset, and thickness of extracted edge lies between 3 ∼ 4 pixels on average.

Original: We conduct 4 experiments with each split of i = 0 ∼ 3 , and report performance of each split as well as the averaged performance.
Revised: We conduct 4 experiments with each split of i = 0 ∼ 3 , and report performance of each split as well as the averaged performance.

Original: Note that unlike Pascal- 5 i , we do not consider division of training and test samples of the original SBD dataset.
Revised: Note that unlike Pascal- 5 i , we do not consider division of training and test samples of the original SBD dataset.

Original: As a result, the images in D train might appear in D test with different annotation from class in C test .
Revised: As a result, the images in D train might appear in D test with different annotation from class in C test .

Original: 5.1. FSE- 
Revised: 5.1. FSE-

Original: The datasets used in previous semantic edge detection research such as SBD of (Hariharan et al., 2011) and Cityscapes of (Cordts et al., 2016) are not suitable for few-shot learning as they have only 20 and 30 classes, respectively.
Revised: The datasets used in previous semantic edge detection research such as SBD of (Hariharan et al., 2011) and Cityscapes of (Cordts et al., 2016) are not suitable for few-shot learning as they have only 20 and 30 classes, respectively.

Original: We propose a new dataset for few-shot edge detection, which we call FSE-1000, based on FSS-1000 of (Wei et al., 2019).
Revised: We propose a new dataset for few-shot edge detection, which we call FSE-1000, based on FSS-1000 of (Wei et al., 2019).

Original: FSS-1000 is a dataset for few-shot segmentation and composed of 1000 classes and 10 images per class with foreground-background segmentation annotation.
Revised: FSS-1000 is a dataset for few-shot segmentation and composed of 1000 classes and 10 images per class with foreground-background segmentation annotation.

Original: From the images and segmentation masks of FSS-1000, we build FSE1000 by extracting boundary labels from segmentation masks.
Revised: From the images and segmentation masks of FSS-1000, we build FSE1000 by extracting boundary labels from segmentation masks.

Original: As done in SBD- 5 i , we extract thick edges of which thickness is around 2 ∼ 3 pixels on average in the light of difﬁculty associated with few-shot setting.
Revised: As done in SBD- 5 i , we extract thick edges of which thickness is around 2 ∼ 3 pixels on average in the light of difﬁculty associated with few-shot setting.

Original: For dataset split, we split 1000 classes into 800 training classes and 200 test classes.
Revised: For dataset split, we split 1000 classes into 800 training classes and 200 test classes.

Original: We will provide the detailed class conﬁguration in the Supplementary Material.
Revised: We will provide the detailed class conﬁguration in the Supplementary Material.

Original: 5. E VALUATION S ETTINGS
Revised: 5. E VALUATION S ETTINGS

Original: We use two evaluation metrics to measure the few-shot semantic edge detection performance of our approach: the Average Precision (AP) and the maximum F-measure (MF) at optimal dataset scale (ODS).
Revised: We use two evaluation metrics to measure the few-shot semantic edge detection performance of our approach: the Average Precision (AP) and the maximum F-measure (MF) at optimal dataset scale (ODS).

Original: In evaluation, we compare the unthinned raw prediction results and the ground truths without Non-Maximum Suppression (NMS) following (Acuna et al., 2019; Yu et al., 2018b).
Revised: In evaluation, we compare the unthinned raw prediction results and the ground truths without Non-Maximum Suppression (NMS) following (Acuna et al., 2019; Yu et al., 2018b).

Original: For the evaluation of edge detection, an important parameter is matching distance tolerance which is an error threshold between the prediction result and the ground truth.
Revised: For the evaluation of edge detection, an important parameter is matching distance tolerance which is an error threshold between the prediction result and the ground truth.

Original: Prior works on edge detection such as (Acuna et al., 2019; Hariharan et al., 2011; Yu et al., 2017; 2018b) adopt non-zero distance tolerance to resolve the annotation noise.
Revised: Prior works on edge detection such as (Acuna et al., 2019; Hariharan et al., 2011; Yu et al., 2017; 2018b) adopt non-zero distance tolerance to resolve the annotation noise.

Original: However, the proposed datasets for few-shot edge detection utilize thicker boundaries to overcome the annotation noise issue instead of adopting distance tolerance.
Revised: However, the proposed datasets for few-shot edge detection utilize thicker boundaries to overcome the annotation noise issue instead of adopting distance tolerance.

Original: Moreover, evaluation with non-zero distance tolerance requires additional heavy computation.
Revised: Moreover, evaluation with non-zero distance tolerance requires additional heavy computation.

Original: This becomes more problematic under few-shot setting where the performance should be measured on the same test image multiple times due to the variation in the support set.
Revised: This becomes more problematic under few-shot setting where the performance should be measured on the same test image multiple times due to the variation in the support set.

Original: For these reasons, we set distance tolerance to be 0 for both FSE-1000 and SBD- 5 i .
Revised: For these reasons, we set distance tolerance to be 0 for both FSE-1000 and SBD- 5 i .

Original: In addition, we evaluate the positive predictions from the area inside an object and zero-padded region as false positives, which is stricter than the evaluation protocol in prior works of (Hariharan et al., 2011; Yu et al., 2017).
Revised: In addition, we evaluate the positive predictions from the area inside an object and zero-padded region as false positives, which is stricter than the evaluation protocol in prior works of (Hariharan et al., 2011; Yu et al., 2017).

Original: 5. I MPLEMENTATION D ETAIL
Revised: 5. I MPLEMENTATION D ETAIL

Original: We implement our framework using Pytorch library and adopt Scikit-learn library to construct the precision-recall curve and compute average precision (AP).
Revised: We implement our framework using Pytorch library and adopt Scikit-learn library to construct the precision-recall curve and compute average precision (AP).

Original: For the encoder, ResNet-34 pretrained on ImageNet is adopted.
Revised: For the encoder, ResNet-34 pretrained on ImageNet is adopted.

Original: All parameters except the encoder parameters are learned from scratch.
Revised: All parameters except the encoder parameters are learned from scratch.

Original: The entire network is trained using the Adam optimizer of (Kingma & Ba, 2014) with weight decay regularization of (Loshchilov & Hutter, 2017).
Revised: The entire network is trained using the Adam optimizer of (Kingma & Ba, 2014) with weight decay regularization of (Loshchilov & Hutter, 2017).

Original: In both experiments on FSE-1000 and SBD- 5 i , we use a learning rate of 10 − 4 and an l 2 weight decay rate of 10 − 2 .
Revised: In both experiments on FSE-1000 and SBD- 5 i , we use a learning rate of 10 − 4 and an l 2 weight decay rate of 10 − 2 .

Original: For FSE-1000 experiments, the model is trained with 40,000 episodes and the learning rate is decayed by 0.1 after training 38, episodes.
Revised: For FSE-1000 experiments, the model is trained with 40,000 episodes and the learning rate is decayed by 0.1 after training 38, episodes.

Original: For SBD- 5 i experiments, 30,000 episodes are used for training, and the learning rate is decayed by 0.1 after training 28,000 episodes.
Revised: For SBD- 5 i experiments, 30,000 episodes are used for training, and the learning rate is decayed by 0.1 after training 28,000 episodes.

Original: Higher shot training of (Liu et al., 2019) is employed in 1-shot experiments for both datasets.
Revised: Higher shot training of (Liu et al., 2019) is employed in 1-shot experiments for both datasets.

Original: 5.3. D ATA PREPROCESSING
Revised: 5.3. D ATA PREPROCESSING

Original: During training, we adopt data augmentation with random rotation by multiples of 90 degrees for both SBD- 5 i and FSE-1000.
Revised: During training, we adopt data augmentation with random rotation by multiples of 90 degrees for both SBD- 5 i and FSE-1000.

Original: We additionally resize SBD- 5 i data to 320 × 320, while no such resizing is performed on FSE-1000.
Revised: We additionally resize SBD- 5 i data to 320 × 320, while no such resizing is performed on FSE-1000.

Original: During evaluation, images of SBD- 5 i are zero-padded to 512 × 512.
Revised: During evaluation, images of SBD- 5 i are zero-padded to 512 × 512.

Original: Again, the original image size is used for FSE-1000.
Revised: Again, the original image size is used for FSE-1000.

Original: 5. E XPERIMENT R ESULT
Revised: 5. E XPERIMENT R ESULT

Original: Table 1 shows the experiment results on the SBD- 5 i dataset.
Revised: Table 1 shows the experiment results on the SBD- 5 i dataset.

Original: To verify the value of the proposed method, we compare CAFENet with two baselines.
Revised: To verify the value of the proposed method, we compare CAFENet with two baselines.

Original: The ﬁrst baseline is a ﬁne-tuned edge detection model with only a few labeled samples.
Revised: The ﬁrst baseline is a ﬁne-tuned edge detection model with only a few labeled samples.

Original: Meta-learning strategy is not used for the ﬁrst baseline.
Revised: Meta-learning strategy is not used for the ﬁrst baseline.

Original: We employ the DFF of (Hu et al., 2019), utilizing the implementation offered by the authors.
Revised: We employ the DFF of (Hu et al., 2019), utilizing the implementation offered by the authors.

Original: For each split of SBD- 5 i , we pretrain a 15-way semantic edge detector with training classes and ﬁnetune the pretrained edge detector with a few labeled samples for new classes in test split.
Revised: For each split of SBD- 5 i , we pretrain a 15-way semantic edge detector with training classes and ﬁnetune the pretrained edge detector with a few labeled samples for new classes in test split.

Original: During pretraining, we follow the training strategies and hyperparameters of (Hu et al., 2019).
Revised: During pretraining, we follow the training strategies and hyperparameters of (Hu et al., 2019).

Original: In ﬁnetuning, we randomly initialize some sub-modules that are closely related to ﬁnal prediction (”side5”, ”side5-w”, and ”ada-learner”) and train them altogether using the support images.
Revised: In ﬁnetuning, we randomly initialize some sub-modules that are closely related to ﬁnal prediction (”side5”, ”side5-w”, and ”ada-learner”) and train them altogether using the support images.

Original: The second baseline is constructed by combining a non-parametric edge detectors such as Canny detector or Sobel detector with a few-shot segmentation algorithm.
Revised: The second baseline is constructed by combining a non-parametric edge detectors such as Canny detector or Sobel detector with a few-shot segmentation algorithm.

Original: The semantic edge detection is occasionally interpreted as a dual task of semantic segmentation, but prior work of (Acuna et al., 2019) veriﬁes that the semantic edge detector outperforms the segmentator combined with the Sobel edge detector, and demonstrates the importance of semantic edge detection.
Revised: The semantic edge detection is occasionally interpreted as a dual task of semantic segmentation, but prior work of (Acuna et al., 2019) veriﬁes that the semantic edge detector outperforms the segmentator combined with the Sobel edge detector, and demonstrates the importance of semantic edge detection.

Original: In our experiments, we combine PANet and PMM, the state-of-the-art few-shot segmentation method, with the Sobel edge detector.
Revised: In our experiments, we combine PANet and PMM, the state-of-the-art few-shot segmentation method, with the Sobel edge detector.

Original: To experiment with existing segmentation methods, we utilize the implementation provided by the authors.
Revised: To experiment with existing segmentation methods, we utilize the implementation provided by the authors.

Original: For each split of SBD- 5 i , we meta-train the PANet and PMM on training classes using the segmentation labels.
Revised: For each split of SBD- 5 i , we meta-train the PANet and PMM on training classes using the segmentation labels.

Original: In evaluation, we obtain the edge predictions of test classes by applying the Sobel edge detector on the segmentation masks as done in (Acuna et al., 2019), and compare the predictions with the edge labels of test classes.
Revised: In evaluation, we obtain the edge predictions of test classes by applying the Sobel edge detector on the segmentation masks as done in (Acuna et al., 2019), and compare the predictions with the edge labels of test classes.

Original: We utilize the ResNet-34 backbone for CAFENet and PANet.
Revised: We utilize the ResNet-34 backbone for CAFENet and PANet.

Original: For PMM, we utilize ResNetbackbone.
Revised: For PMM, we utilize ResNetbackbone.

Original: We also employ higher shot training in 1-shot experiments for both baselines as done in CAFENet experiments.
Revised: We also employ higher shot training in 1-shot experiments for both baselines as done in CAFENet experiments.

Original: The results in Table 1 show that the proposed CAFENet outperforms all baselines in both MF and AP scores by signiﬁcant margin.
Revised: The results in Table 1 show that the proposed CAFENet outperforms all baselines in both MF and AP scores by signiﬁcant margin.

Original: The experiment results prove that the few-shot semantic edge detector can not be simply substituted by few-shot segmentator or the ﬁne-tuned semantic edge detector.
Revised: The experiment results prove that the few-shot semantic edge detector can not be simply substituted by few-shot segmentator or the ﬁne-tuned semantic edge detector.

Original: In Table 2, the experiment results on the FSE-1000 dataset are shown.
Revised: In Table 2, the experiment results on the FSE-1000 dataset are shown.

Original: For FSE-1000, we only experiment with the few-shot segmentation baseline since it is hard to train a semantic edge detector with training set of FSE-1000, due to the large number of training classes.
Revised: For FSE-1000, we only experiment with the few-shot segmentation baseline since it is hard to train a semantic edge detector with training set of FSE-1000, due to the large number of training classes.

Original: We can see that the proposed CAFENet outperforms the baseline even when the dataset contains more diverse classes.
Revised: We can see that the proposed CAFENet outperforms the baseline even when the dataset contains more diverse classes.

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

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: In this paper, we establish the few-shot semantic edge detection problem.
Revised: In this paper we establish the few-shot semantic edge detection problem.

Original: We proposed the ClassAgnostic Few-shot Edge detector (CAFENet) based on a skip architecture utilizing multi-scale features.
Revised: We proposed the ClassAgnostic Few-shot Edge detector (CAFENet) based on a skip architecture utilizing multi-scale features.

Original: To compensate the shortage of semantic information in edge labels, CAFENet employs a segmentation module in low resolution and utilizes segmentation masks to generate attention maps.
Revised: To compensate the shortage of semantic information in edge labels, CAFENet employs a segmentation module in low resolution and utilizes segmentation masks to generate attention maps.

Original: The attention maps are applied to multi-scale skip connection to localize the semantically related region.
Revised: The attention maps are applied to multi-scale skip connection to localize the semantically related region.

Original: We also present the MSMR regularization method splitting the feature vectors and prototypes into several low-dimension sub-vectors and solving multiple metric-learning sub-problems with the sub-vectors.
Revised: We also present the MSMR regularization method splitting the feature vectors and prototypes into several low-dimension sub-vectors and solving multiple metric-learning sub-problems with the sub-vectors.

Original: We built two novel datasets of FSE-1000 and SBD- 5 i well-suited to few-shot semantic edge detection.
Revised: We built two novel datasets of FSE-1000 and SBD- 5 i well-suited to few-shot semantic edge detection.

Original: Experimental results demonstrate that the proposed method signiﬁcantly outperforms the baseline approaches relying on ﬁne-tuning or few-shot semantic segmentation.
Revised: Experimental results demonstrate that the proposed method signiﬁcantly outperforms the baseline approaches relying on ﬁne-tuning or few-shot semantic segmentation

Original: A A DDITIONAL E XPERIMENTAL S ETUP
Revised: A A DDITIONAL E XPERIMENTAL S ETUP

Original: In this section we provide detailed information about experimental setup.
Revised: In this section we provide detailed information about experimental setup.

Original: We adopt the ImageNet pretrained ResNet-34 with 64-128-256-512 channels for each residual block from [pytorch framework] as the encoder.
Revised: We adopt the ImageNet pretrained ResNet-34 with 64-128-256-512 channels for each residual block from [pytorch framework] as the encoder.

Original: To construct the skip architecture, we employ the bottleneck block of ResNet as the post-processing blocks S (1) ∼ S (4) .
Revised: To construct the skip architecture we employ the bottleneck block of ResNet as the post-processing blocks S (1) ∼ S (4) .

Original: Each bottleneck block consists of two 1x1 convolutional layers and one 3x3 convolutional layer with expansion rate of 4.
Revised: Each bottleneck block consists of two 1x1 convolutional layers and one 3x3 convolutional layer with expansion rate of 4.

Original: Dropout with the ratio of 0.25 is applied to the end of each bottleneck block.
Revised: Dropout with the ratio of 0.25 is applied to the end of each bottleneck block.

Original: For the ASPP Module in front of S (3) , we adopt the dilation rate of 1,4,7,11.
Revised: For the ASPP Module in front of S (3) , we adopt the dilation rate of 1,4,7,11.

Original: The segmentation module generates a segmentation prediction with the rounding threshold value λ of 0.4.
Revised: The segmentation module generates a segmentation prediction with the rounding threshold value λ of 0.4.

Original: For decoder, each decoder block is composed of three consecutive 3x3 convolutional layers and dropout with the ratio of 0.25 is again located at the end of each layer.
Revised: For decoder, each decoder block is composed of three consecutive 3x3 convolutional layers, and dropout with the ratio of 0.25 is again located at the end of each layer.

Original: During meta-training of CAFENet we set the number of query samples in training episodes to be 5 for FSE-1000 and 10 for SBD- 5 i , respectively.
Revised: During meta-training of CAFENet, we set the number of query samples in training episodes to be 5 for FSE-1000 and 10 for SBD- 5 i , respectively.

Original: In evaluation we employ average precision score function of Scikit-learn library to measure the Average Precision (AP) score.
Revised: In evaluation, we employ average precision score function of Scikit-learn library to measure the Average Precision (AP) score.

Original: We compute the AP score for each image and average them to measure the overall performance.
Revised: We compute the AP score for each image and average them to measure the overall performance.

Original: For Maximum Fmeasure (MF) score, we measure true positives (TP), false positives (FP) 
Revised: For Maximum Fmeasure (MF) score, we measure true positives (TP), false positives (FP) and false negatives (FN) at every 0.01 threshold intervals for each image, and accumulate the values for all images in 1000 test episodes. The MF score is computed using the accumulated TP, FP, and FN values.

Original: B A BLATION S TUDIES
Revised: B A BLATION S TUDIES

Original: In this section [Table] we shot the results of ablation experiments to examine the impact of proposed MSMR and attentive decoder.
Revised: In this section, we shot the results of ablation experiments to examine the impact of proposed MSMR and attentive decoder.

Original: Table B.1 shows the experiment results on the FSE-1000 dataset.
Revised: Table B.1 shows the experiment results on the FSE-1000 dataset.

Original: The baseline method in Table B.1 conducts edge prediction in low resolution and utilizes the auxiliary loss from low resolution together with the loss from the edge prediction in original resolution for metatraining.
Revised: The baseline method in Table B.1 conducts edge prediction in low resolution and utilizes the auxiliary loss from low resolution together with the loss from the edge prediction in original resolution for metatraining.

Original: The edge prediction is done using a metric-based method utilizing prototypes which are computed using down-sampled edge labels.
Revised: The edge prediction is done using a metric-based method utilizing prototypes which are computed using down-sampled edge labels.

Original: The method dubbed as Seg utilizes a segmentation module without MSMR or attentive decoding.
Revised: The method dubbed as Seg utilizes a segmentation module without MSMR or attentive decoding.

Original: Seg directly matches high-dimensional query feature vectors with prototypes in both training and evaluation.
Revised: Seg directly matches high-dimensional query feature vectors with prototypes in both training and evaluation.

Original: In Seg , the segmentation module is utilized only to provide the segmentation loss that assists for model learning to extract semantic features.
Revised: In Seg , the segmentation module is utilized only to provide the segmentation loss that assists for model learning to extract semantic features.

Original: Seg + Att employs the predicted segmentation mask for the additional attention process in skip architecture.
Revised: Seg + Att employs the predicted segmentation mask for the additional attention process in skip architecture.

Original: Seg + MSMR + Att additionally utilizes the MSMR regularization for training.
Revised: Seg + MSMR + Att additionally utilizes the MSMR regularization for training.

Original: For fair comparison, all methods use the same network architecture and training hyperparameters.
Revised: For fair comparison, all methods use the same network architecture and training hyperparameters.

Original: For
Revised: For

Original: SBD- 5 i datasets, the ablation experiments are done with same model variations as FSE-1000.
Revised: SBD- 5 i datasets, the ablation experiments are done with same model variations as FSE-1000.

Original: The results on SBD- 5 i are shown in Table B.2.
Revised: The results on SBD- 5 i are shown in Table B.2.

Original: [Table]
Revised: [Table]

Original: Tables B.1 and B.2 demonstrate that the use of the segmentation module in Seg gives signiﬁcant performance advantages over baseline for both FSE-1000 and SBD- 5 i datasets.
Revised: Tables B.1 and B.2 demonstrate that the use of the segmentation module in Seg gives signiﬁcant performance advantages over baseline for both FSE-1000 and SBD- 5 i datasets.

Original: It is also seen that the additional use of attentive decoding, Seg + Att , generally improves the performance over Seg .
Revised: It is also seen that the additional use of attentive decoding, Seg + Att , generally improves the performance over Seg .

Original: Finally, adding the effect of MSMR regularization gives substantial extra gains, as seen by the scores associated with Seg + MSMR + Att .
Revised: Finally, adding the effect of MSMR regularization gives substantial extra gains, as seen by the scores associated with Seg + MSMR + Att .

Original: Clearly, when compared with baseline, our overall approach
Revised: Clearly, when compared with baseline, our overall approach

Original: Seg + MSMR + Att provides large gains.
Revised: Seg + MSMR + Att provides large gains.

Original: In the main paper, we report the results of Seg + MSMR + Att as the results of CAFENet.
Revised: In the main paper, we report the results of Seg + MSMR + Att as the results of CAFENet.

Original: B. A DDITIONAL E XPERIMENTS ON M ULTI -S PLIT M ATCHING R EGULARIZATION B.1. F EATURE MATCHING METHOD FOR SEGMENTATION
Revised: B. A DDITIONAL E XPERIMENTS ON M ULTI -S PLIT M ATCHING R EGULARIZATION B.1. F EATURE MATCHING METHOD FOR SEGMENTATION

Original: In Table B.3, we have compared various feature matching methods between prototypes and query feature vectors for producing segmentation prediction on SBD- 5 i .
Revised: In Table B.3, we have compared various feature matching methods between prototypes and query feature vectors for producing segmentation prediction on SBD- 5 i .

Original: The method baseline refers to the original method generating segmentation prediction using only the similarity metric between high-dimensional vectors as done in Eq.
Revised: The method baseline refers to the original method generating segmentation prediction using only the similarity metric between high-dimensional vectors as done in Eq.

Original: For the method average , segmentation predictions from low-dimensional feature splits (Eq. 5) and original high-dimensional feature vectors (Eq. 5) are averaged to generate the ﬁnal prediction mask.
Revised: For the method average , segmentation predictions from low-dimensional feature splits (Eq. 5) and original high-dimensional feature vectors (Eq. 5) are averaged to generate the ﬁnal prediction mask.

Original: The average method can be understood as a method  utilizing MSMR not only for regularization, but also for inference.
Revised: The average method can be understood as a method [Table] utilizing MSMR not only for regularization [Table]

Revised: but also for inference.

Original: In the weighted sum method, the above ﬁve segmentation masks are combined using a weighted sum with learnable weights.
Revised: In the weighted sum method [Table] the above ﬁve segmentation masks are combined using a weighted sum with learnable weights.

Original: As we can see in Table B.3, the MSMR method shows the best performance when employed for regularization. 
Revised: As we can see in Table B. [Table] the MSMR method shows the best performance when employed for regularization. [Table]

Original: B.1. N UMBER OF VECTOR SPLITS
Revised: B.1. N UMBER OF VECTOR SPLITS

Original: MSMR divides the high-dimensional feature into multiple splits.
Revised: MSMR divides the high-dimensional feature into multiple splits.

Original: Table B.4 shows the performance of proposed CAFENet with varying numbers of splits K .
Revised: Table B.4 shows the performance of proposed CAFENet with varying numbers of splits K .

Original: Comparing the K = 1 case with other[Table] [Table] cases, we can see that applying MSMR regularization consistently improves performance.
Revised: Comparing the K = 1 case with other cases, we can see that applying MSMR regularization consistently improves performance.

Original: We can see that K = 4 results in the best AP and MF performance.
Revised: We can see that K = 4 results in the best AP and MF performance.

Original: The performance gain is marginal when we divide the embedding dimension into too small ( K = 16 ) or too big ( K = 2 ) a pieces.
Revised: The performance gain is marginal when we divide the embedding dimension into too small ( K = 16 ) or too big ( K = 2 ) a pieces.

Original: [Table]
Revised: [Table]

Original:  R ANDOM PROJECTION FOR VECTOR SPLITS
Revised: B.1. R ANDOM PROJECTION FOR VECTOR SPLITS

Original: In MSMR
Revised: In MSMR

Original: [Table]
Revised: [Table]

Original: we divide query feature into K splits along the channel dimension [Table] i [Table]
Revised: we divide query feature into K splits along the channel dimension, i.e. we apply deterministic splitting.

Original: e. we apply deterministic splitting.

Original: In Table B.
Revised: In Table B.

Original: [Table]
Revised: [Table]

Original: we compare the performance of different splitting methods.
Revised: we compare the performance of different splitting methods.

Original: The method dubbed as Deterministic refers the MSMR method that we utilize in CAFENet.
Revised: The method dubbed as Deterministic refers the MSMR method that we utilize in CAFENet.

Original: The Random method randomly splits feature vectors into 4 parts in each episode.
Revised: The Random method randomly splits feature vectors into 4 parts in each episode.

Original: The Baseline method does not split feature at all.
Revised: The Baseline method does not split feature at all.

Original: Interestingly, Random approach signiﬁcantly decreases the performance, even worse than the Baseline
Revised: Interestingly, Random approach signiﬁcantly decreases the performance, even worse than the Baseline

Original: [Table]
Revised: [Table]

Original: [Table]

Original: B.

Original: [Table]
Revised: [Table]

Original:  A DDITIONAL E XPERIMENTS ON S EMANTIC A TTENTION B.2. E XPERIMENTS ON A PPLYING THE S EMANTIC A TTENTION
Revised: B. A DDITIONAL E XPERIMENTS ON S EMANTIC A TTENTION B.2. E XPERIMENTS ON A PPLYING THE S EMANTIC A TTENTION

Original: In the proposed CAFENet [Table] we utilize the semantic attention in the attentive decoder.
Revised: In the proposed CAFENet, we utilize the semantic attention in the attentive decoder.

Original: In Table B. [Table] we compare three methods that utilize the attention in different manners.
Revised: In Table B.6, we compare three methods that utilize the attention in different manners.

Original: Attentive Decoding method is our proposed CAFENet that applies the semantic attention to the multi-scale features.
Revised: Attentive Decoding method is our proposed CAFENet that applies the semantic attention to the multi-scale features.

Original: The second method, Direct Attention is a method that directly pass the feature to edge detector and apply the semantic attention to the ﬁnal edge prediction.
Revised: The second method, Direct Attention is a method that directly pass the feature to edge detector and apply the semantic attention to the ﬁnal edge prediction.

Original: The last method, No Attention is a baseline where the edge detector generates prediction without any attention.
Revised: The last method, No Attention is a baseline where the edge detector generates prediction without any attention.

Original: For both 1-shot and 5-shot setting, regardless of how the attention is applied, semantic attention considerably improves performance.
Revised: For both 1-shot and 5-shot setting, regardless of how the attention is applied, semantic attention considerably improves performance.

Original: These results show the effectiveness of semantic attention.
Revised: These results show the effectiveness of semantic attention.

Original: The results also show that the proposed approach of Attentive Decoding yields better result compared to Direct Attention .[Table]
Revised: The results also show that the proposed approach of Attentive Decoding yields better result compared to Direct Attention .

Original: B.2. E XPERIMENTS ON G ENERATING THE A TTENTION
Revised: B.2. E XPERIMENTS ON G ENERATING THE A TTENTION

Original: In the proposed attentive decoding, we can generate attention map using various methods.
Revised: In the proposed attentive decoding, we can generate attention map using various methods.

Original: In Tabel.
Revised: In Ta- ble.

Original: B.7, we compare two different methods to generate attention map.
Revised: B.7, we compare two different methods to generate attention map.

Original: Segmentation Attention is the method adopted in proposed CAFENet.
Revised: Segmentation Attention is the method adopted in proposed CAFENet.

Original: In Segmentation Attention , the output of the segmentation module S is utilized as the ˆ M in equation 7.
Revised: In Segmentation Attention , the output of the segmentation module S is utilized as the ˆ M in equation 7.

Original: In Edge Attention , the edge prediction E ( S ) is generated from segmentation mask S by equation 11 following Feng et al.
Revised: In Edge Attention , the edge prediction E ( S ) is generated from segmentation mask S by equation 11 following Feng et al.

Original: The generated edge prediction E ( S ) is then used as the ˆ M in equation 7.
Revised: The generated edge prediction E ( S ) is then used as the ˆ M in equation 7.

Original: Experiment results show that utilizing the segmentation mask to generate attention map performs better than utilizing the edge prediction.
Revised: Experiment results show that utilizing the segmentation mask to generate attention map performs better than utilizing the edge prediction.

Original: [Equation]
Revised: [Equation]

Revised: [Equation]

Revised: [Table]

Original: [Table]
Revised: [Table]

Original: C Q UALITATIVE R ESULTS
Revised: C Q UALITATIVE R ESULTS

Original: In Figures C.1 and C. [Table] we visualize the qualitative results of CAFENet for FSE-1000 and SBD5 i , respectively.
Revised: In Figures C.1 and C.2, we visualize the qualitative results of CAFENet for FSE-1000 and SBD5 i , respectively.

Original: We can see that the proposed CAFENet successfully detect the edge of the target class from given images.
Revised: We can see that the proposed CAFENet successfully detect the edge of the target class from given images.

Original: In Figure C.1, we can compare the qualitative results of edge predictions from different methods.
Revised: In Figure C.1, we can compare the qualitative results of edge predictions from different methods.

Original: We can see that the ’DFF + Finetune’ method succeeds in ﬁnding the edges of the objects, but it lacks the ability to learn semantic information and hardly distinguish the boundary of target class from the other boundaries.
Revised: We can see that the ’DFF + Finetune’ method succeeds in ﬁnding the edges of the objects, but it lacks the ability to learn semantic information and hardly distinguish the boundary of target class from the other boundaries.

Original: For ’PANet + Sobel’ method, on the other hand, it successfully understands the semantic information and localizes the target object, but it fails to reﬁne the correct boundary.
Revised: For ’PANet + Sobel’ method, on the other hand, it successfully understands the semantic information and localizes the target object, but it fails to reﬁne the correct boundary.

Original: The proposed CAFENet, however, is capable of localizing the objects from target class and detecting the correct boundary at the same time.
Revised: The proposed CAFENet, however, is capable of localizing the objects from target class and detecting the correct boundary at the same time.

Original: Figure C.3 visualizes more qualitative results on SBD- 5 i from ablation experiments.
Revised: Figure C.3 visualizes more qualitative results on SBD- 5 i from ablation experiments.

Original: We illustrate and compare the boundary prediction results of the baseline, Seg , Seg + Att , and Seg + Att +
Revised: We illustrate and compare the boundary prediction results of the baseline, Seg , Seg + Att , and Seg + Att +

Original: MSMR methods.
Revised: MSMR methods.

Original: For fair comparison, all methods share the same support set.
Revised: For fair comparison, all methods share the same support set.

Original: From the results, we can clearly see that the techniques proposed in CAFENet steadily improve the quality of edge prediction. 
Revised: From the results, we can clearly see that the techniques proposed in CAFENet steadily improve the quality of edge prediction. [Figure]

Original: D L ABEL G ENERATOR D. E DGE L ABEL G ENERATOR
Revised: D L ABEL G ENERATOR D. E DGE L ABEL G ENERATOR

Original: Algorithm D.1 generates the edge labels from the segmentation labels.
Revised: Algorithm D.1 generates the edge labels from the segmentation labels.

Original: The edge label generator ﬁnds the regions where the pixel value of segmentation label drastically changes, and determine the pixels in the regions as the boundary.
Revised: The edge label generator ﬁnds the regions where the pixel value of segmentation label drastically changes, and determine the pixels in the regions as the boundary.

Original: Note that the pixels at the border of the image are also determined as the boundary. 
Revised: Note that the pixels at the border of the image are also determined as the boundary. [Figure]

Original: D. S EGMENTATION L ABEL G ENERATOR
Revised: D. S EGMENTATION L ABEL G ENERATOR

Original: Algorithm D.2 is the segmentation label generator which generates the segmentation label from the edge label.
Revised: Algorithm D.2 is the segmentation label generator which generates the segmentation label from the edge label.

Original: Before the label generation, the pixels are divided into several groups based on boundary labels.
Revised: Before the label generation, the pixels are divided into several groups based on boundary labels.

Original: We employ the Breadth-First Search (BFS) algorithm and divide pixels into groups { G 1 , G 2 , ..., G n } .
Revised: We employ the Breadth-First Search (BFS) algorithm and divide pixels into groups { G 1 , G 2 , ..., G n } .

Original: The segmentation label generator of Algorithm D.2 classiﬁes these groups into[Figure] foreground and background.
Revised: The segmentation label generator of Algorithm D.2 classiﬁes these groups into foreground and background.

Original: First, the algorithm sweeps each column and row to count the number of pixel value change in edge label.
Revised: First, the algorithm sweeps each column and row to count the number of pixel value change in edge label.

Original: If there are certain numbers of changes, the algorithm again sweeps the column or row and record the location of foreground pixels and mark the foreground pixels in the column or row in a matrix T .
Revised: If there are certain numbers of changes, the algorithm again sweeps the column or row and record the location of foreground pixels and mark the foreground pixels in the column or row in a matrix T .

Original: Based on pixel groups { G 1 , G 2 , ..., G n } , the marking results in T are then divided into pixel value groups { T 1 , T 2 , ..., T n } . 
Revised: Based on pixel groups { G 1 , G 2 , ..., G n } , the marking results in T are then divided into pixel value groups { T 1 , T 2 , ..., T n } . The probability that each [Figure]

Original: The probability that each group G i belongs to the foreground is calculated as the mean of pixel values T i .
Revised: Input: Segmentation label M of an image Output: Edge label y of an image. y ← 0 W × H (cid:46) Initialize y as zero matrix having same shape with M for ( h, w ) in (1 , 1) ,...,( H , W ) do (cid:46) H/W is height/width of the image if M h,w = 1 then for ( a, b ) =

Revised: (- r ,- r ),...,( r , r ) do (cid:46) radius r determines thickness of edge

Revised: if M h + a,w + b = 0 then y h,w ←(cid:46) 0 / 1 means non-edge/edge pixel, respectively break else if ( h + a < 0) or ( h + a > H ) or ( w + b < 0) or ( w + b > W ) then y h,w ← 1 break return y (cid:46) Return label annotation

Revised: [Figure]

Revised: group G i belongs to the foreground is calculated as the mean of pixel values T i .

Original: The groups with probability above the threshold λ are determined as the foreground groups, and the pixels belongs to foreground groups are marked as foreground pixels.
Revised: The groups with probability above the threshold λ are determined as the foreground groups, and the pixels belongs to foreground groups are marked as foreground pixels.

Original: We set the threshold value λ to be 20 / 255 .
Revised: We set the threshold value λ to be 20 / 255 .

Original: [Figure]
Revised: [Figure]

Original: E D ETAILS ON D ATASETS E. FSE- 
Revised: E D ETAILS ON D ATASETS E. FSE-

Original: We build FSE-1000 using an existing few-shot segmentation dataset, FSS-1000.
Revised: We build FSE-1000 using an existing few-shot segmentation dataset, FSS-1000.

Original: We extract the boundary labels from segmentation annotations using Algorithm D.1.
Revised: We extract the boundary labels from segmentation annotations using Algorithm D.1.

Original: The radius value r in Algorithm D.1 is set to 3 in FSE-1000.
Revised: The radius value r in Algorithm D.1 is set to 3 in FSE-1000.

Original: 1000 categories in FSE-1000 are split into 800 train classes and 200 test classes.
Revised: 1000 categories in FSE-1000 are split into 800 train classes and 200 test classes.

Original: For the detailed class conﬁguration, the reader may refer to our attachment on class conﬁguration.
Revised: For the detailed class conﬁguration, the reader may refer to our attachment on class conﬁguration.

Original: Figure D.1 visualizes the result of our edge extraction algorithm.[Figure]
Revised: Figure D.1 visualizes the result of our edge extraction algorithm.

Original: Input: Segmentation label M of an image

Original: Output: Edge label y of an image.

Original: y ← 0 W × H (cid:46)

Original: Initialize y as zero matrix having same shape with M for ( h, w ) in (1 , 1) ,...,( H , W ) do (cid:46) H/W is height/width of the image if M h,w = 1 then for ( a, b ) =

Original: (- r ,- r ),...,( r , r ) do (cid:46) radius r determines thickness of edge

Original: if M h + a,w + b = 0 then y h,w ←(cid:46) 0 / 1 means non-edge/edge pixel, respectively break else if ( h + a < 0) or ( h + a > H ) or ( w + b < 0) or ( w + b > W ) then y h,w ← 1 break return y (cid:46) Return label annotation

Original: [Figure]

Original: E. SBD- 5 i
Revised: E. SBD- 5 i

Original: SBD- 5 i is constructed based on the existing semantic edge detection dataset (SBD).
Revised: SBD- 5 i is constructed based on the existing semantic edge detection dataset (SBD).

Original: Due to the noise of boundary annotations in original SBD, we utilize the thicker edge as done in FSE-1000.
Revised: Due to the noise of boundary annotations in original SBD, we utilize the thicker edge as done in FSE-1000.

Original: To extract thicker edge, we generate the segmentation labels from the edge labels using Algorithm D. instead of using existing segmentation labels of SBD.
Revised: To extract thicker edge, we generate the segmentation labels from the edge labels using Algorithm D. instead of using existing segmentation labels of SBD.

Original: Figure D.2 shows the process of generating the segmentation label from the edge label.
Revised: Figure D.2 shows the process of generating the segmentation label from the edge label.

Original: From the generated segmentation labels, we extract edgelabels using Algorithm D.1 with a radius value of 4. This process allows us to train the proposed CAFENet using only the edge labels.
Revised: From the generated segmentation labels, we extract edge

Original: While all images in FSE-1000 have the same size, images in SBD- 5 i have different size.

Original: However, constructing the training episode as a mini-batch requires images with the same size.

Original: Previous works on semantic edge detection typically apply random cropping to deal with this issue.

Original: For the few-shot setting, however, random cropping severely degrades informativeness of support set and consequently hinders learning.

Original: Alternatively, we utilize the training examples resized to 320 ×to maintain the information of images as much as possible.

Original: When resizing the edge labels for training, we ﬁrst generate segmentation labels in original scale using Algorithm D.2 and resize the segmentation labels to 320 × 320 .

Original: Then, we extract edge labels from resized segmentation labels using Algorithm D.1 with a radius value of 3.

Original: F A DDITIONAL R ESULTS WITH M ULTI - ANGLE I NPUT T EST

Original: In this section, we report the few-shot semantic edge prediction results with multi-angle input test.

Original: In multi-angle input test, the model predicts the edge by averaging the 4 edge prediction results from 4 copies of an input image rotated by multiples of 90 degrees.

Original: We have empirically found that multiangle input test signiﬁcantly improves the performance.

Original: Table F.1 and F.2 show the evaluation results with multi-angle input test for FSE-1000 and SBD- 5 i , respectively.

Original: We can verify the effectiveness of the multi-angle input test from the results.

Original: Input: Edge label y of an image, pixel groups G 1 , G 2 , ..., G n
Revised: Input: Edge label y of an image, pixel groups G 1 , G 2 , ..., G n

Original: Output: Segmentation label M of an image.
Revised: Output: Segmentation label M of an image.

Original: M, T ← 0 W,H (cid:46)
Revised: M, T ← 0 W,H (cid:46)

Original: Initialize M, T as zero matrix having same shape with y for h = 1,..., H do (cid:46)H is height of the image cnt, mode ←for w = 1,..., W do (cid:46) W is width of the image if y h,w = mod ( mode + 1 , 2) then (cid:46) Accumulate changes of pixel value cnt ← cnt +mode ← mod ( mode + 1 , 2) if mod ( cnt, 4) = [-
-]
Revised: Initialize M, T as zero matrix having same shape with y for h = 1,..., H do (cid:46) height of the image cnt, mode ←for w = 1,..., W do (cid:46) W is width of the image if y h,w = mod ( mode + 1 , 2) then (cid:46) Accumulate changes of pixel value cnt ← cnt +mode ← mod ( mode + 1 , 2) if mod ( cnt, 4) = [-
-]0 and cnt (cid:54)

Original: and cnt (cid:54) = 

Revised: =

Original: then (cid:46) Check if there are FG pixels in the row cnt (cid:48) , mode (cid:48) ←for w (cid:48)
Revised: then (cid:46) Check if there are FG pixels in the row cnt (cid:48) , mode (cid:48) ←for w (cid:48)

Original: = 1,...,
Revised: = 1,...,

Original: W do (cid:46) Find location of FG pixels in the row if y h,w (cid:48)
Revised: W do (cid:46) Find location of FG pixels in the row if y h,w (cid:48)

Original: = mod ( mode (cid:48)
Revised: = mod ( mode (cid:48)

Original: + 1 , 2) then cnt (cid:48) ← cnt (cid:48)
Revised: + 1 , 2) then cnt (cid:48) ← cnt (cid:48)

Original: +mode (cid:48) ← mod ( mode (cid:48)
Revised: +mode (cid:48) ← mod ( mode (cid:48)

Original: + 1 , 2) if mod ( cnt (cid:48) , 4) =
Revised: + 1 , 2) if mod ( cnt (cid:48) , 4) =

Original: 2 then
Revised: 2 then

Original: T h,w (cid:48) ←(cid:46)
Revised: T h,w (cid:48) ←(cid:46)

Original: Record location of FG pixels in the row for w = 1,..., W do (cid:46)
Revised: Record location of FG pixels in the row for w = 1,..., W do (cid:46)

Original: Repeat the same process for every column cnt, mode ←for h
Revised: Repeat the same process for every column cnt, mode ←for h

Original: = 1,..., H do if y h,w = mod ( mode + 1 , 2) then cnt ← cnt +mode ← mod ( mode + 1 , 2) if mod ( cnt, 4) = 0 and cnt (cid:54) = 0 then cnt (cid:48) , mode (cid:48) ←for h (cid:48)
Revised: = 1,..., H do if y h,w = mod ( mode + 1 , 2) then cnt ← cnt +mode ← mod ( mode + 1 , 2) if mod ( cnt, 4) = 0 and cnt (cid:54) = 0 then cnt (cid:48) , mode (cid:48) ←for h (cid:48)

Original: = 1,..., H do if y h (cid:48) ,w = mod ( mode (cid:48)
Revised: = 1,..., H do if y h (cid:48) ,w = mod ( mode (cid:48)

Original: + 1 , 2) then cnt (cid:48) ← cnt (cid:48)
Revised: + 1 , 2) then cnt (cid:48) ← cnt (cid:48)

Original: +mode (cid:48) ← mod ( mode (cid:48)
Revised: +mode (cid:48) ← mod ( mode (cid:48)

Original: + 1 , 2) if mod ( cnt (cid:48) , 4) =
Revised: + 1 , 2) if mod ( cnt (cid:48) , 4) =

Original: 2 then
Revised: 2 then

Original: T h (cid:48) ,w ←for i = 1 , ..., n do
Revised: T h (cid:48) ,w ←for i = 1 , ..., n do

Original: T i ← T h,w | ( h,w ) ∈ G i if mean ( T i ) ≥ λ then (cid:46) Check the probability that G i belongs to foreground
Revised: T i ← T h,w | ( h,w ) ∈ G i if mean ( T i ) ≥ λ then (cid:46) Check the probability that G i belongs to foreground

Original: M h,w | ( h,w ) ∈
Revised: M h,w | ( h,w ) ∈

Original: G
Revised: G

Original: i ←(cid:46) 1 means a foreground pixel else
Revised: i ←(cid:46) 1 means a foreground pixel else

Original: M h,w | ( h,w ) ∈
Revised: M h,w | ( h,w ) ∈

Original: G i ←(cid:46) 0 means a background pixelreturn M (cid:46)
Revised: G i ←(cid:46) 0 means a background pixel

Original:  Return segmentation annotation 
Revised: return M (cid:46) Return segmentation annotation labels using Algorithm D.1 with a radius value of 4. This process allows us to train the proposed CAFENet using only the edge labels.

Revised: While all images in FSE-1000 have the same size, images in SBD- 5 i have different size.

Original: [Figure]
Revised: However, constructing the training episode as a mini-batch requires images with the same size. Previous works on semantic edge detection typically apply random cropping to deal with this issue. For the few-shot setting, however, random cropping severely degrades informativeness of support set and consequently hinders learning. Alternatively, we utilize the training examples resized to 320 ×to maintain the information of images as much as possible.

Revised: When resizing the edge labels for training, we ﬁrst generate segmentation labels in original scale using Algorithm D.2 and resize the segmentation labels to 320 × 320 .

Revised: Then, we extract edge labels from resized segmentation labels using Algorithm D.1 with a radius value of 3.

Revised: F A DDITIONAL R ESULTS WITH M ULTI - ANGLE I NPUT T EST

Revised: In this section

Original: [Table]
Revised: [Table]

Revised: we report the few-shot semantic edge prediction results with multi-angle input test.

Revised: In multi-angle input test

Original: [Table]
Revised: [Table]

Revised: the model predicts the edge by averaging the 4 edge prediction results from 4 copies of an input image rotated by multiples of 90 degrees.

Revised: We have empirically found that multiangle input test signiﬁcantly improves the performance.

Revised: Table F.1 and F.2 show the evaluation results with multi-angle input test for FSE-1000 and SBD- 5 i , respectively.

Revised: We can verify the effectiveness of the multi-angle input test from the results

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: Seg 27.

Revised: Seg

Revised: [Table]

Revised: Att 29.

Revised: Seg

Revised: [Table]

Revised: Att

Revised: [Table]

Revised: MSMR 31.