EvaNet: Elevation-Guided Flood Extent Mapping on Earth Imagery

1 Introduction

Climate change is drastically increasing the intensity and occurrence of floods [Matgen et al., 2020]. In just the last two decades, flooding has negatively impacted over 2.3 billion people, often disproportionately affecting vulnerable communities [Wahlstrom et al., 2015]. Therefore, accurate and timely mapping of flood extent can be crucial for effectively planning rescue and rehabilitation efforts [Oddo and Bolten, 2019]. However, sending field crews on site for inspection is prohibitively slow, while obtaining data from a limited number of groundwater sensors or UAVs cannot provide a global coverage. Therefore, we target the accurate and timely mapping of flood extent from high-resolution satellite imagery that provides a global coverage.

There has been a lot of research on using remote-sensing satellite imagery for flood extent mapping. Two commonly used satellite types are radar (active sensor) and optical (passive sensor). For example, Sentinel-1 [Copernicus, 2014] and Sentinel-2 [Copernicus, 2015] are radar and optical satellites, respectively, that produce high resolution earth imagery at high revisit times [Matgen et al., 2020]. Radar is more resilient to noises like clouds, but traditional approach to generating flood maps from radar imagery relies on semiautomated tools, [Rudner et al., 2019] or thresholding techniques [Fraccaro et al., 2022] that are slow and lack generalizability, often requiring expert intervention for parameter tuning. In this paper, we focus on the optical satellite imagery, since radar data such as that from Sentinel-1 [Copernicus, 2014] can also be converted into RGB channels [Fraccaro et al., 2022]. Moreover, both [Konapala et al., 2021] and [Bonafilia et al., 2020] found that using Sentinel-2 data only yields the best segmentation performance for deep learning models, as compared with when Sentinel-1 data is involved.

Thanks to the availability of digital elevation model (DEM) data from sources such as USGS, existing deep learning approaches use the elevation map to improve segmentation performance by treating the map simply as an additional input channel of U-Net [Ronneberger et al., 2015] just like a regular spectral channel [Beni and Gebrehiwot, 2021; Konapala et al., 2021; Fraccaro et al., 2022]. The physical law of gravity inherent to elevations as illustrated in Figure 1 (see its caption) is not encoded into the model design.

Encoding physical law in model design can help better recover the true states ("flooded" or "dry") of noisy pixels covered by clouds and tree canopies, which are often ambiguous just based on spectral features, and it has shown success in graphical models for flood mapping [Jiang and Sainju, 2019; Sainju et al., 2022; Sainju et al., 2020; Xie et al., 2018]. We propose to encode the physics-aware constraints into the more powerful deep learning models to achieve better performance.

Formally, given earth imagery with spectral features (e.g., RGB values) from optical satellites on a terrain surface (defined by an elevation map over a 2D grid), our goal is to conduct image segmentation so that each pixel (i.e., location) is classified as either "flooded" or "dry". In this paper, we propose an Elevation-guided Network (EvaNet) for flood extent mapping on earth imagery, which is physics-guided (c.f. Figure 1). Our main contributions are as follows:

• ÷ While a conventional loss function for image segmentation (e.g., pixel-wise cross-entropy loss LCE) is only computed from (i) ground-truth pixel labels and (ii) their predictions, we propose an elevation-guided regularization term Leva to penalize adjacent pixel-pairs that violate the physical law of gravity. Interestingly, we find that Leva alone can serve as a great loss function, not just as a regularization term.
• ÷ We extensively explored various approaches to integrating the elevation map as an input to the convolution operations on the encoder and decoder sides of U-Net, and find that using an independent convolution branch over the elevation map (called the elevation path) to regulate the flow of spectral features by the gated linear unit (GLU) [Dauphin et al., 2017] gives the best performance by striking a balance between model simplicity (to prevent overfitting) and model expressiveness.
• ÷ Extensive experiments verify that our both techniques above are effective, and that when being combined, achieve the best performance beating U-Net and other non-deep-learning methods by a large margin. Moreover, we show that EvaNet is an effective drop-in replacement for U-Net to improve deep learning, flood mapping methods that originally rely on U-Net as a basic component.

2 RelatedWork

