Towards Non-Region Specific Large-Scale Inundation Modelling with Machine Learning Methods

Abstract

Traditional flood inundation modelling methods are computationally expensive and not suitable for near-real time inundation prediction. In this study we explore a data-driven machine learning method to complement and, in some cases, replace existing methods. Given sufficient training data and model capacity, our design enables a single neural network instance to approximate the flow characteristics of any input region, opening the possibility of applying the model to regions without available training data. To demonstrate the method we apply it to a very large >8000 km² region of the Fitzroy river basin in Western Australia with a spatial resolution of 30 m × 30 m, placing an emphasis on efficiency and scalability. In this work we identify and address a range of practical limitations, e.g., we develop a novel water height regression method and cost function to address extreme class imbalances and by carefully constructing the input data, we introduce some natural physical constraints. Furthermore, a compact neural network design and training method was developed to enable the training problem to fit within GPU memory constraints and a novel dataset was constructed from the output of a calibrated two-dimensional hydrodynamic model. A good correlation between the predicted and groundtruth water heights was observed.

1. Introduction

Flooding is one of the most damaging natural disasters worldwide, with accurate and fast inundation modelling this risk can be mitigated. Hydrodynamic models have been applied successfully for several decades to the flood inundation modelling problem ([1,2,3]). However, while hydrodynamic modelling tools are highly effective at estimating detailed and accurate flood inundation characteristics (flow rates, water heights, etc.), they typically require extensive configuration and calibration before simulating future floods. Moreover, hydrodynamic modelling is computationally expensive, limiting the capability of these tools for near real-time simulations and multiple scenario modelling ([3,4]). With the advent of distributed sensing and satellite imaging, scientific organisations and governments have accumulated extensive datasets of extreme hydrological events (floods, drought, etc.) [5]. Often these observations are used to verify and tune traditional hydrodynamic models such that future events can be modelled ahead of time, informing government policy and other decisions. In this paper, we aim to combine existing datasets and hydrodynamic models with modern data-driven machine learning (ML) modelling techniques. We propose a novel model designed to provide short-term (7 days) inundation predictions over large regions (>8000 km²) in a fast and efficient manner to assist emergency services during rapidly evolving flood events. For the purpose of this paper we have opted to model water heights/inundation given its relative value in potential disaster management applications, given appropriate training data this method could be extended to provide flow rates and other outputs.

We define the inundation modelling problem as estimating the water height $H_{x,y}\left(t\right)$ at some future time t and spatial position $(x,y)$ given an initial water height $H_{x,y}\left(0\right)$, digital elevation model (DEM) topology data $T_{x,y}$, surface roughness/viscosity parameter ${\mu }_{x,y}$ and a set of driving inflows $I_n\left(t\right)$ defined at a small number of inflow boundary locations. Therefore, dropping the spatial indices $x,y$, our inundation model $\mathit{\sigma }(.)$ provides the following:

$$H\left(t\right)=\mathit{\sigma }\left(H\left(0\right),T,\mu ,I_0,\dots ,I_N,t,\mathit{\theta }\right)$$

(1)

where $\mathit{\theta }$ is a set of parameters (model weights, etc.) tuned using machine learning methods. For this analysis we are ignoring the effect of rainfall in the modelling region and assuming all incoming water flows via the inflow boundaries. A high level overview of the proposed system is depicted in Figure 1.

In this paper we have opted to replicate a simulated scenario which does not include rainfall occurring in the local modelling region (but may occur outside, e.g., up river). For the scope of the current paper we have opted to omit this input since we believe that it not necessary to demonstrate the paper’s methodology but note that the model can be extended to repond to rainfall by providing as an additional rainfall scalar input for each subregion.

Prior Work

