Fault interpretation is a critical task in seismic data interpretation and is usually approached as a segmentation task. This study proposes a 3D convolutional neural network (CNN) that reframes this as a regression problem to estimate continuous fault throw magnitudes. Using a realistically designed synthetic dataset comprising 3D seismic and fault throw label volume pairs, the model learns a mapping from seismic amplitude patterns to voxel-wise throw magnitudes in a number of samples.
The proposed method demonstrates consistent delineation of fault planes and captures relative fault throw variations across both synthetic validation data and real-world seismic data from the Exmouth Sub-Basin, Australia. By capturing displacement variations along faults, the model simplifies fault hierarchy assessment and reduces interpretation time, supporting rapid geological understanding of the study area.
While the model effectively preserves structural patterns, limitations remain regarding the quantitative accuracy of large throws. Accordingly, the workflow is presented as a feasibility demonstration for regression-based fault throw estimation, with future improvements expected from using larger input volumes and broader structural variability in training data.
This regression-based approach provides a foundation for enhancing automated structural interpretation by offering continuous displacement estimates that support the understanding of fault geometries and subsurface structural frameworks.
Introduction
Automated fault detection in seismic data has become increasingly critical in geophysical research as seismic datasets grow in complexity (An et al., 2023). Traditional fault interpretation relies heavily on manual analysis by experienced geophysicists, a process that is time-consuming, subjective, and prone to inconsistencies. The advent of machine learning (ML), particularly deep learning models such as convolutional neural networks (CNNs), has transformed seismic interpretation by enabling the analysis of large datasets with high accuracy and speed. These methods have proven effective in tasks such as fault detection, horizon picking, and facies classification. Many of the deep-learning architectures used for fault segmentation, such as U-Net (Ronneberger et al., 2015), were originally developed for medical image segmentation, where tasks such as tumour delineation and organ boundary extraction closely parallel fault detection in seismic volumes.
Early work by Jiang (2017) demonstrated the potential of using CNN in fault detection from seismic slices. This was followed by Xiong et al. (2018), and Guo et al. (2018), who advanced the usability and output quality of CNN-based fault prediction, laying the foundation for integrating deep learning into structural interpretation. The introduction of 3D CNNs (Guitton, 2018) marked a significant advancement, enabling the analysis of entire seismic volumes rather than individual slices. Wu et al. (2019) employed 3D CNNs to detect faults in seismic cubes, achieving robust and continuous fault surfaces across volumes. Their work demonstrated the strengths of CNNs in extracting complex fault patterns that are challenging to interpret manually, particularly in structurally complex areas.
More recently, Wei et al. (2022) improved fault classification accuracy by incorporating focal-loss supervision. Further enhancements were achieved by Zeng et al. (2024), who introduced attention-based ES-UNet models to enhance the resolution of fault boundaries by capturing features at multiple levels of detail. In parallel, Wang et al. (2023), Tang et al. (2023) and Wang et al. (2024) explored generative AI and developed transformer-based networks that outperformed the traditional U-net models in fault detection tasks, showcasing the potential of these models in seismic interpretation. Additionally, Ashtari (2024) introduced an innovative method based on the Shi–Tomasi corner detection algorithm to automatically detect fault samples on seismic data using deep neural networks, demonstrating precise fault detection.
A more sophisticated learning strategy was introduced by Gao (2024), who proposed a multi-tasking framework capable of jointly predicting multiple seismic attributes. This approach enables the model to learn shared representations across related tasks, improving generalisation and strengthening the prediction of structurally relevant seismic features.
Despite these advancements, most ML-based fault interpretation methods have been limited to binary classification tasks, where pixels or voxels are classified as either fault (1) or as background (0). While effective, such approaches do not capture fault throw magnitudes, which are critical for understanding tectonic regimes and fault hierarchies. Binary classification impairs the differentiation between major and minor faults, particularly when analysing Z-slices or assessing reservoir compartmentalisation and structural trap integrity.
A persistent challenge in applying ML to seismic fault interpretation is the scarcity of labelled data for training models, especially for fault detection tasks where faults may vary significantly in orientation, density, and displacement. Synthetic data generation, introduced by Wu et al. (2019) and Merrifield et al. (2022) tackled this by providing a method to create realistic 3D seismic volumes with controlled fault attributes. Their approach comprised generating a simple 1D reflectivity model, which was then modified with folding structures and planar faulting to mimic natural geological formations. This technique has been widely adopted for training fault detection models, as it provides labelled data with well-defined fault planes. However, synthetic data in existing research has predominantly been tailored for binary classification tasks.
While classification approaches for fault detection are well-represented in the literature, regression-based models have received limited attention, particularly in the context of fault throw estimation. Regression-based fault interpretation remains underexplored, despite its potential to provide detailed insights into fault properties. Gao (2024) is one of the very few publications in the last two years that evaluated regression ML for fault dip and strike. Unlike classification, a regression-based approach enables the model to output continuous values representing fault throws, which can be used to differentiate faults based on their displacement. This information is crucial for interpreters, as fault throw directly impacts reservoir compartmentalisation, migration pathways, and structural trap integrity.
This study introduces an approach of framing fault detection as a regression task. We propose a 3D CNN model that outputs continuous values representing fault throw magnitudes at each voxel. The model is trained using mean squared error (MSE), which provided the most stable performance. A synthetic dataset comprising 400 3D seismic volumes with varying fault orientations, folding, angular unconformities, wavelets, and noise, and their corresponding ground truth fault throw labels, was augmented and used for training. Testing on real seismic data from the Exmouth Sub-Basin demonstrates the model’s ability to delineate faults and estimate their throw variations, providing geologically consistent results. This study therefore demonstrates the feasibility of voxelwise regression for fault throw estimation.
Synthetic data preparation
Synthetic data provides a controlled environment for training, enabling the generation of many labelled samples with ground truth fault throw. Because obtaining voxelwise 3D fault throw annotations from real seismic volumes is extremely challenging, synthetic datasets play a crucial role in supervised learning. However, the realism and diversity of the synthetic data must be carefully ensured to promote generalisation to real seismic data.
This section outlines the process of generating synthetic seismic data and its fault throw labels, including the modelling of faults, their throws, and associated seismic reflections. We use the method developed by Wu et al. (2019) to generate 400 synthetic seismic and corresponding throw magnitude cube pairs of size (128, 128, 128). This dataset size was selected to balance variability in structural configurations with computational constraints. Expansions on the method include angular unconformity simulation and fault smearing.
Baseline geological model
Each synthetic cube begins with a baseline reflectivity model of flat, stratified layers, a simplification of the Markov chain model (Altamar, 2024). This is achieved by repeating a one-dimensional seismic reflectivity trace along the and dimensions. The trace is defined as a series of random values uniformly distributed within the range along the vertical dimension , which corresponds to sample depth or time:
where denotes a uniform probability distribution. Figure 1 shows central cross sections of various baseline seismic cubes with flat reflectors. We will demonstrate the entire process of creating the labelled synthetic data using these five examples.
Angular unconformity simulation
Angular unconformity simulation is applied to the flat cubes. The perturbation modifies the dip of the layers under the unconformity depth . The vertical shift is determined by a linear trend with a randomly generated dip angle across the lateral extent of the model:
where is a random integer representing the depth of the unconformity, and represents the linear trend. Figure 2 illustrates central cross sections of the example reflectivity cubes showing angular unconformity.
Folding simulation
Folding is simulated by introducing eight folds (anticlines and synclines) of diverse sizes, with randomly assigned centres to each training sample. This process modifies the originally flat or angular layers, introducing curvilinear features characteristic of geological folding. The folding perturbation is modelled as a 2D Gaussian function, with randomly selected amplitude, size, and direction, like the Wu et al. (2019) method. Figure 3 shows central cross sections of synthetic reflectivity cubes with randomly distributed folds.
Fault simulation
Faults are simulated by applying vertical shifts to the folded models. Between four and seven faults are introduced iteratively to each training sample. Fault geometry is defined by length, width, dip angle, and dip direction, all set as random values within predefined ranges. The throw along the fault surface is modelled as a 2D Gaussian function defined in local fault plane coordinates:
where:
- and represents local coordinates along fault strike and dip directions, respectively.
- is the maximum throw magnitude.
- are the coordinates of the maximum throw location.
- and controls the spread of the throw along the fault plane.
Each variable is randomly sampled from a predefined range for every fault simulation iteration. The resulting fault-plane throw distribution is mapped into the 3D volume according to the fault geometry and attenuated away from the fault plane using a spatial reduction function.
The shift is only applied to the voxels in front of the fault plane. A fault mask cube was generated to define the voxels to be shifted. The shifted position of each voxel is calculated as:
Figure 4 shows central cross sections of synthetic faulted reflectivity cubes.
The total displacement of each fault and its 3D position are saved in 3D arrays representing the fault throw labels. Figure 5 shows central cross sections of fault label cubes for the same five examples, where the amplitudes represent the amount of vertical shift (in samples) applied at each voxel. To simulate fault smearing, a horizontal moving average function with varying operator length was applied to the shift cubes. This creates a smearing effect rather than sharp displacement, which mimics fault plane uncertainty due to limited vertical resolution or migration artifacts. The smearing simulation significantly improved the model’s performance on real data. Notice that, while the fault label thickness is 3 pixels, some fault throws change laterally, which represents a smeared fault plane.
The distribution of fault throws in the synthetic dataset (Figure 6) is intentionally nonuniform, with small displacements occurring far more frequently than large ones. This design choice reflects natural fault populations, where minor faults consistently outnumber major faults in real geological settings. The synthetic data contains fault throw values in the range 0-84 samples, with approximately 95% nonfault voxels and 5% fault voxels. This inherent voxelimbalance is characteristic of real fault populations and is explicitly accounted for and analysed in our loss-function evaluation.
Noise and Wavelet Convolution
To enhance realism, Gaussian noise, diffraction noise, and Ricker wavelet convolution are applied to the reflectivity cubes. Diffraction noise is generated by randomly placing 20 diffraction points within the 3D grid:
where is the amplitude of the diffraction noise, and is the diffraction point centre. The level of Gaussian noise varies from one synthetic sample to another, to help the model generalise to various noise levels. All noises were added to the reflectivity cubes before applying the wavelet convolution. A Ricker wavelet with a randomly selected central frequency (25 to 40 Hz) was convolved with each noisy reflectivity cube. We acknowledge that the peak frequency could be lower in many datasets, especially in deep images; however, the stretching of the strata caused by faulting and angular unconformity simulations had a frequency reduction effect on the synthetic data. Furthermore, a time/depth gain function of randomly selected exponent from a preset range is applied to simulate amplitude attenuation with depth. Figure 7 shows central cross-sections of synthetic seismic amplitude cubes for the example samples after noise addition and wavelet convolution. Many of the added processes significantly improved the model’s generalisation as they were designed to address certain issues that were noticed in the model’s behaviour during experimentation.
Data augmentation
To enhance model robustness and generalisation, data augmentation is performed using volumetric rotations (90°, 180°, 270°) and vertical flipping. These rotations are applied in the spatial (azimuthal) sense and do not affect the seismic phase. Each augmented seismic sample is normalised to the range [0,1] and scaled by a random factor . These scalers enhanced the model’s performance in low-amplitude zones, improving predicted fault plane continuity. Applying the four rotations to each sample, the effective size of the training dataset increased from 400 to 2000 samples. Figure 8 illustrates an example of the augmentation process of a synthetic cube and its corresponding label.
Model architecture
This study utilises a 3D CNN model modified after Bi et al. (2021), who modified the 3D U-Net architecture (Ronneberger et al., 2015) to predict Relative Geological Time (RGT) from 3D seismic amplitude cubes. Because RGT prediction is also a voxelwise regression problem, their architecture is well suited for fault throw estimation. The model incorporates significant enhancements, including Squeeze-and-Excitation (SE) residual blocks and an attention-based decoder, both of which improve feature extraction and prediction accuracy. Bi et al. (2021) demonstrated that this enhanced network outperformed both UNet and ResNet50 (He et al., 2016) while using fewer trainable parameters, and our experiments for fault throw prediction show similar behaviour. A detailed visualisation of the model architecture is provided in Figure 9.
The main modifications we introduced to the Bi et al. (2021) model are: (1) replacing down sampling with strided convolution instead of maxpooling, and (2) reducing the bottleneck layer channels from 256 to 128. This reduction in bottleneck width resulted in a substantial decrease in trainable parameters — from ~56.6 million reported by Bi et al. (2021) to approximately 5.7 million in our implementation — without degrading model performance. This parameter count is appropriate for volumetric CNNs, as each 1283 cube contains millions of overlapping 3D patches, providing ample effective training samples for the model to learn stable representations.
Encoder and SE-residual blocks
The encoder comprises sequential SE-residual blocks, each followed by down-sampling through strided convolution. These blocks enable the network to learn complex spatial relationships while maintaining computational efficiency. The SE-residual blocks, introduced by Hu et al. (2018), adaptively recalibrate channel-wise feature responses by modelling interdependencies among channels.
Each SE block consists of two main stages: a squeeze operation implemented through global average pooling, followed by an excitation stage composed of two dense layers that first reduce and then restore the channel dimensionality. A sigmoid activation generates channel-wise attention weights, which are applied multiplicatively to the convolutional feature maps to reweight their channel responses.
The SE-residual blocks in this implementation consist of two convolutional layers, followed by batch normalisation and ReLU activation. The output from these layers is combined with the input tensor using a residual connection. This structure, adapted from Hu et al. (2018), enhances the model’s ability to capture spatial features in seismic data. Recent studies have also utilised similar structures for seismic fault detection tasks. For instance, Wang et al. (2023) integrated Residual Network-50 residual blocks with convolutional block attention modules (CBAM) to improve fault identification performance. Additionally, Guarido et al. (2021) employed a 2.5D residual neural network for fault detection in seismic volumes, demonstrating the robustness of residual blocks in handling seismic data. Zeng et al. (2024) proposed an attention-based ES-UNet network with model retraining learning for intelligent fault identification, which further supports the effectiveness of attention mechanisms in enhancing fault detection. An et al. (2023) provided a comprehensive review of the current state and future directions for deep learning-based automatic seismic fault interpretation, highlighting the advancements and challenges in this field. As mentioned before, the main difference between all these studies is that we estimate the fault throw directly instead of classifying the data into fault/no-fault binary classification.
Decoder and attention mechanism
The decoder reconstructs the fault throw cube by progressively up sampling the encoded feature maps and combining them with corresponding features from the encoder. The concatenation process is guided by an attention mechanism, which ensures that the decoder focuses on the most relevant features.
The attention unit computes a set of coefficients by combining fine-grained features from the decoder and coarse-grained features from the encoder through 3D convolutions. These coefficients are normalised using batch normalisation, activated using ReLU, and further refined using a sigmoid-activated convolution. The resulting coefficients modulate the coarse-grained features through element-wise multiplication. Finally, the scaled coarse features are concatenated with the fine features.
This attention mechanism, like the methods described by Oktay et al. (2018), has been modified for 3D seismic data by Bi et al. (2021) and is integrated into this model to enhance feature reconstruction.
In our implementation, unlike the models described above that use a sigmoid activation at the final layer, the final convolutional layer employs a linear activation function. This allows the network to produce continuous and unbounded fault-throw values, consistent with the regression objective of the model.
Dilated convolutions
At the lowest scale of the encoder, dilated convolutions are used to expand the receptive field without increasing the number of parameters. This allows the model to capture long-range dependencies and enhance feature extraction from seismic data without exhausting the memory.
Model summary
The model integrates these components into a unified framework. The encoder-decoder structure facilitates multiscale feature extraction and reconstruction, while the SE-residual blocks and attention mechanism refine feature representations. With a total of 5,675,839 trainable parameters, the architecture provides a balanced compromise between model depth and computational efficiency, allowing training and inference on a standard workstation. The model is optimised using mean squared error (MSE) as the loss function, and learning rate is adaptively reduced when validation performance plateaus. A summary of the model architecture is provided in Table 1. Based on the network’s convolutional structure (kernel sizes, strides, and dilation), the effective vertical receptive field (RF) is approximately 111 samples. Theoretically, this allows the model to detect the presence and location of faults of any size; however, it can reliably estimate throw magnitudes only up to approximately half the RF (~50–60 samples), because both the upthrown and downthrown reflectors must fall within the same receptive field. This limitation does not affect fault-segmentation models, which require only pattern detection and not explicit estimation of block separation. Importantly, this is not a limitation of the regression formulation itself but of the current architecture. Increasing the network depth or training with larger input volumes — given sufficient computational resources — would proportionally expand the receptive field and permit accurate estimation of larger throws in future versions of the model.
| Layer | Kernel Size | Features | Input Size (ln, xln, z, feature) | Output Size (ln, xln, z, feature) |
| Input Layer | - | 1 | (128, 128, 128, 1) | (128, 128, 128, 1) |
| Conv3D + SE-Residual Block x2 | (7, 7, 7), (3, 3, 3) | 16 | (128, 128, 128, 1) | (128, 128, 128, 16) |
| Strided Convolution + SE-Residual Block x2 | (3, 3, 3) | 32 | (128, 128, 128, 16) | (64, 64, 64, 32) |
| Strided Convolution + SE-Residual Block x2 | (3, 3, 3) | 64 | (64, 64, 64, 32) | (32, 32, 32, 64) |
| Strided Convolution + SE-Residual Block x2 + Dilated Conv3D | (3, 3, 3) | 128 | (32, 32, 32, 64) | (16, 16, 16, 128) |
| Up-sample + Conv3D + Attention | (5, 5, 5), (1, 1, 1) | 64 | (16, 16, 16, 128) | (32, 32, 32, 64) |
| Up-sample + Conv3D + Attention | (5, 5, 5), (1, 1, 1) | 32 | (32, 32, 32, 64) | (64, 64, 64, 32) |
| Up-sample + Conv3D + Attention | (5, 5, 5), (1, 1, 1) | 16 | (64, 64, 64, 32) | (128, 128, 128, 16) |
| Final Conv3D | (1, 1, 1) | 1 | (128, 128, 128, 16) | (128, 128, 128, 1) |
Table 1. Model architecture summary.
Loss Function
The model is optimised using the Mean Squared Error (MSE) loss, which provided the most stable training and best overall performance in our experiments.
Mean Squared Error (MSE)
The MSE loss is a standard choice for regression tasks due to its simplicity and stability. It measures the average squared difference between the predicted and true fault throw cubes:
where is the total number of voxels, and , are the true and predicted fault throw values at voxel , respectively.
Because fault throw labels are un-normalised and reach magnitudes up to ~84 units, their large numerical contrast with background voxels naturally offsets the voxelcount imbalance, allowing MSE alone to emphasise fault regions effectively.
Evaluation of Masked Mean Squared Error (Masked MSE)
A masked variant of the loss was also evaluated to explicitly emphasise voxels with non-zero fault throw values. The combined loss formulation was defined as:
where the masked term only considers voxels and with non-zero displacement.
A sensitivity analysis was performed for (Table 2) showed that incorporating the masked term consistently degraded performance across all evaluation metrics (MAE, RMSE, and ).
α | Val Loss | MAE | MSE | RMSE | R² |
0 | 2.62 | 0.42 | 2.62 | 1.62 | 0.41 |
0.01 | 9.58 | 0.49 | 2.98 | 1.73 | 0.31 |
0.05 | 10 | 0.56 | 3.07 | 1.75 | 0.28 |
0.1 | 6.4 | 0.47 | 2.93 | 1.71 | 0.32 |
0.2 | 10.57 | 0.45 | 3.38 | 1.84 | 0.21 |
Table 2. Effect of masked loss weighting (α) on validation performance.
The best results were obtained using standard MSE alone (), indicating that explicitly weighing fault regions did not improve generalisation in this case.
Training and validation
The training process for the 3D CNN model was designed to ensure efficient memory utilisation and robust performance. The synthetic dataset, comprising 400 seismic cubes and their corresponding labels, was augmented to 2000 samples through geometric transformations (rotations and flips). This augmentation introduced diversity into the training data, enhancing the model’s generalisation capabilities. The synthetic seismic cubes were globally normalised to the range [0,1] using min-max normalisation, while the fault label cubes were left un-normalised to preserve the true fault throw values. The dataset was split into training and validation sets using an 80-20% split, resulting in 1600 training samples and 400 validation samples.
Training process
Due to GPU memory constraints, the training process was conducted in manageable sub-groups. The training samples, each with dimensions 128×128×128×1, were divided into smaller sub-groups of 400 samples. Each sub-group was processed sequentially in separate runs such that:
During each run, the model was trained on a single chunk of 400 samples for 100 epochs (unless early stopping criteria were met). A batch size of 2 was selected for memory usage limitations. The same validation set (400 samples) was used to monitor the model’s performance during all runs. Model weights were carried forward to the next sub-groups. While this approach enables training under memory constraints, it introduces minor distribution shifts between sub-groups, which are reflected as transient fluctuations in validation loss during early epochs of each training phase.
Callback functions
Two callback functions were employed to optimise training performance and prevent overfitting. The first was an early stopping criterion, which halted training if no improvement in validation loss was observed for 10 consecutive epochs. The second was a learning rate scheduler that reduced the learning rate by a factor of 0.5 whenever the validation loss stagnated for two consecutive epochs. This approach, inspired by Loshchilov and Hutter (2016), accelerates convergence and improves model performance without requiring aggressive learning-rate tuning.
The model was trained using the Adam optimiser (Kingma and Ba, 2014), which has been widely adopted for its robustness and efficiency in deep learning applications.
Performance monitoring
The model’s performance was monitored using training and validation loss metrics. As shown in Figure 10, the observed spikes in validation loss during early epochs are directly related to the sub-group training strategy, and represent expected transient adaptation rather than training instability. Due to GPU memory constraints, training was performed sequentially on subsets of the dataset, each containing 400 samples. At the beginning of each sub-group training phase, the model is exposed to a new subset of data with potentially different structural characteristics and fault distributions. This introduces a temporary distribution shift, leading to transient increases in validation loss. As training progresses within each sub-group, the model adapts to the new data, and the loss stabilises. Notably, these fluctuations diminish in later stages of training, indicating that the model becomes increasingly robust and generalises better across different sub-groups. The validation loss remains slightly lower than the training loss throughout training. This behaviour is attributed to differences in data variability, as training samples are introduced in sequential sub-groups with diverse structural characteristics, while the validation set remains fixed.
Early stopping criteria was triggered in most cases, resulting in a total of 88 epochs across all sub-groups.
The final model achieved a validation MSE (computed over the 400 fixed validation volumes) of approximately 2.62, corresponding to an RMSE of ~1.62 samples and MAE of ~0.42 samples, with an of ~0.41. These results indicate moderate predictive capability, with the model successfully capturing general trends in fault throws while maintaining stable convergence behaviour.
For comparison, a baseline 3D U-Net model without attention mechanisms and SE-residual blocks did not achieve comparable convergence, with validation MSE loss remaining above six samples across all runs, indicating inferior performance relative to the proposed architecture.
Results
The proposed 3D CNN model demonstrated acceptable performance on both synthetic validation data and real-world seismic data, showcasing its ability to detect faults and estimate their throw magnitudes. This section presents a detailed analysis of the model’s inference results on the validation set and its application to real seismic data from the Exmouth Sub-Basin, Australia.
Validation set results
The model’s performance on the validation set is illustrated in Figure 11, which compares the predicted fault throw cubes with the true fault labels. The model successfully identified fault planes across the entire volumes, capturing their orientations and spatial extents. More importantly, the predicted fault throw values generally matched the true values, demonstrating the model’s ability to differentiate between faults based on their displacement magnitudes.
One of the key strengths of the model is its ability to handle complex fault geometries, including intersecting faults and faults with varying throws. For example, in regions where multiple faults intersect, the model predicted the cumulative displacement caused by overlapping fault planes. This capability is particularly valuable in structurally complex areas, where manual interpretation is often challenging and time-consuming.
The voxel-wise crossplot (Figure 12) highlights the relationship between predicted and true fault throw values. The model shows reasonable agreement for small to moderate displacements, with predictions following the general trend of the ground truth. As the throw magnitude increases, the model underestimates larger displacements, producing a compression toward lower predicted values. This behaviour is consistent with the theoretical limitation imposed by the network’s vertical RF: because both the upthrown and downthrown reflectors must fall within the same RF (~50–60 samples), the model becomes less sensitive to very large displacements that exceed this contextual window. This underestimation therefore reflects the architectural constraints of the model rather than instability in training or inconsistencies in the synthetic labels. Voxel-wise evaluation is also highly sensitive to small spatial misalignments and local noise, further contributing to the spread observed at higher throw values.
Real data application: Exmouth Sub-Basin
To evaluate the model’s generalisation capabilities, it was applied to real seismic data from the Exmouth Sub-Basin, located on the Northwest Shelf of Australia. This region records a polyphase extensional tectonic history. During the Late Triassic-Middle to Jurassic (Rhaetian-Callovian) Formation of N-S to NE-SW domino-style extensional faults during the initial rifting phase took place. Continued extension through the Late Jurassic–Early Cretaceous (Berriasian–Valanginian) produced additional NE-trending faults and thick syn-rift successions (Dingo Claystone, Calypso Formation) that accumulated within half-graben subsidence. During Late Cretaceous-Neogene, passive-margin thermal subsidence characterised by polygonal fault systems and regional tilting/inversion occurred. Key stratigraphic markers include the Barrow Delta (Late Tithonian=Valanginian), marking a regional unconformity and transition to carbonate-rich passive-margin fill, and later polygonal fault networks in post-rift strata (Jitmahantakul and McClay 2013; Schenk et al. 2019; Deng et al. 2024).
The dataset, publicly available through the Australian Government’s Geoscience Data Initiative, has been widely used in seismic interpretation and ML studies (e.g., Wu et al., 2019).
The model was applied to the Exmouth dataset using an inference pipeline designed to handle large seismic volumes efficiently. The inference pipeline comprises cropping to manageable cube sizes with selected cube overlaps to avoid the CNN edge effects. The inference is made on the sub-cubes, and the prediction results are averaged in the overlapping zones, then the sub-cubes are concatenated to produce a final fault throw cube with the same size as the input seismic cube.
The results, shown in Figure 13, demonstrate that the predicted fault throw cube exhibits geologically consistent patterns, with fault displacements varying smoothly across the volume. This consistency is a testament to the model’s ability to generalise from synthetic training data to real-world seismic data.
Horizontal and vertical slices extracted from the fault throw cube provide valuable insights into fault relationships and displacement patterns. To have a clearer view of the results, a centreline thinning algorithm is applied to the slices in Figure 14, which shows a series of horizontal slices from the top to the bottom of the inference cube, highlighting variations in fault throw within and between faults. These slices enable interpreters to quickly identify major and minor faults and assess their relative displacements.
A quick analysis of a horizontal slice (Figure 15) reveals the relationship between a central fault and its branches. Vertical sections extracted along lines A and B (Figure 16) show how the throw of the central fault in section B is distributed among its branches in section A. This level of detail allows interpreters to reconstruct fault networks and infer tectonic histories with greater confidence.
For example, in section B, the central (marked by an arrow) fault exhibits a large throw, indicating significant displacement. In section A, this fault splits into two branches (marked by an arrow), with the throw distributed between them. The model reproduced the throw distribution, enabling interpreters to infer the fault’s growth history and its impact on the surrounding strata. This capability is particularly valuable in hydrocarbon exploration, where understanding fault evolution is critical for assessing reservoir connectivity and trap integrity. It is observed that the fault zone prediction is not as accurate when the seismic amplitudes are relatively low and the discontinuities caused by faulting are not clearly defined.
The extraction of one of the major faults in the area (Figure 17), displaying voxel-wise throw magnitudes along the fault surface, yields several important insights. A structure that would conventionally be interpreted as a single fault is resolved by our method into multiple, closely spaced fault segments with similar orientations. Each sub-segment exhibits a gradual decrease in throw magnitude towards its tips, while abrupt throw variations along the surface suggest the presence of fault intersections or branching. Notably, the model demonstrates strong generalisation in throw estimation: the derived throw profile aligns with patterns observed in the seismic data, rather than merely replicating the idealised Gaussian throw distributions used in the synthetic training set.
To further evaluate model performance on real data quantitatively, the throw prediction cube was multiplied by the seismic sample rate, 3 ms here, converting it to time. Figure 18 shows two representative seismic sections with annotated measurements of the predicted throw (P) versus manually measured throws (GT) using vertical horizon separation at different faults. Figure 19 presents a crossplot of predicted versus measured values.
The results demonstrate that the model captures fault throw magnitudes with their relative variations with acceptable accuracy. Note that the maximum observed throw in this test dataset is approximately 30 ms, corresponding to 10 vertical samples, which is within the range where the model demonstrates reliable prediction performance based on the synthetic validation analysis.
Model robustness and interpretability
The interpretability of the model’s outputs is a key strength. By providing continuous fault throw estimates, the model enables interpreters to quickly assess fault hierarchies and prioritise faults based on their displacement magnitudes. This capability significantly enhances interpretation speed and accuracy, reducing the time required for manual fault picking and analysis. As with all machine learning-based approaches, thorough quality control and validation of the results are essential. Given that the model generally preserves the relative variation of throw along the fault surface, it is recommended that actual throw magnitudes be evaluated at multiple locations along the fault plane. For faults of particular importance, post-prediction scaling of the extracted throw magnitudes should be considered to ensure accurate structural interpretation.
Discussion
The proposed 3D CNN-based fault throw determination model demonstrates feasibility of treating fault throw estimation as a regression problem directly from seismic amplitude data. By moving beyond traditional classification approaches, the model provides continuous displacement estimates, enabling a more quantitative and geologically meaningful characterisation of fault systems. The results from both synthetic experiments and real seismic data indicate that the model is capable of capturing spatial variations in fault throw and reproducing structurally consistent displacement patterns.
A key contribution of this study lies in reformulating fault interpretation as a regression task. Unlike classification-based approaches that identify only the presence or absence of faults, the proposed model outputs continuous fault throw values, enabling interpreters to differentiate between major and minor faults based on displacement. This facilitates a rapid understanding of fault hierarchies and tectonic regimes that binary classification frameworks cannot supply. The model performance on real seismic data from the Exmouth Sub-Basin demonstrates its ability to generalise key structural patterns from synthetic training data to real-world scenarios. The predicted fault throw cubes exhibit geologically consistent patterns, aligning with extensional tectonic settings.
Another important aspect of the model is its interpretability. By providing continuous fault throw estimates, the model simplifies fault interpretation workflows. Interpreters can quickly identify fault hierarchies, assess displacement patterns, and infer tectonic histories, significantly reducing the time and effort required for manual analysis.
The main limitation is related to the input cube size and the model’s RF. Although the model was trained on 128×128×128 volumes, its RF — determined by the accumulated kernel sizes, strides, and dilation — is approximately 111 samples. To estimate fault throw reliably, both the upthrown and downthrown reflectors must fall within the same RF. This constrains the practically resolvable throw magnitude to roughly half the RF (~50–60 samples), depending on the fault’s vertical position within the input cube. This is an architectural constraint rather than a limitation of the regression formulation itself. Increasing the network depth or training with larger input cubes would proportionally expand the receptive field and enable accurate estimation of larger throws in future model versions, when sufficient computational resources are available.
Furthermore, the synthetic training data included only normal faults, which restricts the model’s applicability to extensional tectonic settings. Future work should expand the dataset to include compressional fault systems, such as reverse and thrust faults, to enhance the model’s versatility. Computational constraints also remain a consideration. Training the model on larger input cubes or more diverse datasets or increasing the model’s complexity may require significant computational resources. Addressing these constraints will be critical for scaling the model to more complex and diverse geological settings. These limitations do not undermine the feasibility of the regression formulation but highlight areas where future dataset expansions and architectural scaling can further improve quantitative behaviour.
Future work will focus on addressing these limitations by expanding the diversity and scale of the training dataset, including additional fault types and larger spatial contexts. Extending the regression framework to predict additional fault attributes, such as dip and strike, represents a natural progression of this work. In addition, the integration of transfer learning strategies may improve adaptation to real seismic data sets from different geological settings. Emerging architectures, such as transformer-based models, also offer potential for handling larger datasets and capturing long-range spatial dependencies, which could further enhance fault characterisation capabilities.
Conclusion
This study demonstrates the potential of 3D CNN-based fault throw estimation to enhance seismic interpretation workflows. The proposed model delineates faults and estimates throw magnitudes, providing geologically consistent results that align with manual interpretations. By integrating fault throw estimation into automated fault detection, this approach offers a powerful tool for rapidly understanding subsurface structural complexities and supporting informed decision-making in hydrocarbon exploration and geohazard assessment. Notably, the inference process on large datasets takes just a few minutes, a key advantage of pre-trained models. This enables quick application and a rapid understanding of the structural framework in areas of interest.
The success of this model on real seismic data from the Exmouth Sub-Basin highlights its practical relevance and potential for widespread adoption. Future advancements, including expanded dataset diversity and increased input cube sizes, will further enhance the model’s capabilities and establish its role as a useful component of modern seismic interpretation.
Author contribution
H.H. (Hesham Hasan) conducted the research, performed the data analysis, and wrote the manuscript. W.M.M. (Walid M. Mabrouk) supervised the research, provided guidance on the experimental design and data interpretation, and critically reviewed the manuscript. A.M. (Ahmed Metwally) supervised the research, provided conceptual guidance, and critically reviewed the manuscript. All authors approved the final version of the manuscript.
Data availability
The datasets generated and analysed during the current study and the custom Python code used to generate and visualise the results (including 3D visualisation) are available from the corresponding author, Hesham Hasan, upon request. Please contact Hesham Hasan at heshamahmed@gstd.sci.cu.edu.eg for access to the data.
References
- Altamar, R.P. [2024] Advances in basin modeling using Markov chain: Facies deposition in response to sea level variations and random sequence of geologic processes. The Leading Edge, 43(11), pp. 765-773.
- An, Y., Du, H., Ma, S., Niu, Y., Liu, D., Wang, J., Du, Y., Childs, C., Walsh, J. and Dong, R. [2023] Current state and future directions for deep learning based automatic seismic fault interpretation: A systematic review. Earth-Science Reviews, 243, p.104509.
- Ashtari, A. [2024] Automated fault detection using Shi-Tomasi corner detection algorithm in seismic data. Journal of Geophysical Research.
- Bi, Z., Wu, X., Geng, Z. and Li, H. [2021] Deep relative geologic time: A deep learning method for simultaneously interpreting 3-D seismic horizons and faults. Journal of Geophysical Research: Solid Earth, 126(9), p.e2021JB021882.
- Deng, H., McClay, K., Chen, H., Finch, E., Jablonski, D. and Jitmahantakul, S. [2024] Structural inheritance controls crustal-scale extensional fault-related folding in the Exmouth and Dampier Sub-basins, North West Shelf, Australia. AAPG Bulletin, 108(7), pp.1291-1326.
- Gao, K. [2024] Iterative multitask learning and inference from seismic images. Geophysical Journal International, 236(1), pp.565-592.
- Guarido, M., Wozniakowska, P., Emery, D.J., Lume, M., Trad, D.O. and Innanen, K.A. [2021] November. Fault detection in seismic volumes using a 2.5 D residual neural networks approach. SEG International Exposition and Annual Meeting, Expanded Abstracts (p. D011S066R002).
- Guitton, A. [2018] 3D convolutional neural networks for fault interpretation. 80th EAGE Annual Conference and Exhibition, Extended Abstracts.
- Guo, B., Li, L. and Luo, Y. [2018] A new method for automatic seismic fault detection using convolutional neural network. SEG International Exposition and Annual Meeting, Expanded Abstracts (pp. SEG-2018).
- He, K., Zhang, X., Ren, S. and Sun, J. [2016] Deep residual learning for image recognition. Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 770-778).
- Hu, J., Shen, L. and Sun, G. [2018] Squeeze-and-excitation networks. Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 7132-7141).
- Jiang, Y. [2017] Detecting geological structures in seismic volumes using deep convolutional neural networks. Master’s thesis.
- Jitmahantakul, S. and McClay, K. [2013] Late Triassic-Mid-Jurassic to Neogene Extensional Fault Systems in the Exmouth Sub-Basin, Northern Carnarvon Basin, North West Shelf, Western Australia.
- Kingma, D.P. and Ba, J. [2014] Adam: A method for stochastic optimization, ArXiv Prepr. arXiv preprint arXiv:1412.6980, 10.
- Loshchilov, I. and Hutter, F. [2016] Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983.
- Merrifield, T.P., Griffith, D.P., Zamanian, S.A., Gesbert, S., Sen, S., De La Torre Guzman, J., Potter, R.D. and Kuehl, H. [2022] Synthetic seismic data for training deep learning networks. Interpretation, 10(3), SE31-SE39.
- Oktay, O., Schlemper, J., Folgoc, L.L., et al. [2018] Attention U-Net: Learning where to look for the pancreas. arXiv preprint arXiv:1804.03999.
- Ronneberger, O., Fischer, P. and Brox, T. [2015] U-net: Convolutional networks for biomedical image segmentation. International Conference on Medical image computing and computer-assisted intervention (pp. 234-241). Cham: Springer international publishing.
- Schenk, O., Dempsey, C., Benson, R., Cheng, M., Tewari, S., Karvelas, A. and Bancalà, G. [2019] New insights into the Exmouth Sub-basin from basin and petroleum system modelling. ASEG Extended Abstracts, 2019(1), pp.1-5.
- Tang, Z., Wu, B., Wu, W. and Ma, D. [2023] Fault detection via 2.5 d transformer u-net with seismic data pre-processing. Remote Sensing, 15(4), p.1039.
- Wang, J., Ma, S., An, Y. and Dong, R. [2024] A comparative study of vision transformer and convolutional neural network models in geological fault detection. IEEE Access, 12, pp.136148-136159.
- Wang, Z., You, J., Liu, W. and Wang, X. [2023] Transformer assisted dual U-net for seismic fault detection. Frontiers in Earth Science, 11, p.1047626.
- Wei, X.L., Zhang, C.X., Kim, S.W., Jing, K.L., Wang, Y.J., Xu, S. and Xie, Z.Z. [2022] Seismic fault detection using convolutional neural networks with focal loss. Computers & Geosciences, 158, p.104968.
- Wu, X., Liang, L., Shi, Y. and Fomel, S. [2019] FaultSeg3D: Using synthetic data sets to train an end-to-end convolutional neural network for 3D seismic fault segmentation. Geophysics, 84(3), pp.IM35-IM45.
- Xiong, W., Ji, X., Ma, Y., Wang, Y., AlBinHassan, N.M., Ali, M.N. and Luo, Y. [2018] Seismic fault detection with convolutional neural network. Geophysics, 83(5), pp.O97-O103.
- Zeng, L., Tang, H. and Liu, X. [2024] A Method for Intelligent Identification of Seismic Faults Using an Attention-Based Es-Unet Network with Model Re-Training Learning. Available at SSRN 4517072.