Image Segmentation. Flood extent mapping is a semantic segmentation task, which classifies each pixel in an image into a semantic class (flood or dry in our problem). Besides semantic segmentation, there are other segmentation tasks such as instance segmentation [He et al., 2017] which finds the object pixels in the bounding box of an object detected by an object detection model, and panoptic segmentation [Kirillov et al., 2019] which combines semantic segmentation and instance segmentation.

Flood Extent Mapping by Deep Learning. A number of deep learning models for flood extent mapping have been explored by the remote sensing community recently. For example, [Beni and Gebrehiwot, 2021] first applies FCN [Long et al., 2015a] on only the RGB data to obtain an initial flood map (Stage 1); then the work uses water level data from USGS combined with the DEM data to detect water pixels under tree canopy, by using a method called region growing (Stage 2); the result from Stage 2 is then used to improve the FCN-based flood extent for vegetated areas (Stage 3). We remark that elevation data was not used in Stage 1, and our EvaNet can serve as a drop-in replacement of FCN to improve the performance of Stage 1.

As another example, [Konapala et al., 2021] uses spectral bands SWIR2, NIR and red values from Sentinel-2 to compute new indices as U-Net input, and DEM data is treated simply as an additional channel. Also, [Mateo-Garcia et al., 2021] focuses on the application of onboard segmentation with small, nano satellites to reduce revisit time to disaster areas; they input 13-band Sentinel-2 image into U-Net for segmentation without using DEM data. While these works from the remote sensing community include new input modes that can extend our work, our EvaNet targets the more fundamental problem of effectively integrating DEM data with spectral features guided by the physical law of gravity, and can serve as a drop-in replacement of their na¨ıve U-Net or FCN models to improve performance.

Non-Deep-Learning Methods. Hidden Markov tree (HMT) [Xie et al., 2018] is a state-of-the-art graphical model for flood extent mapping. HMT captures the directed spatial dependency based on flow directions across all locations by a reverse tree structure in the hidden class layer, which is similar to the hidden state sequence in hidden Markov models (HMM); spectral features are read out from the class state (dry or flooded) based on a learned multivariate Gaussian distribution. Later, hidden Markov contour tree (HMCT) [Jiang and Sainju, 2019] further captures complex contour structures on a 3D surface.

Both HMT and HMCT are for transductive learning where training samples are taken near the test region, or where a complete elevation map plus only limited spectral features in a target region are observed [Sainju et al., 2020]. More recently, inductive learning with HMT is explored with the help of U-Net. [Sainju et al., 2022] proposes to use the inference stage of HMCT only as a post-processor of U-Net to cleanse its predicted noisy posterior class probability at all the pixels. The resulting model is called HMCT-PP. Our EvaNet can also serve as a drop-in replacement of the U-Net in HMCT-PP.

Since the size of earth imagery on a terrain surface is often much larger than the input size of popular deep convolutional neural networks, segmentation is usually conducted on patches and the results are then stitched together. In contrast, HMT-based methods build a topological tree on the entire terrain surface so inference of the entire imagery is conducted together all at once. In HMCT-PP, the stitched U-Net predictions serve as the input to HMCT refinement.

Knowledge-Guided Machine Learning (KGML). Unlike our problem that focuses on the Earth imagery at one snapshot to quickly map out flood-inundated area for disaster response, KGML research is usually formulated as a forecast problem fitting historical data or fitting a simulation model (e.g., based on PDE), so requires many temporal snapshots. The goal of KGML is more on geosciences to study climate and environmental phenomena/process for future disaster warning and mitigation, often using meteorological factors such as air temperature, precipitation, and wind speed. We discuss the related works on KGML in our online appendix [Sami et al., 2024].

3 Method

In this section, we first formally define our problem and overview our techniques used in EvaNet. We then describe both techniques in detail.

Notations and Problem Definition. We regard each image as a 2D grid ⌦, and denote a pixel by p = (i↪ j), where i and j are the pixel coordinates in ⌦. We also denote the elevation of pixel p by h(p). Each pixel p has 8 adjacent pixels which constitute p's neighbor set, denoted by N(p). While pixels on the boundary of ⌦ do not have 8 neighbor pixels, we pad the input image and its elevation map using the reflection of the input boundary, to ensure that all p 2 ⌦ has 8 neighbors. We also use pn to denote an arbitrary neighbor of p, i.e., pn 2 N(p). We call (p↪ pn) as a pixel-pair, where p and pn are adjacent to each other in ⌦. Finally, we define