The application of data-driven Machine Learning (ML) and Neural Networks (NN) to flood event modelling has become increasingly popular in recent years ([6]). Benefits of these methods include computational efficiency when compared to physics based models and the ease in which they can be extended to provide probabilistic outputs (without expensive sampling methods). Neural Network models used to predict flood inundation (depth and extent) can be categorised into static and temporal methods. In the static approach, the NN model takes a set of inputs (typically discharge/inflow information) and predicts the corresponding water depth at a single predefined future time, e.g., U-Net_river developed by [7] or the hybrid ML model proposed by [8]. In the temporal/sequential approach, the primary focus of this work, the ML model takes a set of inputs including current water depth to predict the water depth at a series of future times. Examples of generic ML model designs capable of modelling time-series data include Recurrent Neural Networks (RNN, [9]), Long-Short-Term Memory (LSTM, [10]) networks and, more recently, Transformers ([11]). Prior applications include the Generalized Regression Neural Network applied in [12] and the more complex LSTM network applied in [13].

In this work we focus on RNNs since they are relatively compact, efficient and scalable, leading to reduced hardware requirements during the training and inference processes. The key design feature separating RNNs from other methods (LSTMs and Transformers) is each RNN evaluation only considers inputs from the previous timestep whereas other methods access information from further back in time via a memory design feature (LSTM) or attention method (Transformer). To support this property these methods require that past inputs are also provided to the model during training each iteration, greatly increasing memory and compute requirements, e.g., a LSTM has an additional hidden state input/output which is calculated by running the model over the sequence of previous inputs and must be recalculated each training iteration.

Many methods ([12,13]) produce a ML model that is designed to be specific to a single region, i.e., they cannot be applied to new regions without performing an expensive retraining process with additional data. From a modelling perspective this greatly simplifies the problem, however this may limit their application in practice. Futhermore, with this limitation each model instance cannot exploit data from different regions in the training process, potentially reducing the data diversity and accuracy to novel events. By splitting the modelling region into many subregions, we explore a more general approach where the NN model must adapt to a range of varying input regions, i.e., our model instance is applied to 224 unique subregions. Given a sufficiently general training dataset with many diverse scenarios and a large enough neural network this method may generalize to regions previously unseen. This is made possible by inputting local DEM/roughness data directly (rather than implicit in the network structure), and training a single model instance on a diverse set of scenarios.

In addition to the ML model design and training regime, the dataset used to train the model plays a pivotal role in the accuracy and generalizability of the resulting method. In most cases this data is obtained via either direct physical measurements (distributed sensing, satellite, etc.), simulation/modelling methods or a combination of both. Typically physical measurements are sparsely distributed or only provide limited data, for this reason many ML methods have moved to using the outputs of verified physical simulations. For instance, iRIC ([14]), a two-dimensional hydraulic model solver, is used by [7] to generate training data. TUFLOW ([15]) is also commonly used by researchers to generate the flood events data from real and synthetic events, e.g., [12] used TUFLOW to model ten flood events including three historical and seven designed/synthetic events for their study. The MIKE21 ([16]) software, used in this paper, is another popular hydrodynamic simulator used for modelling inundation events. In [17,18] MIKE21 was used to simulated fluvial and pluvial events to generate data from synthetic and real events.

2. Materials and Methods

2.1. Dataset

We developed a dataset based on the Fitzroy River basin in Western Australia. This river basin has 3 primary inflows situated upstream located at Christmas Creek, Dimond Gorge and Mount Krauss (Figure 2). The driving inflows used for the simulation are based on a historic flood which occurred in 2001, this flood was selected because it has been extensively studied by our group and has no data sharing limitations. The dataset is generated by applying a hydrodynamic physics simulation based on the MIKE21 software over 40 days with the first 5 days used to fill the river from an initially empty state. The simulation results have been verified by manual inspection of satellite imaging and multiple direct measurements of flow rate of this and other flood events. Our dataset includes 3 independent scenarios labelled Baseline, Wet and Dry. Each scenario corresponding to a separate simulation run with differing driving inflows. The simulation produces water height data every hour for each point in a user-defined sparse triangular mesh. Typically this mesh is fine near the river and becomes progressively coarser for further away points which are less likely to become inundated. The dataset is free for non-commerical use and is available from https://doi.org/10.25919/7g40-es07 (accessed on 7 August 2024). In 