In Figure 1, we have ∆h(A↪ B) < 0 and ∆h(D↪ E) > 0.

The goal of flood extent mapping is to assign each pixel p 2 ⌦ a binary label indicating whether it is flooded or dry. Table 1 provides the list of notations used in this paper.

EvaNet Overview. Figure 2 overviews the architecture of EvaNet, where the encoder and decoder networks take not only the image but also the elevation map in convolution computation, which we will explain in section "ElevationRegulated Convolutions"; and where the loss function takes not only the predictions and the ground-truth annotation, but also the elevation map in the loss computation, which we will explain in section "Elevation-Guided Loss".

3.1 Elevation-Guided Loss

Given an input image of size W ⇥H, a flood segmentation model (U-Net or EvaNet) outputs a tensor of size W ⇥H ⇥2 with 2 channels: one is a dry score map sdry 2 RW⇥H , and the other is a flood score map sflood 2 RW⇥H , as illustrated in Figure 2. To compute the loss function, we apply pixelwise softmax where the probability that a pixel p is flooded

(resp. dry) is given by pflood(p) = esflood (p) esflood (p)+esdry (p) (resp. pdry(p) = esdry (p) esflood (p)+esdry (p) )1 . We define the ground-truth label of a pixel p as follows:

Note that a pixel may be unlabeled since it is covered by tree canopy. We provide domain experts with a 3D visualization tool where they can navigate the terrain surface by shifting and rotation, and where they can annotate the pixels using tools like 'brush' if they are confident of the pixel labels. Elevation-guided breadth-first search (BFS) [Adhikari et al., 2022] was adopted to speed up annotation, where (i) when an annotator marks an individual pixel p as flooded, the label propagates to nearby pixels with lower elevations by 'pitfilling' breadth-first search stopping when reaching pixels with elevation higher than h(p), and (ii) when an annotator marks an individual pixel p as dry, the label propagates to nearby pixels by 'hill-climbing' breadth-first search stopping when reaching pixels with elevation starting to drop. The labels of some pixels covered by tree canopy may be derived in this way from nearby pixels using the physical law of gravity.

U-Net uses only pixel-wise cross-entropy loss:

Elevation-Guided Regularization. However, LCE does not take the pixel elevations into consideration. To utilize the elevation map, we propose a regularization term Leva to penalize predictions that violate the physical constraints shown in Figure 1. Unlike LCE which is computed over individual pixels p, Leva is computed over individual pixel-pairs (p↪ pn):

where (i) w(p↪ pn) is a weight term indicating how much the pixel-pair (p↪ pn) is relevant to the physical constraints, and (ii) δ(p↪ pn) measures how much the label predictions of p and pn deviate from the physical constraints. We next explain the formulations of w(p↪ pn) and δ(p↪ pn).

Note that if a pixel p is unlabeled (i.e., gt(p) = 0), it has no term in the summation formulations of LCE and Leva, so it will not provide any supervision during training.

1 Alternatively, since our label is binary, one may let the segmentation model output only flood score map sflood, and compute pflood = sigmoid(sflood) and pdry = 1 - pflood. However, we find this formulation to be less numerically stable in PyTorch than using softmax.

Formulation of δ(p↪ pn). We define δ(p↪ pn) as follows, and we will explain its intuition soon:

where f(p) 2 (-1↪ 1) is defined as follows:

In other words, the higher confidence that our prediction is for p to be flooded (resp. dry), the closer f(p) is to 1 (resp. -1). An alternative definition that achieves this goal is to let the segmentation model output only a flood score map sf lood, and compute f(p) = tanh(sflood). However, we find this formulation less numerically stable in PyTorch.

Formulation of w(p↪ pn). We define w(p↪ pn) as follows, and we will explain its intuition soon:

where 1¶▷♦ is an indicator variable that equals 1 if the condition holds, and 0 otherwise. Note that only δ(p↪ pn) involves prediction since it uses f(p); in contrast, w(p↪ pn) is purely decided by gt(pn), h(p) and h(pn), i.e., annotations and elevations. Also note that if pn is unlabeled (i.e., gt(pn) = 0), then w(p↪ pn) = 0 so the term in the summation formulation of Leva in Eq (2) is 0, i.e., pixel-pair (p↪ pn) provides no supervision during training.

Intuition Behind the Formulations. We next provide the intuition of our formulations for δ(p↪ pn) and w(p↪ pn). We divide the possible scenarios for a pixel-pair (p↪ pn) into 5 cases shown in Figure 3, based on gt(pn) as the primary partitioning key and ∆h(p↪ pn) as the secondary key.

The physical constraints illustrated in Figure 1 correspond to 2 sub-cases in Figure 3: (1) Case 2.1 where we can derive that p should also be flooded, and (2) Case 3.1 where p should also be dry. Note that based on Eq (4), w(p↪ pn) = 1 for these 2 cases, and w(p↪ pn) = 0 for the other 3 cases where p can be either dry or flooded without violating any constraints. As a result, w(p↪ pn) in Eq (4) acts as a switch that is on only for those pixel-pairs (p↪ pn) that belong to Case 2.1 and Case 3.1, and excludes the other pixel-pairs when computing Leva using Eq (2). We call this weighting scheme given by Eq (4) as binary weighting.

Based on Eq (3), (1) δ(p↪ pn) = 1 - f(p) in Case 2.1, so if f(p) is close to 1 (i.e., predicted closer to be flooded) as aligned with the physical constraint, then δ(p↪ pn) is close to

0; while if f(p) is close to -1 (i.e., predicted closer to be dry) which violates the physical constraint, then δ(p↪ pn) is close to the supremum 2 so the penalty term in Leva is maximized. Also, (2) δ(p↪ pn) = 1 + f(p) in Case 3.1 by Eq (3), so if f(p) is close to -1 (i.e., predicted closer to be dry) as aligned with the physical constraint, then δ(p↪ pn) is close to 0; while if f (p) is close to 1 (i.e., predicted closer to be flooded) which violates the physical constraint, then δ(p↪ pn) is close to 2 to maximize the penalty term.

Figure 5 in our online appendix [Sami et al., 2024] shows the pixel distribution among the 5 cases on our datasets, where Cases 2.1 and 3.1 are dominating where the physical constraints apply, so we expect sufficient regularization.

Alternative Formulations of w(p↪ pn). The binary weighting scheme in Eq (4) only switches on the pixel-pairs satisfying Case 2.1 and Case 3.1, and treats their penalty terms as equally important. We also explored the adjustment of weights based on ♣∆h(p↪ pn)♣. The intuition is that, for example in Case 2.1, the higher pn is than p, the more penalty weight will be imposed if p is misclassified as dry.

Based on this idea, we define the elevation-difference weighting scheme as follows:

so that w(p↪ pn) = ♣∆h(p↪ pn)♣ for Cases 2.1 and 3.1, and 0 otherwise. We also explored a log-elevation-difference weighting scheme where w(p↪ pn) = log (1+♣∆h(p↪ pn)♣) for Cases 2.1 and 3.1, and 0 otherwise:

However, we find that these weighting schemes are not better than binary weighting. The results of comparison can be found in Table 7 of the appendix [Sami et al., 2024].

Implementing Leva. Recall that Eq (2) sums over pixel-pairs rather than individual pixels, but both the predicted score maps sflood and sdry and the ground-truth map gt are on pixels. Fortunately, PyTorch supports an "unfold" operation that can expand each pixel to include its local 3 ⇥ 3 pixelneighborhood. We utilize "unfold" to expand each pixel p in sflood, sdry and gt with its neighbors pn to facilitate the computation of w(p↪ pn) and ∆h(p↪ pn).

Loss Schemes. Since Leva is formulated as a regularization term that penalizes pixel-pairs (p↪ pn) in Cases 2.1 and 3.1 based on how much the label prediction of p violates the physical constraints, a natural loss function is given by

where hyperparameter λ balances the importance between LCE and Leva. U-Net simply uses L = LCE (i.e., λ = 0). By setting λ = 1, we obtain a representative hybrid loss L = LCE + Leva. Another extreme is using L = Leva (i.e., λ = 1), which could be a bit surprising since we exclude LCE and only use the regularization term to penalize the violation of physical constraints. Surprisingly, this last loss turns out to perform well in our experiments (c.f., Table 6 in our appendix [Sami et al., 2024]), probably because Cases 2.1 and 3.1 are well spread out on the entire terrain (c.f., Figure 5 in our appendix [Sami et al., 2024]). In other words, Leva by itself serves as a good loss function for flood mapping.

3.2 Elevation-Regulated Convolutions

Figure 4 shows the architecture of EvaNet's encoder-decoder network, where the encoder and decoder each consists of 3 convolution blocks, each with two novel elevation-regulated convolution (ERC) layers to be introduced soon.

EvaNet takes two inputs: (1) a 128⇥128 image patch and (2) the associated elevation map of the patch. Here, we partition a large high-resolution satellite image into 128 ⇥ 128 patches, since an entire satellite image is too large to input into any convolution neural network given the current GPU memory capacity. For this purpose, we pad each image on its boundary using the reflection mode, so that both the width and height of the padded image is divisible by 128. For example, for an 1856 ⇥ 4104 input image, we pad 32 pixels on the left and right boundaries, and pad 60 pixels on the upper and lower boundaries, giving a padded image of size 1920⇥4224 which gives 15 ⇥ 33 patches.

As Figure 4 shows, each convolution block consists of two ERC layers. Each ERC layer takes a spectral tensor (blue) X and an elevation-derived tensor (green) Xe, and outputs a regulated spectral tensor (purple) Y and a gated elevationderived tensor (yellow) Ye. Specifically, both inputs first pass through a 3⇥3 convolution, and the two resulting tensors are combined by gated linear unit (GLU) [Dauphin et al., 2017]: Ye = sigmoid(conv2d(Xe)), Y = conv2d(X) ⌦Ye↪ where conv2d(▷) is a 3 ⇥ 3 convolution with a 'replicate' padding mode, and ⌦ is element-wise product. The outputs (Y, Ye) then serve as the inputs to the next ERC layer.

Since neural networks take normalized inputs, we conduct min-max normalization of the elevations and input the normalized elevation patch to our encoder. Note that in contrast, raw elevations are used when we calculate w(p↪ pn) (using Eq (4), Eq (5) or Eq (6)) to compute Leva.

Intuitively, Ye 2 (0↪ 1)H⇥W⇥C serves as an elevationbased gate to control the flow of conv2d(X) to Y, and since Ye is computed from Xe with a 3 ⇥ 3 convolution, it is able to capture the local terrain topology. We choose GLU for elevation-based regulation since it is found to outperform other gating mechanisms in recent works [Wu et al., 2019; Hui et al., 2021b; Hui et al., 2021a]. We also tested other alternative gating mechanisms such as [Arevalo et al., 2017; Kim et al., 2018] and found GLU to perform the best. The related experiments are reported in Table 5 of our online appendix [Sami et al., 2024].

Also, we use 'replicate' padding for conv2d(▷) to ensure the quality of predictions on patch boundary. This is in contrast to zero padding, which we tested and found that the abrupt value drops at the patch boundary lead to poor prediction quality for pixels at the boundary.

As Figure 4 shows, at the encoder side, Y is downsampled using 2⇥2 max pooling which is commonly used for spectral tensors, and Ye is downsampled using 2 ⇥ 2 average pooling as a lower-resolution terrain approximation. We tried other pooling combinations but this setting gives the best predictions as demonstrated in Table 8 of the online appendix [Sami et al., 2024]. At the decoder side, we use 3⇥3 transpose convolution for both Y and Ye.

4 Experiments &Results