Table 1. Raw input data sources—generated by MIKE21 hydro-dynamic model.

Type	Format	Description
DEM and water height	XYZ text file	Comma separated vertex data storing (x,y) position of triangle mesh point, DEM elevation with respect to Australian Height Datum (AHD, m) and water height above ground (m). Generated by the MIKE 21 model at hourly interval. DEM data is constructed by merging coarse satellite DEM data with fine aerial LIDAR captured directly over the major river [19].
Roughness parameter	GDAL .asc file	Binary data in GDAL format defining surface roughness parameter over a 30 m × 30 m dense grid. Note this grid may not precisely align with the desired input grid.
Driving Inflows	CSV text file	Comma separated text data defining the flow-rates at the 3 inflow boundaries sampled daily. Missing data is replaced with an empty string. Data is based on real water gauge observations provided by the Western Australia government.

we provide a description of the raw input data formats.

2.2. Preprocessing

To reduce complexity and facilitate convolutional operations in the model design we spatially sampled the sparse triangular mesh to produce a dense grid with each cell providing the water height for a 30 m × 30 m region. We convert the sparse triangular mesh data into an appropriate grid via a rasterization process. Using interpolation methods this process estimates the value for each point in the predefined dense grid. In its current implementation (multi-threaded CPU based) this process is performed as a preprocessing step applied before modelling.

In most instances more than one triangle is present in each cell. Ideally a smaller cell size would be used however it would require significant hardware resources given the size of the region being modelled, e.g., moving to 5 m × 5 m would require 36× the current VRAM requirements. Using a smaller cell size would be practical if a smaller context window was applied, however this is likely to introduce other limitations.

The preprocessing method is also responsible for sampling the dataset and breaking the problem into manageable chunks for efficient model training. For spatial sampling we found the most success by first breaking the entire region down into 3.8 km × 3.8 km non-overlapping regions and identify which regions contained water at some point in time, discarding all others. For each water region we then exported the data within 11.52 km × 11.52 km overlapping regions to produce a 384 × 384 sample with a 30 m × 30 m grid cell size. The precise size of the region is an important design consideration because it dictates how much context the model has available to produce its prediction. We expect the required context size to increase as the model predicts further into the future with a single step, e.g., predicting 6 h into the future requires more context than 1 h because the state further upstream can have a greater impact. Furthermore, each sequence of water heights is split into multiple samples each containing 3.5 days (84 h) of data.

After preprocessing the complete dataset is approximately 100 GB with each sample 44 MB. The results are stored within a NumPy v1.19.5 NPZ file (water height sequence, topological DEM, roughtness and mask) and an associated JSON file (driving inflows and other metadata). Applied to all three sequences, the preprocessing method takes approximately 4.25 h using an Intel i7-7820X CPU writing to a solid state drive. In 

Table 2. Dataset preprocessing outputs. All matrices are 384 × 384 and spatially aligned.

Type	Format	Description
Water height sequence	vector of float32 matrix	A sequence of water heights $H\left(t\right)$ for the local region
Topological DEM	float32 matrix	The elevation T for the local region
Roughness	float32 matrix	The roughness parameter $\mu$ for the local region
Mask	boolean matrix	This mask indicates which point in the above matrices contain valid data. This is necessary when near the edge of the dataset where we have missing data.
Driving Inflows	float32 vector	Driving inflows $I_n\left(t\right)$ at each inflow boundary associated with each water height
Metadata	JSON	Additional metadata including timestamps associated with each water height, region bounding box, etc.

we provide an overview of the data contained within each sample.

3. Machine Learning Method

We propose two independent machine learning models which we have named the Inflow model and Interior model. In Section 3.5 we provide additional details on how these models are applied to predict water height at inference time. The models differ slightly in their inputs and operate in different regions:

(a)

Inflow Model: predicts the change in water height for local regions containing a single inflow boundary with known inflow or discharge rate. In our dataset there are 3 inflow boundaries: Christmas Creek, Dimond Gorge and Mount Krauss. Each inflow boundary has an inflow rate $I\left(t\right)$ defined over the modelling time period.

(b)

Interior Model: predicts the change in water height for all local regions not predicted by the Inflow model. This model is responsible for propagating the water generated by the Inflow model through the rest of the river system.

In practice, these models are applied via the following recursive update equations to estimate the water height $H\left(t\right)$ at some future timestep t:

$$\begin{array}{cc}\hfill \mathrm{Inflow}:& \Delta H(t+1)={\sigma }_{inflow}(M,T,\mu ,H\left(t\right),I\left(t\right))\hfill \end{array}$$

(2)

$$\begin{array}{cc}\hfill \mathrm{Interior}:& \Delta H(t+1)=\Delta H\left(t\right)+{\sigma }_{interior}(M,T,\mu ,H\left(t\right),I\left(t\right),\Delta H\left(t\right))\hfill \end{array}$$

(3)

where ${\sigma }_{inflow}$ and ${\sigma }_{interior}$ are neural networks, $\Delta H\left(t\right)=H\left(t\right)-H(t-1)$ is the change in water height, M is the input mask, T is the DEM topography for the local region, $\mu$ is the viscosity parameter for the local region and $I\left(t\right)$ is the inflow associated with the local region. In machine learning the proposed design is commonly referred to as a Recurrent Neural Networks (RNN), we expect other more advanced sequence-to-sequence methods (e.g., long short term memory, transformers, etc) could also be applied to the problem. The RNN design was selected due to its simplicity, low computational requirements (during training) and robustness to over-training given our limited number of sequences (i.e., two for training).

The key difference between the Inflow and Interior models is the exclusion of the change in water height $\Delta H\left(t\right)$ input to the ${\sigma }_{inflow}$ neural network. By removing this term we force the Inflow model to respond to the inflow input $I\left(t\right)$ which is now the only parameter providing time-varying flow information. If this change was not made then ${\sigma }_{inflow}$ might ignore changes to $I\left(t\right)$ and instead rely on the more information rich (i.e., specified at all positions) $\Delta H\left(t\right)$ to provide flow information. This will likely result in over-training and poor performance on novel inflows as our training dataset provides a relatively small range of $(I,\Delta H)$ pairs.

Both the Inflow and Interior models operate on a grid of overlapping local regions, in this case each evaluation takes a local input region of 11.52 km × 11.52 km and predicts the change in water height for a 3.84 km × 3.84 km region located centrally within the input. The larger input region provides the network with additional contextual information (i.e., flows further up/down stream, etc.) which may be relevant to the prediction. With our 30 m cell size, these regions equate to an input tensor of $C_0$× 384 × 384 and an output tensor $C_1$× 128 × 128 where $C_0$ = 4 for the Inflow model and $C_1$ = 5 for the Interior model. These dimensions are a key model design parameter and must be balanced with the available GPU video memory (VRAM) and desired inference speed.

3.1. Input Transforms

In an effort to introduce some minor physical constraints and simplify the modelling problem the initial Transform block applies a series of simple linear transforms to the inputs, i.e., for the Interior model we apply:

$$\begin{array}{c}{H}_D=0.1{\left[\begin{array}{cccc}\left(H_{x,y}-H_{x-1,y}\right)& \left(H_{x,y}-H_{x+1,y}\right)& \left(H_{x,y}-H_{x,y-1}\right)& \left(H_{x,y}-H_{x,y+1}\right)\end{array}\right]}^{\mathrm{T}}\end{array}$$

(4)