Data. We obtain high-resolution aerial imagery from NOAA National Geodetic Survey during Hurricane Matthew in North Carolina (NC) in 2016 [NOAA, 2016]. The accompanied DEM data are obtained from the University of North Carolina Libraries [NCSU, 2023]. Futhermore, to test if our models trained on the Matthew 2016 dataset can generalize to a different flooding event, we also obtained two more regions in Baytown, TX, and Richmond, TX during Hurricane Harvey in 2017 from [NOAA, 2017], and the corresponding DEM data was obtained from USGS data downloader [USGS, 2023]. The aerial imagery from both events are 0.3 m ⇥ 0.3 m in resolution, the DEM data for Matthew 2016 are 6 m ⇥ 6 m and for Harvey 2017 are 3 m ⇥ 3 m in resolution. We resampled them into a resolution of 2 m ⇥ 2 m, which is fine enough for the purpose of flood extent mapping. Table 2 shows the regions we used, where R1-R5 are from Matthew 2016, and R6-R7 is from Harvey 2017. While high-resolution Earth imagery and DEM data are abundant, the ground-truth flood maps need to be annotated by domain experts. So, we provide a 3D visualization tool to domain experts for annotating pixels.

In our online appendix [Sami et al., 2024], Figure 6 shows the imagery for Kinston, NC during Hurricane Matthew in 2016, its annotation where pixels are labeled as flooded or dry, and the normal-time imagery from Google Earth. We expect that inputting the normal-time image into a model is effective in helping identify flooded regions by providing a contrast. This is confirmed our experiments reported in Table 10 of our online appendix, which also aligns with findings from prior works [Drakonakis et al., 2022; Rudner et al., 2019]. Some pixels are ambiguous (e.g., covered with tree canopies) so remain unlabeled. Unlabeled pixels are not included in the loss computation during training, and not included during test when calculating the evaluation measures. As Table 2 shows, most pixels of each region are annotated. Without loss of generalization, in Table 2, we use R1 and R2 for training, and use R3, R4, R5, R6 and R7 for test.

Models. We consider three U-Net baselines: (1) "U-Net 3C" with input using the RGB channels of the disaster-time image; (2) "U-Net 4C" with input adding an additional channel for the elevation map; (3) "U-Net 7C" with input also adding the RGB channels of the normal-time image.

For EvaNet, we consider two versions: (1) "EvaNet 4C" using only the disaster-time RGB image for the leftmost cyan 'image' input tensor shown in Figure 4, and (2) "EvaNet 7C" using both disaster-time and normal-time images for that input tensor. We remark that our new elevation-regulated convolution (denoted by Eva-Conv) and elevation-guided loss (denoted by Eva-Reg) can serve as drop-in replacements of the regular convolution and binary cross-entropy loss in any encoder-decoder model for semantic segmentation, and we choose the popular U-Net model just as a representative.

For physics-guided graphical models, we compare with hidden Markov tree (HMT) [Xie et al., 2018; Jiang and Sainju, 2019]. Since HMT uses transductive learning, we use the same region for training and test. For U-Net and EvaNet, we use two regions R1 and R2 in Table 2 for training and the other regions for test. For example, when reporting the performance measures on R3, HMT is trained on R3 and tested on R3, while all other models are trained with the patches of R1 and R2, and then tested on patches of R3 and stitched.

By default, EvaNet uses only Leva in Eq (2) as the loss function, where w(p↪ pn) uses the binary weighting scheme in Eq (4). We use 3 convolution blocks of Eva-Conv for both the encoder and the decoder as shown in Figure 4, where the input has 7 channels (disaster-time and normal-time RGB plus elevation map), and the encoder downsamples the spectral path using max pooling, and downsamples the elevation path using average pooling. These default configurations are found to be the best-performing, as demonstrated by our experiments in the online appendix [Sami et al., 2024] (see Tables 6-10). We trained our EvaNet models and the UNet baselines on a cluster with NVIDIA-P100 GPUs for 100 epochs with a learning rate of 1 ⇥ 10-7 and batch size of 4. These default settings are found to be the best-performing through extensive tests.

Performance Measures. Accuracy, precision, recall and F1-score are commonly used measures for binary classification. Following prior works such as [Xie et al., 2018; Jiang and Sainju, 2019], we consider our flood segmentation problem as a pixel-wise binary classification problem, and report the above four measures in two contexts: (1) "Dry" where dry (resp. flood) is the positive (resp. negative) class, and (2) "Flood" where dry (resp. flood) is the positive (resp. negative) class. These measures are computed only from labeled pixels in the test images.

Comparison with Baselines. Here, we consider 3 representative baselines: (1) HMT [Xie et al., 2018], which is a graphical model for transductive learning that considers both the disaster-time RGB image and the elevation map, (2) U-Net 3C, which is a U-Net model that only considers the disastertime RGB image, (3) U-Net 7C, which is a U-Net model that considers both the RGB images and the elevation map. They are compared with EvaNet 7C in Table 3. We skip 4C models since they are dominated by 7C ones (c.f. Table 10 in our online appendix [Sami et al., 2024]).

We can see that EvaNet 7C consistently gives the highest accuracy and F1-score, much higher than all the baselines. Among the other models, HMT performs well on R3, R4 and R7, but very poorly on R5 and R6 where more pixels are predicted as dry, which shows that HMT is region-sensitive and not very robust. U-Net 7C is the second best on R3, R5, and R6 and generally better than U-Net 3C and HMT, but U-Net

7C is even worse than U-Net 3C on R4. We explored the data and found that our pixels in training regions all have elevation below 80 meters, but quite a few pixels in R4 are higher than 90 meters, leading to poor model generalization when the elevation map is treated as an additional input channel backfiring on performance. However, our way of using the elevation map in EvaNet 7C does not cause any generalization issue, and EvaNet 7C still gives the best performance on R4; it also outperforms all other models on R6 and R7, which is from a different flooding event. This shows that our EvaNet design is robust thanks to the elevation guidance.

Ablation Study. To verify the effectiveness of both our EvaConv and Eva-Reg designs, we conduct an ablation study using 7-channel input, by exploring the performance of 4 models: (1) U-Net 7C (i.e., with loss LCE), (2) U-Net with our loss function Leva (denoted by U-Net 7C + Eva-Reg), (3) U-Net 7C with our new Eva-Conv operations in both encoder and decoder (denoted by U-Net 7C + Eva-Conv), and (4) EvaNet 7C, i.e., with both Eva-Conv and Eva-Reg. Without loss of generality, Table 4 shows the performance results on test region R4, where we can see that (i) both Eva-Reg and Eva-Conv improve the model accuracy and F1-score as compared with U-Net 7C, (ii) Eva-Reg (i.e., our new loss Leva)

improves the performance more significantly, and (iii) our EvaNet 7C model combining both designs provides the highest accuracy and F1-score. In our online appendix [Sami et al., 2024], we show that our techniques are effective also in other ConvNet architectures using Table 11, and we also visually inspect the flood maps from different models in Figure 7 to confirm our conclusions.

Effect as a U-Net Drop-in Replacement. We also find that EvaNet can improve the performance of an existing model such as HMCT-PP [Sainju et al., 2022] (i.e., U-Net + HMCT) by replacing its U-Net component. Due to space limit, please refer to Table 12 in our online appendix [Sami et al., 2024] for more details.

5 Conclusion

We presented EvaNet, a physics-guided segmentation model for flood extent mapping on satellite imagery. EvaNet is based on the popular encoder-decoder architecture with two novel techniques: (1) an elevation-guided loss function, and (2) an elevation-regulated convolution. Extensive experiments show that both techniques are effective, and that EvaNet works as a perfect drop-in replacement for U-Net in flood mapping solutions such as HMCT-PP.

Acknowledgements

The work was done when Dr. Mirza Tanzim Sami and Dr. Jalal Khalil worked as PhD students under the supervision of Da Yan at the University of Alabama at Birmingham. The research of Mirza Tanzim Sami, Da Yan, Saugat Adhikari, Lyuheng Yuan and Jiao Han were supported by NSF OAC-2106461, ARDEF 1ARDEF21 03, NSF OAC-2313192, DOE ECRP Award 0000274975, South Big Data Innovation Hub 2022 S.E.E.D.S. Award, NSF OAC-2414185, and NSF OAC-2414474. Mirza Tanzim Sami acknowledges the financial support from the Alabama Graduate Research Scholars Program (GRSP) funded through the Alabama Commission for Higher Education and administered by the Alabama EPSCoR. The research of Zhe Jiang was supported by NSF OAC-2152085, NSF IIS-2147908 and NSF IIS-2207072. The research of Yang Zhou was supported by NSF OAC2313191.