$$\begin{array}{c}{T}_D=0.01{\left[\begin{array}{cccc}\left(T_{x,y}-T_{x-1,y}\right)& \left(T_{x,y}-T_{x+1,y}\right)& \left(T_{x,y}-T_{x,y-1}\right)& \left(T_{x,y}-T_{x,y+1}\right)\end{array}\right]}^{\mathrm{T}}\end{array}$$

(5)

$$\begin{array}{c}V={\left[\begin{array}{cccccc}20\mu & 2\Delta H& M& 0.002I_0& 0.002I_1& 0.002I_2\end{array}\right]}^{\mathrm{T}}\end{array}$$

(6)

$$\begin{array}{c}\mathrm{output}=concat(H_D,T_D,V)\end{array}$$

(7)

where $H_D$ and $T_D$ are the discrete spatial derivatives of water height and topology respectively and $concat(.)$ concatenates the input vectors. For most inputs we applied a basic scaling operation such that the output is roughly within the range of [0, 1]. This aids convergence because the network weights are initialized with the assumption that input tensor values are normalized ([20]). An additional transform is applied to the water height $H\left(t\right)$ and topographic data T, we assert that the absolute water height and the absolute topology above sea level is not relevant to the modelling problem, only the local changes are of importance. Therefore we provide the discrete spatial derivatives for these inputs. Note that the Inflow model is identical to the above except the $2\Delta H$ term is omitted.

3.2. Water Height Regression

Given the two output feature maps $(F_0,F_1)$ generated by the neural network (with dimensions 384 × 384) we predict the change in water height $\Delta H$ using:

$$\begin{array}{c}P={\left(1+\exp \left(F_0\right)\right)}^{-1}\end{array}$$

(8)

$$\begin{array}{c}\Delta H=\left\{\begin{array}{cc}0.001F_1& P\ge 0.5\\ 0& P<0.5\end{array}\right.\end{array}$$

(9)

where P is the inundation probability, i.e, the likelihood that the change in water height is not equal to zero. This attention-like formulation provides the network the ability to easily return a change in water height of precisely zero $\Delta H=0$ which is by far the most common occurrence, especially in grid cells without water. Without this modification it is common for the regression to output a small $ϵ$ rather than zero, which accumulates over multiple iterations, introducing significant errors in longer-term predictions. During training this formulation also operates as a means to address the extreme class imbalance of the problem, bypassing the need for sampling methods to improving convergence. Furthermore, the probability P can be a useful output in its own right, e.g., it can provide the likelihood that a uninundated region will become inundated in the next timestep. i.e., if $H\left(t\right)=0$ then $\mathrm{Pr}\left(H(t+1)>0\right)=P$.

3.3. Network Topology

The ${\sigma }_{inflow}$ and ${\sigma }_{interior}$ neural networks share a custom architecture based primarily on Residual Network blocks ([21]) with skip connections. Given the exploratory nature of the research, this architecture has not been highly optimized for the application. In 

Table 3. Feedforward neural network design, layers are applied sequentially top to bottom as defined below. Input data is spatially downscaled via the 5× ResNet blocks, then upscaled to the original resolution using 5× Upsample blocks. Skip connections are used between ResNet and Upsample blocks to improve information flow.

Block Type	Multi.	Output Dim	Description
Transform	$1\times$	$10\times 384\times 384$	Takes local inputs (flow, topographic DEM data, driving inflows, etc.) and applies the transforms described in Section 3.1.
Conv-ReLU	$2\times$	$32\times 384\times 384$	Applies a $3\times 3$ convolution, batch normalization ([22]) and rectified linear (ReLU) activation to the input tensor.
ResNet	$2\times$	$64\times 192\times 192$	Applies two Conv-ReLU blocks to the input then combines the resulting tensor with the input via an addition operation. The first ResNet block in each sequence downscales the input by $2\times 2$ [21].
ResNet	$2\times$	$128\times 96\times 96$
ResNet	$3\times$	$192\times 48\times 48$
ResNet	$3\times$	$256\times 24\times 24$
ResNet	$3\times$	$320\times 12\times 12$
Upsample	$1\times$	$256\times 24\times 24$	Applies a $2\times 2$ upscaling operation to the input, adds the features from the previous defined ResNet block with the same spatial resolution (i.e., skip connection), then applies a basic Conv-ReLU block.
Upsample	$1\times$	$192\times 48\times 48$
Upsample	$1\times$	$128\times 96\times 96$
Upsample	$1\times$	$64\times 192\times 192$
Upsample	$1\times$	$64\times 384\times 384$
Regression	$1\times$	$2\times 384\times 384$	Applies a $1\times 1$ convolution operation with 2 output features to generate the water height change and inundation probability outputs. The water height change is multiplied by scalar constant (in this case 0.001) to improve training dynamics.

we provide the fundamental neural network building blocks and the arrangement of these blocks to form the final network.

3.4. Model Training

Both models are trained with the datasets described in Section 2.1, i.e., the Wet and Dry scenarios form the training data and Baseline scenario the testing data. No augmentation methods are applied to these samples. We apply stochastic gradient descent (SGD) with nesterov momentum and a batch-size of 16 samples per GPU to form a total batch-size of 64 samples. Training is performed using a server with $4\times$ Nvidia RTX 3090 GPUs, these GPUs have 24 GB of VRAM which proved to be useful in this application. With this hardware and a 35 epoch training duration it took approximately 12 h to train the Interior model and <1 h for the Inflow model. For the first 5 epochs the learning rate was linearly increased from $0.0$ to $0.1$, then cosine annealing is applied to subsequent epochs. In some cases we found it beneficial to restart the training a second time with the learning rate halved. This is likely due to the attention mechanism in the regression (see Section 3.2), ideally output P would be already optimized before $\Delta H$.

The models are trained over a single timestep, i.e., we sample the inputs $H\left(t\right)$, $\Delta H\left(t\right)$, M, T, $\mu$ and $I_n\left(t\right)$, and provide the groundtruth $\Delta H_{GT}(t+\Delta t)$ and $P_{GT}(t+\Delta t)$ using the training data. We experiment with using a range of $\Delta t$ from 1 h to 24 h. We jointly optimize the water height $\Delta H$ and inundation probability P by minimizing the following cost function:

$$\begin{array}{c}\mathrm{Cost}=M\left({\lambda }_0{\displaystyle \frac{\mathrm{HuberLoss}(\Delta H_{GT}-\Delta H)}{1+H}}+{\lambda }_1\mathrm{CrossEntropy}\left(P_{GT},P\right)\right)\end{array}$$

(10)

$$\begin{array}{c}\mathrm{CrossEntropy}(X,Y)=(1-X)\ln (1-Y)+X\ln \left(Y\right)\end{array}$$

(11)

$$\begin{array}{c}\mathrm{HuberLoss}\left(X\right)=\left\{\begin{array}{cc}{\displaystyle \frac{1}{2}}{X}^2& \left|X\right|\le 0.1\\ 0.1\left|X\right|-0.05& \left|X\right|>0.1\end{array}\right.\end{array}$$

(12)

where $({\lambda }_0,{\lambda }_1)$ are scalar user-defined cost factors, $(P,\Delta H)$ are outputs from the neural network, $(P_{GT},\Delta H_{GT})$ is the associated groundtruth and M is a binary mask $\in [0,1]$ used to indicate which points should be considered in the cost function. Typically the mask M is zero everywhere except the central $128\times 128$ region unless a point isn’t valid, e.g., it is common for regions near the edges to lack some topographic information, etc, for these cases we set $M=0$. Compared to other regression costs (e.g., mean squared error) the $\mathrm{HuberLoss}$ function provides additional robustness to outliers by switching from $X^2$ to $\left|X\right|$ for large errors, i.e., in this case the error becomes linear when $|\Delta H-\Delta H_{GT}|>0.1$. We divide the $\mathrm{HuberLoss}$ by the water height term $1+H$ such that a greater focus is placed on shallow regions which are likely to be outside the main river flow.

3.5. Inference Method

The basic proposed inference algorithm works by identifying regions which may contain water and applying both trained models to step forward in time. These steps are then repeated recursively until the desired sequence length is obtained:

• Extract the current water height, elevation, roughness and driving inflow data from the three $384\times 384$ grid cells which contain the driving inflows.
• Apply the Inflow model to these regions to predict a set of local water heights for the next timestep $H_{inflow}(t+1)$
• By observing the current global water height $H\left(t\right)$ identify all $128\times 128$ grid cells which contain any water. To this set of regions add the surrounding regions to form the water cells. For each water cell extract the associated $384\times 384$ local region from the elevation, roughness, water height, flow and driving inflow data.
• Apply the Interior model to the extracted water regions to predict a set of local water heights $H_{interior}(t+1)$
• Combine local outputs of both Inflow and Interior models $H_{inflow}(t+1)$ and $H_{interior}(t+1)$ to reconstruct the global water height $H(t+1)$ and change in water height $\Delta H(t+1)=H(t+1)-H\left(t\right)$. Only the central $128\times 128$ values from the local ML model predictions is used.
• Repeat steps 1–5 until desired time has elapsed

By applying the Interior model only to regions which contain water in the previous time-step we can dramatically reduce the runtime required for inference, however, with rapidly evolving flood conditions, this may introduce errors if a region is incorrectly identified as not having water. To address this we also propose including the surrounding regions at the cost of increased computational load.

4. Results

4.1. Inflow Model

To validate the Inflow model, we considered training and testing a single region which contains a driving inflow boundary. The region containing the Mount Krauss inflow boundary was selected because it is consistently the largest inflow for the river system. For training data we used the Wet and Dry scenarios, for testing we selected a 7 day subset of the Baseline scenario starting at an offset of 100 h (4 a.m. on 19 February 2001). In this scenario the river starts with a moderate inflow 2000 m³/s, increases to 5000 m³/s over the next two days then decreases to a low inflow rate of 500 m³/s over the following 5 days. In these experiments the neural network estimates the water height 24 h in the future.

For comparison purposes, we tested this method with and without driving inflows as input to the network. In 

Table 4. Inflow model RMSE on Baseline Mt. Krauss testing sequence. Predictions with driving inflows performs significantly better, demonstrating the value of this information.

Model	Day 1	Day 2	Day 3	Day 4	Day 5	Day 6	Day 7
Without driving inflows	0.378	0.527	0.295	0.348	0.562	0.683	0.750
With driving inflows	0.109	0.208	0.120	0.148	0.188	0.195	0.200

we provide the root mean squared error (RMSE) for both configuration. When driving inflows are not present the network has no knowledge of incoming water flow rates, significantly decreasing performance. These results provide evidence that the model is responding directly to the inflow information rather than another property present in the input data.

In Figure 3 we provide the predicted and groundtruth water heights. Matching the groundtruth, we observe a significant increase in water height for the initial 2 days followed by a gradual decline. However, the prediction largely fails to reproduce a shallow secondary flow (bottom left of image) that is generated on Day 2 and persists outside the banks of the primary river in subsequent days.

4.2. Interior Model

When designing the inundation model we can choose to either (a) predict a small time into the future with each evaluation and perform many iterations (e.g., 1 h time-step with 168 iterations = 7 days) or (b) predict a longer time into the future and perform fewer iterations (e.g., 24 h time-step with 7 iterations = 7 days). Method (a) is more similar to the approach used in the hydrodynamic model, while method (b) introduces additional complexity (non-linearity) in the modelling problem.

In Figure 4 we provide the root mean squared error (RMSE) and mean absolute error (MAE) given a range of time-steps $\Delta T$ from 1 h to 24 h. For each scenario a new model is trained from scratch and evaluated on the full test dataset. This dataset is constructed by extracting every 7 day sequence available in the Baseline sequence e.g., Day 0 to Day 7, Day 1 to Day 8, etc. The RMSE and MAE is then obtained by averaging the errors over all sequences. For comparison purposes we provide results given a Naive model, which assumes a constant flow rate, i.e., the water height at time t is given by $H\left(t\right)=H\left(0\right)+t\Delta H\left(0\right)$ where $H\left(0\right)$ and $\Delta H\left(0\right)$ are the initial water height and flow rate inputs. In this scenario, we found that all models significantly outperformed the Naive model and that the longer time-step models were significantly more accurate as time progressed. The long time-step models also have the advantage of being significantly faster to evaluate. Note that the slight decrease in RMSE that occurs from 120 to 168 h is a artifact of the testing data, typically less water is present during this later period skewing the error metric.

In Figure 5 we provide the groundtruth water height and model prediction for the 24 Hr Interior model on the 7 day Baseline testing sequence (same period used in Inflow results). These results demonstrate strong correlation between the prediction and groundtruth data, e.g., On Day 1 to Day 3 the flood plain in the lower left increases before gradually retreating. In this sequence the prediction tends to under estimate the amount of water present outside of the river on Days 1–4, then overestimates on Days 5–7.

5. Timing

We have designed the ML system to provide relatively fast predictions with moderate hardware requirements. In 

Table 5. Prediction time for traditional hydrodynamic and proposed ML system. We observe significantly reduced time and hardware requirements for our system.

Method	Hardware	Days	Area	Runtime	Per Day Per 1000 ${\mathbf{km}}^2$
MIKE21	$4\times$ Tesla P100	40	35,026 ${\mathrm{km}}^2$	38 h	97.6 s
ML System	$1\times$ 1080 Ti	7	8242 ${\mathrm{km}}^2$	1 min 36 s	1.7 s

we provide the time required to generate a single prediction using the ML system and the MIKE21 hydrodynamic modelling software ([16]). These results ignore the time required to load groundtruth and other components that would not be present in a production system. In its current form the ML system is approximately $57\times$ faster while using significantly less powerful hardware (a single 1080 Ti is roughly equivalent to a single P100). Assuming near linear scaling with the number of GPUs (method is naturally parallelizable), these results suggest a factor >200× with identical hardware.

6. Discussion

In this paper, we design and implement a data-driven method for rapid inundation modelling of a large >$8000{\mathrm{km}}^2$ region. Given the range of practical considerations, particularly the processed dataset size (100 GB for 3 × 40 day sequences) and video memory constraints we opted for a relatively simple recurrent neural network design applied to a local $11.52\times 11.52{\mathrm{km}}^2$ region (per evaluation). Furthermore, we developed a novel input transformation, water height regression method, cost function and neural network design. We observed a good correlation between the predicted and groundtruth water heights, with both Interior and Inflow models realistically distributing water outside the main river during a flood event then retreating as inflows decreased. Our results also suggest that evaluating this model per day is more accurate than smaller timesteps (e.g., 1 h), demonstrating the ability for neural networks to adapt to increased modelling complexity. Given the data-driven nature of our method we expect a larger, more diverse dataset would further improve results.

While these results are promising, they do not negate the need for traditional hydrodynamic modelling. Instead we view this as a complementary system for generating predictions when time and hardware are constrained. In particular the traditional methods are key for generating datasets and when novel out-of-domain situations arise, e.g., data driven methods are known to fail to generalize for situations which are considerably different to their training data.

Ultimately data driven ML method are constrained by the availability of suitable datasets which may be scarce in many regions of the world. Ideally this would be addressed by training a single model instance on a large range of real-world calibrated simulations. However we also note that this particular problem domain may be well suited to artificial dataset creation methods, e.g., by creating realistic randomized DEM, roughness and inflows for virtual river basins we can train the model over a very diverse dataset.