Wu - 2019-FaultSeg3D Using Synthetic Datasets To Train An End-To-End Convolutional Neural Network For 3D Seismic Fault Segmentation. GEOPHYSICS

GEOPHYSICS
FaultSeg3D: using synthetic datasets to train an end-to-end

convolutional neural network for 3D seismic fault
segmentation
Journal: Geophysics
Downloaded from library.seg.org by Lund University on 02/18/19. For personal use only.
Manuscript ID GEO-2018-0646.R1
Manuscript Type: Technical Paper
Keywords: faults, interpretation, seismic attributes
Area of Expertise: Interpretation Methods

GEOPHYSICS
This paper presented here as accepted for publication in Geophysics prior to copyediting and composition.
© 2019 Society of Exploration Geophysicists.
Page 1 of 34 GEOPHYSICS
1
2
3
4
5
FaultSeg3D: using synthetic datasets to train an end-to-end
6
7
8
convolutional neural network for 3D seismic fault
9
10
11
segmentation
12
13
14 Xinming Wu1,2 , Luming Liang3 , Yunzhi Shi2 and Sergey Fomel2
15
16 1 Laborary of Seismology And Physics of Earth’s Interior, School of Earth and Space
17
18 Sciences, University of Science and Technology of China, Hefei, China. 2 Bureau of
19
20
21
Economic Geology, The University of Texas at Austin, TX, USA. 3 Uber, USA.
22
23 E-mail: xinwucwp@gmail.com.
24
25 (February 8, 2019)
26
27 Running head: CNN for 3D fault segmentation
GEOPHYSICS
28
29
30
31
32
ABSTRACT
33
34
35 Delineating faults from seismic images is a key step for seismic structural interpretation,
36
37 reservoir characterization and well placement. In conventional methods, faults are con-
38
39 sidered as seismic reflection discontinuities and are detected by calculating attributes that
40
41
42
estimate reflection continuities or discontinuities. We consider fault detection as a binary
43
44 image segmentation problem of labelling a 3D seismic image with ones on faults and zeros
45
46 elsewhere. We perform an efficient image-to-image fault segmentation by using a supervised
47
48 fully convolutional neural network. To train the network, we automatically create 200 3D
49
50
51 synthetic seismic images and corresponding binary fault labelling images, which are shown
52
53 to be sufficient to train a good fault segmentation network. Since a binary fault image is
54
55 highly imbalanced between zeros (non-fault) and ones (fault), we use a class-balanced bi-
56
57 nary cross-entropy loss function to adjust the imbalance so that the network is not trained
58
59
60 1
GEOPHYSICS Page 2 of 34
1
2
3
4 or converged to predict only zeros. After training with only the synthetic datasets, the
5
6
7
network automatically learns to calculate rich and proper features that are important for
8
9 fault detection. Multiple field examples show that the neural network (trained by only
10
11 synthetic datasets) can much more accurately and efficiently predict faults from 3D seismic
12
13 images than the conventional methods. With a TITAN Xp GPU, the training processing
14
15
16
takes about 2 hours and predicting faults in a 128 ⇥ 128 ⇥ 128 seismic volume takes only
17
18 milliseconds.
19
20
21
22
23
24
25
26
27
GEOPHYSICS
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60 2
1
2
3
4 INTRODUCTION
5
6
7
Faults are typically recognized as lateral reflection discontinuities in a 3D seismic image.
8
9
10 Based on this observation, numerous methods have been proposed to detect faults by cal-
11
12 culating attributes of measuring seismic reflection continuity such as semblance (Marfurt
13
14 et al., 1998) and coherency (Marfurt et al., 1999; Li and Lu, 2014; Wu, 2017), or reflection
15
16
17
discontinuity such as variance (Van Bemmel and Pepper, 2000; Randen et al., 2001), and
18
19 gradient magnitude (Aqrawi and Boe, 2011). These seismic attributes, however, can be sen-
20
21 sitive to noise and stratigraphic features, which also correspond to reflection discontinuities
22
23 in a seismic image. This means that measuring seismic reflection continuity or discontinuity
24
25
26 alone is insufficient to detect faults (Hale, 2013).
27
GEOPHYSICS
28
Faults are typically more vertically aligned while the stratigraphic features mostly ex-
29
30
31 tend laterally. Based on this observation, Gersztenkorn and Marfurt (1999) suggest to use
32
33 vertically elongated windows in computing seismic coherence to enhance faults while sup-
34
35 pressing the stratigraphic features. Similarly, some other authors (Bakker, 2002; Hale, 2009;
36
37
Wu, 2017) apply smoothing in directions perpendicular to seismic reflections in computing
38
39
40 coherence or semblance by assuming faults are typically normal to reflections. However,
41
42 faults are seldom vertical or are not necessarily perpendicular to seismic reflections. There-
43
44 fore, some authors (Hale, 2013; Wu and Hale, 2016) propose to smooth both the numerator
45
46
and denominator of the semblance along fault strikes and dips to compute fault-oriented
47
48
49 semblance or fault likelihood. Calculating fault-oriented semblance, however, is computa-
50
51 tionally more expensive than the previous attributes because it requires scanning over all
52
53 possible combinations of fault strikes and dips to find the maximum fault likelihoods.
54
55
56 Some fault detection methods start with some initial fault attributes and further enhance
57
58
59
60 3
1
2
3
4 them by smoothing the attributes along fault strikes and dips (Ne↵ et al., 2000; Cohen et al.,
5
6
7
2006; Wu and Zhu, 2017). These methods also need to smooth the fault attributes over all
8
9 possible combinations of fault strikes and dips to obtain the best enhanced fault features.
10
11 Similarly, some authors (Pedersen et al., 2002, 2003) propose to enhance fault features along
12
13 paths of “artificial ants” by assuming the paths follow faults. Wu and Fomel (2018) propose
14
15
16
an efficient method to extract optimal surfaces following maximum fault attributes and use
17
18 these optimal surfaces to vote for enhanced fault images of fault probabilities, strikes and
19
20 dips.
21
22
23 Recently, some convolutional neural network (CNN) methods have been introduced to
24
25 detect faults by pixel-wise fault classification (fault or non-fault) with multiple seismic
26
27
attributes (Huang et al., 2017; Guitton, 2018; Zhao and Mukhopadhyay, 2018; Di et al.,
GEOPHYSICS
28
29
30 2018; Guo et al., 2018). Wu et al. (2018) use a CNN-based pixel-wise classification method
31
32 to not only predict fault probability but also estimate fault orientations at the same time.
33
34 These methods need to choose a local window or cube to make fault prediction at every
35
36
image pixel, which is computationally highly expensive, especially in 3D fault detection.
37
38
39 In this paper, we consider the fault detection as a more efficient end-to-end binary image
40
41 segmentation problem by using convolution neural networks. Image segmentation has been
42
43 well studied in computer science and multiple powerful CNN architectures (e.g., Girshick
44
45
et al., 2014; Ronneberger et al., 2015; Xie and Tu, 2015; Ren et al., 2015; Badrinarayanan
46
47
48 et al., 2017; He et al., 2017) have been proposed to obtain superior segmentation results.
49
50
51 In this paper, we use an efficient end-to-end CNN, simplified from U-net (Ronneberger
52
53 et al., 2015), to perform our task of 3D binary fault segmentation. We simplify the original
54
55 U-net by reducing the number of convolutional layers and features at each layer, which
56
57 significantly saves GPU memory and computational time but still preserves high perfor-
58
59
60 4
1
2
3
4 mance in our 3D fault detection tasks. Considering a fault binary image is highly biased
5
6
7
with mostly zeros but only very limited ones on the faults, we use a balanced cross-entropy
8
9 loss function for optimizing the parameters of our CNN model. To train and validate the
10
11 neural network, we design a workflow to automatically generate 3D synthetic seismic and
12
13 corresponding fault images. In this workflow, the seismic folding and faulting structures,
14
15
16
wavelet peak frequencies, and noise are defined by a set of parameters and each param-
17
18 eter can be chosen from some predefined range. By randomly choosing a combination of
19
20 these parameters within the predefined ranges, we are able to generate numerous unique
21
22 seismic images and corresponding fault labelling images. We train and validate, respec-
23
24
25 tively, by using 200 and 20 pairs of synthetic seismic and fault images, which turned to
26
27 be sufficient to train a good CNN model for our fault detection tasks. Although trained
GEOPHYSICS
28
29 by using only synthetic seismic datasets, our CNN model can work much better and more
30
31 efficiently than the conventional methods for 3D fault detection in field seismic datasets
32
33
34 that are recorded at totally di↵erent surveys. By using a TITAN Xp GUP, our CNN model
35
36 takes less than 5 minutes to predict faults in a large seismic volume with 450 ⇥ 1950 ⇥ 1200
37
38 samples.
39
40
41
42
TRAINING DATASETS
43
44
45
46 Training and validating a CNN model often requires a large amount of images and corre-
47
48 sponding labels. Manually labelling or interpreting faults in a 3D seismic image could be
49
50 extremely time-consuming and highly subjective. In addition, inaccurate manual interpre-
51
52
tation, including mislabeled and unlabeled faults, may mislead the learning process. To
53
54
55 avoid these problems, we propose an e↵ective and efficient way to create synthetic seismic
56
57 images and corresponding fault labels for training and validating our CNN model.
58
59
60 5
1
2
3
4 Synthetic seismic and fault images
5
6
7
8 The workflow we use to create synthetic seismic and fault images is similar to the one used
9
10 for generating synthetic datasets by Wu and Hale (2016). In this workflow, we first generate
11
12 a 1D horizontal reflectivity model r(x, y, z) (Figure 1a) with a sequence of random values
13
14
that are in the range of [ 1, 1]. We then create some folding structures in the reflectivity
15
16
17 model by vertically shearing the model. We define the folding structures by using the
18
19 following function:
20
k=N ck )2 +(y dk )2
21 1.5z X
(x
2 2
22 s1 (x, y, z) = a0 + bk e k , (1)
zmax
23 k=1
24 1.5z
25 which combines with multiple 2D Gaussian functions and a linear scale function zmax . The
26
27 combination of 2D Gaussian functions yields laterally varying folding structures while the
GEOPHYSICS
28
29 linear scale function damps the folding vertically from below to above. In this equation,
30
31 each combination of the parameters a0 , bk , ck , dk , and yields some specific spatially
k
32
33
34 varying folding structures in the model. By randomly choosing each of the parameters from
35
36 the predefined ranges, we are able to create numerous models with unique structures. With
37
38 the shift map s1 (x, y, z), we use a sinc interpolation to vertically shift the original reflectivity
39
40
model r(x, y, z) to obtain a folded model r(x, y, z + s1 (x, y, z)) as shown in Figure 1b. In
41
42
43 order to further increase the complexity of the structures in the model, we also add some
44
45 planar shearing defined as follows:
46
47
48 s2 (x, y, z) = e0 + f x + gy, (2)
49
50
51 where the shearing shifts are laterally planar while vertically invariant. The parameters
52
53 e0 , f, and g, again, are randomly chosen from some predefined ranges. By sequentially
54
55 applying the planar shifts s2 (x, y, z) to the previously folded model r(x, y, z + s1 (x, y, z)),
56
57 we obtain a new reflectivity model r(x, y, z + s1 + s2 ) as shown in Figure 1c.
58
59
60 6
1
2
3
4 After obtaining a folded reflectivity model, we then add planar faulting in the model.
5
6
7
Although all the faults are planar, the fault orientations (dip and strike) and displacements
8
9 of the faults are all di↵erent from each other. The fault displacements on each fault are
10
11 allowed to be spatially varying along the directions of fault strike and dip. The common
12
13 patterns of fault displacement distribution have been discussed by some authors (Muraoka
14
15
16
and Kamata, 1983; Mansfield and Cartwright, 1996; Stewart, 2001). In generating faults in
17
18 our synthetic models, we define the fault displacement distributions as a Gaussian function
19
20 or linear function. In the case of Gaussian distribution, the fault displacements decrease
21
22 from the fault center in all directions along the fault plane. In the other case of linear
23
24
25 distribution, the fault displacements linearly increase (normal fault) or decrease (reverse
26
27 fault) in the fault dip direction along the fault plane. The maximum fault displacement for
GEOPHYSICS
28
29 each fault is randomly chosen in the range between 0 and 40 samples. From our experi-
30
31 ence, the images with more faults are more e↵ective than those with less faults to train a
32
33
34 convolutional neural network for fault segmentation. We therefore add more than 5 faults
35
36 within a training image with the size of 128 ⇥ 128 ⇥ 128. However, these faults should not
37
38 be too close to each other as shown in Figure 1d, where we have added 6 planar faults.
39
40
41 After creating a folded and faulted reflectivity model (Figure 1d), we finally convolve
42
43 this model with a Ricker wavelet to obtain a 3D seismic image shown in Figure 1e. The
44
45
peak frequency of the wavelet is also randomly chosen from a predefined range. Note that
46
47
48 we convolve the reflectivity model with a wavelet after (not before) creating the folding and
49
50 faulting in the model because the convolution will blur the sharp discontinuities near faults
51
52 and therefore make the faults look more realistic. To further improve the realism of the
53
54
55
synthetic seismic image, we also add some random noise to the image as shown in Figure 1f.
56
57 From this noisy image (Figure 1f), we crop a final training seismic image (Figure 2a) with
58
59
60 7
1
2
3
4 the size of 128 ⇥ 128 ⇥ 128 to avoid the artifacts near the boundaries. Figure 2b shows
5
6
7
the corresponding binary fault labelling image, where the faults are labelled by ones at two
8
9 pixels adjacent to the faults from both the hanging wall and footwall sides.
10
11
12 By using this workflow, we randomly choose parameters of folding, faulting, wavelet peak
13
14 frequency and noise to obtain 200 pairs of 3D unique seismic images and corresponding fault
15
16 labelling images. We can actually generate much more unique training datasets but we found
17
18
200 pairs of images are sufficient to train a pretty good neural network for fault segmenta-
19
20
21 tion. Using the same workflow, we also automatically generated 20 pairs of seismic and fault
22
23 labelling images for the validation. We have made all these training and validation datasets
24
25 freely available through our GitHub account: https://github.com/xinwucwp/faultSeg.
26
27
GEOPHYSICS
28
29 Data augmentation
30
31
32
33 Creating unique training seismic and fault labelling images, as discussed above, is crucial
34
35 to successfully train a fault segmentation neural network. Data augmentation during the
36
37 training is also helpful to increase the diversity of the datasets and to prevent the neural
38
39
40 network from learning irrelevant patterns. We apply simple data augmentations including
41
42 vertical flip and rotation around the vertical time or depth axis. To avoid interpolation
43
44 and artifacts near boundaries, we rotate the seismic and fault labelling volumes by only
45
46 three options of 90 , 180 and 270 . As our input seismic and fault labelling volumes are
47
48
49 128 ⇥ 128 ⇥ 128 cubes, the flip and rotation will preserve the image size without needing
50
51 interpolation or extrapolation. Note that we do not want to rotate the seismic and fault
52
53 volumes around the inline or crossline axis because it will yield vertical seismic structures
54
55 and flat faults, which are geologically unrealistic.
56
57
58
59
60 8
1
2
3
4 FAULT SEGMENTATION BY CNN
5
6
7
We consider 3D fault detection as an image segmentation problem of labelling ones on faults
8
9
10 while zeros elsewhere in a 3D seismic image. We achieve such fault segmentation by using
11
12 a simplified version of U-Net, an end-to-end fully convolutional neural network, which was
13
14 first proposed by Ronneberger et al. (2015) for biomedical image segmentation and then
15
16
17
was widely used for many other image segmentation problems. In 3D seismic images,
18
19 the distribution of fault samples and non-fault samples is typically highly imbalanced, we
20
21 therefore use a balanced binary cross-entropy loss to optimize the parameters of the network
22
23 as discussed by Xie and Tu (2015).
24
25
26
27
CNN architecture
GEOPHYSICS
28
29
30
31 We started our research on fault segmentation by using the original U-net architecture (Ron-
32
33 neberger et al., 2015), which turned to be more complicated than necessary for our problem
34
35
of fault detection. We reduce the convolutional layers and features at each layer to save
36
37
38 memory and computation but still preserve good performance in fault detection.
39
40
41
The finally simplified U-net that we use for 3D fault detection is shown in Figure 3,
42
43 where an input 3D seismic image is fed to a network that contains a contracting path (left
44
45 side) and an expansive path (right side) as in the original U-net architecture. In the left
46
47 contracting path, each step contains two 3 ⇥ 3 ⇥ 3 convolutional layers followed by a ReLU
48
49
50 activation and a 2⇥2⇥2 max pooling operation with stride 2 for downsampling. We double
51
52 the number of features after each step. Every step in the right expansion path contains an
53
54 2⇥2⇥2 upsampling operation, a concatenation with features from the left contracting path,
55
56 and two 3 ⇥ 3 ⇥ 3 convolutional layers followed by a ReLU activation. Di↵erent from the
57
58
59
60 9
1
2
3
4 original U-net architecture, we do not include a 2 ⇥ 2 ⇥ 2 “up-convolution” layer after each
5
6
7
upsampling as in the original expansion path. The upsampling operation is implemented
8
9 by using the function UpSampling3D defined in Keras (Chollet et al., 2015). The final
10
11 output layer is a 1 ⇥ 1 ⇥ 1 convolutional layer with a sigmoid activation to map each 16-
12
13 component feature vector to a probability value in the output fault probability map, which
14
15
16
has the same size as the input seismic image. This simplified U-net architecture totally
17
18 consists of 15 convolutional layers, reduced from 23 convolutional layers in the original U-
19
20 net architecture. The number of features at these convolutional layers is also significantly
21
22 reduced from the original architecture.
23
24
25
26
27
Balanced cross-entropy loss
GEOPHYSICS
28
29
30 The following binary cross-entropy loss function is widely used in the binary segmentation
31
32 of a common image:
33
34 i=N i=N
X X
35 L= yi log(pi ) (1 yi ) log(1 pi ), (3)
36
i=0 i=0
37
38
39
where N denotes the number of pixels in the input 3D seismic image. yi represents true
40
41 binary labels and pi represents prediction probabilities (0 < pi < 1) computed from the
42
43 sigmoid activation in the last convolutional layer. As the true labels yi are binary values
44
45 (0 or 1), the first term measures the prediction errors at the image pixels labelled by ones
46
47
48 while the second term measures prediction errors at the pixels labeled by zeros.
49
50
This loss function works well for binary segmentation of common images, where the
51
52
53 distribution of zero/non-zero samples are more or less balanced. This loss function, however,
54
55 is not suitable to measure the errors of fault segmentation, where more than 90 percent
56
57 samples are non-fault samples (labelled by zeros) while the fault samples (labelled by ones)
58
59
60 10
1
2
3
4 are very limited. If we train the neural network using this loss function, the network can
5
6
7
easily converge to the wrong direction and make zero predictions everywhere because zero
8
9 prediction is a good solution to this loss function in the fault segmentation problem.
10
11
12 To solve this problem, we use the following balanced cross-entropy loss function as
13
14 discussed by Xie and Tu (2015):
15
16 i=N
X i=N
X
17 L= yi log(pi ) (1 ) (1 yi ) log(1 pi ), (4)
18 i=0 i=0
19 Pi=N
(1 yi )
20 where = i=0
N represents the ratio between non-fault pixels and the total image
21
22 pixels while 1 denotes the ratio of fault pixels in the 3D seismic image.
23
24
25
26 Training and validation
27
GEOPHYSICS
28
29
30 We train the convolutional neural network by using 200 pairs of synthetic 3D seismic and
31
32 fault images that are automatically created as in Figures 1 and 2. The validation dataset
33
34 contains another 20 pairs of such synthetic seismic and fault images, which are not used in
35
36
the training dataset. Considering the amplitude values of di↵erent real seismic images can
37
38
39 be much di↵erent from each other, we convert all the training seismic images to one-channel
40
41 grayscale images with values in the range from 0 to 255.
42
43
44 The size of each 3D seismic or fault image is 128 ⇥ 128 ⇥ 128. We choose this relatively
45
46 small size because the memory of our GPU is limited to 12 GB. We would suggest to choose
47
48 a larger size if the GPU memory is allowed. We feed the 3D seismic images to the neural
49
50
51 network in batches and each batch contains 4 images, which consist of an original imageand
52
53 the same image rotated around the vertical time/depth axis by 90 , 180 and 270 . We did
54
55 not try a larger batch size, again, because of the GPU memory limitation. We use the Adam
56
57 method (Kingma and Ba, 2014) to optimize the network parameters and set the learning
58
59
60 11
1
2
3
4 rate to be 0.0001. We train the network with 25 epochs and all the 200 training images are
5
6
7
processed at each epoch. As shown in Figure 4, both the training and validation accuracies
8
9 gradually increase to 95% while the training and validation loss converges to 0.01 after 25
10
11 epochs.
12
13
14 To verify the CNN model trained with 25 epochs, we apply this trained model together
15
16 with another seven commonly used fault detection methods to the synthetic seismic volume
17
18 (Figure 2a), which was not included in the training datasets. Figures 5a⇠ 5h show all
19
20
21 the eight fault detection results that are, respectively, computed by using the methods of
22
23 C3 (Gersztenkorn and Marfurt, 1999), C2 (Marfurt et al., 1999), planarity (Hale, 2009),
24
25 structure-oriented linearity (Wu, 2017), structure-oriented semblance (Hale, 2009), fault
26
27
likelihood (Hale, 2013; Wu and Hale, 2016), optimal surface voting (Wu and Fomel, 2018)
GEOPHYSICS
28
29
30 and our CNN-based segmentation. The input for the optimal surface voting method is
31
32 the planarity volume (Figure 5c) and the input for all the other methods is the amplitude
33
34 volume (Figure 2a). Compared to the first five methods, the fault likelihood and optimal
35
36
surface voting methods provide better fault detections where the fault features are less noisy
37
38
39 and can be more continuously tracked. Our CNN method achieves the best performance in
40
41 computing an accurate, clean and complete fault detection, which is most consistent with
42
43 the true fault labelling shown in Figure 2b
44
45
46 To quantitatively evaluate the fault detection methods, we further calculate the precision-
47
48 recall (Martin et al., 2004) and receiver operator characteristic (ROC) (Provost et al., 1998)
49
50
51 curves shown in Figure 6. From the precision-recall curves (Figure 6a), we can clearly ob-
52
53 serve that our CNN method (red curve in Figure 6a) provides the highest precisions for
54
55 all the choices of recall. The precisions of the fault likelihood (orange curve in Figure 6a)
56
57 and optimal surface voting (magenta curve in Figure 6a) methods are relatively lower than
58
59
60 12
1
2
3
4 the CNN method but are higher than the other 5 methods. The ROC curves in Figure 6b
5
6
7
provide similar evaluations of the methods. In the next section, we will use the same CNN
8
9 model (trained by only synthetic datasets) to four field seismic images that are acquired at
10
11 di↵erent surveys. In this highly strict precision evaluation, the fault detections are expected
12
13 to perfectly match the true fault labels with the thickness of only two samples. However,
14
15
16
all the methods should have higher precisions if we consider each fault is a thicker zone and
17
18 all fault detections within the zone are good enough.
19
20
21
22 Applications
23
24
25
It might not be surprising that the CNN model, trained by synthetic datasets, works well to
26
27
GEOPHYSICS
28 detect faults in a synthetic seismic image (Figure 5h) that is also created by using the same
29
30 workflow for creating the training datasets. We further test the same CNN model on 4 field
31
32 seismic images that are acquired at di↵erent surveys. To be consistent with the synthetic
33
34
training seismic images, all the field seismic images are converted to one-channel grayscale
35
36
37 images with values in the range from 0 to 255. We compare our fault prediction results with
38
39 the thinned fault likelihood (Hale, 2013; Wu and Hale, 2016), which is a superior attribute
40
41 (better than most of the conventional attributes (Figures 5 and 6)) for fault detection.
42
43
44 The first 3D seismic volume in Figure 7a is a subset (128 (vertical)⇥384 (inline)⇥512
45
46 (crossline) samples) extracted from the Netherlands o↵-shore F3 block seismic data, which
47
48
49 is graciously provided by the Dutch Government through TNO and dGB Earth Sciences.
50
51 Multi-oriented faults are apparent within this 3D seismic volume. Figure 7b shows the
52
53 fault probability image predicted by using the trained CNN model. The color in this fault
54
55 image represents fault probability, which is computed by the sigmoid activation in the
56
57
58
59
60 13
1
2
3
4 last convolutional layer. Although trained by only synthetic datasets, this CNN model
5
6
7
works pretty well to provide a clean and accurate prediction of faults in this field seismic
8
9 image. In this CNN fault probability image, most fault features have very high probabilities
10
11 (close to 1) and only very limited noisy features are observed. Although we added only
12
13 planar faults in the training datasets, the networks actually learns to detect curved faults
14
15
16
in the field seismic image as shown on the time slice in Figure 7b. Figures 7c and 7d,
17
18 respectively, show the fault likelihood attribute (Hale, 2013; Wu and Hale, 2016) before and
19
20 after thinning. The thinned fault likelihood (Figure 7d) works fine to highlight the faults
21
22 within this seismic image. However, a lot more noisy features are observed than in the
23
24
25 CNN fault probability image (Figure 7b). In addition, as denoted by the yellow arrows on
26
27 the inline slice (Figure 7d), the fault-oriented smoothing in calculating the fault likelihood
GEOPHYSICS
28
29 actually extends the fault features beyond the top of true faults. Also, the fault likelihood
30
31 is computed from the semblance/coherence of seismic reflections, which can be sensitive to
32
33
34 noisy reflections (red features on the crossline in Figure 7d) but insensitive to the faults
35
36 with small fault displacements (like those faults denoted by white arrows in Figure 7d). On
37
38 the other hand, the trained CNN model is more robust to noise and can better measure the
39
40
probability of the faults with small displacements.
41
42
43 The second 3D seismic image shown in Figure 8a is graciously provided by Clyde
44
45
Petroleum Plc. through Paradigm. Di↵erent from the previous synthetic and field ex-
46
47
48 amples, the faults in this seismic image are not apparent as sharp reflection discontinuities.
49
50 Instead, the faults are imaged like reflections in this 3D seismic image as shown in Figure 8a.
51
52 However, the CNN model still works pretty well to detect the faults as shown in Figure 8b,
53
54
55
which means that the network wisely learnt to predict faults by not simply detecting sharp
56
57 discontinuities or edges. Figure 8c shows the thinned fault likelihoods, which are more noisy
58
59
60 14
1
2
3
4 than the CNN fault probabilities as shown on the horizontal slice.
5
6
7 The third 3D seismic image shown in Figure 9 is a subset (210 (vertical) ⇥600 (inline)
8
9 ⇥825 (crossline) samples) extracted from a lager seismic reflection volume that is acquired
10
11
12 across the Costa Rica Margin, NW of the Osa Penisula to image the fault properties in
13
14 the subduction zone. Multiple sets of closely spaced faults are apparent in this 3D seismic
15
16 volume as discussed by Bangs et al. (2015). The fault detection in this example is more
17
18 challenging than the previous ones because the faults are very close to each other, the
19
20
21 reflection structures are not well imaged and the image is pretty noisy. Figures 9a, 9b
22
23 and 9c show the CNN fault probabilities at di↵erent slices. We observe that most faults are
24
25 clearly labelled in this CNN fault probability images and these faults can be continuously
26
27
tracked by following the probability features. Multiple sets of faults striking in di↵erent
GEOPHYSICS
28
29
30 directions can be clearly observed on the horizontal slice in these CNN fault probability
31
32 images. Figures 9d, 9e and 9f show the thinned fault likelihoods at the same slices, which
33
34 can detect most faults but the fault features are much more noisy than the CNN fault
35
36
probabilities. In addition, many of the faults are mislabelled, especially in areas where the
37
38
39 seismic structures are noisy.
40
41
42
Figure 10 shows the fourth larger seismic volume (450 (vertical) ⇥ 1950 (inline) ⇥ 1200
43
44 (crossline) samples) that is acquired at the Campos Basin, o↵shore Brazil. This image shows
45
46 that the sediments are heavily faulted due to the salt bodies at the bottom of the volume.
47
48 The CNN fault probabilities shown in Figures 10a and 10b clearly and accurately label
49
50
51 out numerous closely spaced faults in this seismic volume. The faulting patterns are clearly
52
53 visible on the time slices of the CNN fault probability image. To be able to better visualize
54
55 the fault detection in this example, we further display two sub-volumes of seismic amplitude
56
57 and CNN fault probabilities (Figures 11b and 11d), where most of the faults are clearly and
58
59
60 15
1
2
3
4 accurately labeled except some subtle faults. The horizontal slices in Figures 11b and 11d,
5
6
7
respectively, display clear patterns of polygonal and radial faults that may be associated
8
9 with salt diapirs (Rowan et al., 1999; Carruthers, 2012).
10
11
12 In addition to the above field examples, we also applied the same trained CNN model
13
14 to another two 3D seismic images Kerry-3D and Opunake-3D, which are provided on the
15
16 SEG Wiki website. The fault segmentation results are clean and accurate as shown in
17
18
the SEG Wiki website (Kerry-3D: https://wiki.seg.org/wiki/Kerry-3D and Opunake-3D:
19
20
21 https://wiki.seg.org/wiki/Opunake-3D) or the GitHub repository (https://github.com/xinwucwp/faultSeg).
22
23
In summary, although the CNN model is trained by using only 200 synthetic seismic
24
25
26 images, it works pretty well to detect faults in 3D field seismic volumes that are recorded
27
GEOPHYSICS
28 at totally di↵erent surveys. In addition, the 3D fault prediction using the trained CNN
29
30 model is highly efficient. By using one TITAN Xp GPU, computing the large CNN fault
31
32
33
probability volume (450 (vertical) ⇥ 1950 (inline) ⇥ 1200 (crossline) samples) in Figure 10
34
35 takes less than 3 minutes. Computing fault likelihoods for the same volume, however,
36
37 required around 1.5 hours when using a workstation with 32 cores.
38
39
40 In our training and validating datasets, we avoid including thrust and listric faults
41
42 with low dip angles. These faults often appear strong reflections features in a seismic
43
44
image other than reflection discontinuities as the faults discussed in this paper. Therefore,
45
46
47 all the conventional fault detection methods, based on measuring reflection discontinuity
48
49 or continuity, often fail to detect the thrust and listric faults. However, our CNN-based
50
51 method will have a change to successfully detect these faults by training another specific
52
53
model, which is actually what we will focus on in the future research.
54
55
56
57
58
59
60 16
1
2
3
4 CONCLUSIONS
5
6
7
We have discussed an end-to-end convolutional neural network to efficiently detect faults
8
9
10 from 3D seismic images, where the fault detection is considered as a binary segmentation
11
12 problem. This neural network is simplified from the originally more complicated U-net
13
14 to save GPU memory and computational time (for both training and prediction) but still
15
16
17
preserve high performance for fault detection. As the distribution of fault and non-fault
18
19 samples are heavily biased, we use a balanced loss function to optimize the CNN model
20
21 parameters. We train the neural network by using only 200 pairs of 3D synthetic seismic and
22
23 fault volumes, which are all automatically generated by randomly adding folding, faulting
24
25
26 and noise in the volumes. Although trained by using only synthetic datasets, the neural
27
GEOPHYSICS
28 network can accurately detect faults from 3D field seismic volumes that are acquired at
29
30 totally di↵erent surveys. Although we add only planar faults in the training datasets, the
31
32 network actually learns to detect curved faults in the field seismic images. We have made all
33
34
35 our synthetic training datasets, codes, and the trained CNN model freely available through
36
37 our GitHub account: https://github.com/xinwucwp/faultSeg.
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60 17
1
2
3
4 REFERENCES
5
6
7 Aqrawi, A. A., and T. H. Boe, 2011, Improved fault segmentation using a dip guided and
8
9 modified 3D Sobel filter: 81st Annual International Meeting, SEG, Expanded Abstracts,
10
11
12 999–1003.
13
14 Badrinarayanan, V., A. Kendall, and R. Cipolla, 2017, Segnet: A deep convolutional
15
16 encoder-decoder architecture for image segmentation: IEEE transactions on pattern anal-

17
18
ysis and machine intelligence, 39, 2481–2495.
19
20
21 Bakker, P., 2002, Image structure analysis for seismic interpretation: PhD thesis, Delft
22
23 University of Technology.
24
25 Bangs, N. L., K. D. McIntosh, E. A. Silver, J. W. Kluesner, and C. R. Ranero, 2015, Fluid
26
27
accumulation along the costa rica subduction thrust and development of the seismogenic
GEOPHYSICS
28
29
30 zone: Journal of Geophysical Research: Solid Earth, 120, 67–86.
31
32 Carruthers, T., 2012, Interaction of polygonal fault systems with salt diapirs: PhD thesis,
33
34 Cardi↵ University.
35
36
Chollet, F., et al., 2015, Keras: https://github.com/fchollet/keras.
37
38
39 Cohen, I., N. Coult, and A. A. Vassiliou, 2006, Detection and extraction of fault surfaces
40
41 in 3D seismic data: Geophysics, 71, no. 4, P21–P27.
42
43 Di, H., M. Shafiq, and G. AlRegib, 2018, Patch-level mlp classification for improved fault
44
45
detection: 88th Annual International Meeting, SEG, Expanded Abstracts, 2211–2215.
46
47
48 Gersztenkorn, A., and K. J. Marfurt, 1999, Eigenstructure-based coherence computations
49
50 as an aid to 3-D structural and stratigraphic mapping: Geophysics, 64, no. 5, 1468–1479.
51
52 Girshick, R., J. Donahue, T. Darrell, and J. Malik, 2014, Rich feature hierarchies for ac-
53
54
55
curate object detection and semantic segmentation: Proceedings of the IEEE conference
56
57 on computer vision and pattern recognition, 580–587.
58
59
60 18
1
2
3
4 Guitton, A., 2018, 3d convolutional neural networks for fault interpretation: Presented at
5
6
7
the 80th EAGE Conference and Exhibition 2018.
8
9 Guo, B., L. Li, and Y. Luo, 2018, A new method for automatic seismic fault detection
10
11 using convolutional neural network: 88th Annual International Meeting, SEG, Expanded
12
13 Abstracts, 1951–1955.
14
15
16
Hale, D., 2009, Structure-oriented smoothing and semblance: CWP Report 635.
17
18 ——–, 2013, Methods to compute fault images, extract fault surfaces, and estimate fault
19
20 throws from 3D seismic images: Geophysics, 78, no. 2, O33–O43.
21
22 He, K., G. Gkioxari, P. Dollár, and R. Girshick, 2017, Mask r-cnn: Computer Vision
23
24
25 (ICCV), 2017 IEEE International Conference on, IEEE, 2980–2988.
26
27 Huang, L., X. Dong, and T. E. Clee, 2017, A scalable deep learning platform for identifying
GEOPHYSICS
28
29 geologic features from seismic attributes: The Leading Edge, 36, 249–256.
30
31 Kingma, D. P., and J. Ba, 2014, Adam: A method for stochastic optimization.: CoRR,
32
33
34 abs/1412.6980.
35
36 Li, F., and W. Lu, 2014, Coherence attribute at di↵erent spectral scales: Interpretation, 2,
37
38 SA99–SA106.
39
40
Mansfield, C., and J. Cartwright, 1996, High resolution fault displacement mapping from
41
42
43 three-dimensional seismic data: evidence for dip linkage during fault growth: Journal of
44
45 Structural Geology, 18, 249–263.
46
47 Marfurt, K. J., R. L. Kirlin, S. L. Farmer, and M. S. Bahorich, 1998, 3-D seismic attributes
48
49
using a semblance-based coherency algorithm: Geophysics, 63, no. 4, 1150–1165.
50
51
52 Marfurt, K. J., V. Sudhaker, A. Gersztenkorn, K. D. Crawford, and S. E. Nissen, 1999,
53
54 Coherency calculations in the presence of structural dip: Geophysics, 64, no. 1, 104–111.
55
56 Martin, D. R., C. C. Fowlkes, and J. Malik, 2004, Learning to detect natural image bound-
57
58
59
60 19
1
2
3
4 aries using local brightness, color, and texture cues: IEEE transactions on pattern analysis
5
6
7
and machine intelligence, 26, 530–549.
8
9 Muraoka, H., and H. Kamata, 1983, Displacement distribution along minor fault traces:
10
11 Journal of Structural Geology, 5, 483 – 495.
12
13 Ne↵, D. B., J. R. Grismore, and W. A. Lucas, 2000, Automated seismic fault detection and
14
15
16
picking. (US Patent 6,018,498).
17
18 Pedersen, S. I., T. Randen, L. Sonneland, and Ø. Steen, 2002, Automatic fault extraction
19
20 using artificial ants: 72nd Annual International Meeting, SEG, Expanded Abstracts,
21
22 512–515.
23
24
25 Pedersen, S. I., T. Skov, A. Hetlelid, P. Fayemendy, T. Randen, and L. Sønneland, 2003, New
26
27 paradigm of fault interpretation: 73rd Annual International Meeting, SEG, Expanded
GEOPHYSICS
28
29 Abstracts, 350–353.
30
31 Provost, F. J., T. Fawcett, R. Kohavi, et al., 1998, The case against accuracy estimation
32
33
34 for comparing induction algorithms.: ICML, 445–453.
35
36 Randen, T., S. I. Pedersen, L. Sønneland, et al., 2001, Automatic extraction of fault surfaces
37
38 from three-dimensional seismic data: 81st Annual International Meeting, SEG, Expanded
39
40
Abstracts, 551–554.
41
42
43 Ren, S., K. He, R. Girshick, and J. Sun, 2015, Faster r-cnn: Towards real-time object detec-
44
45 tion with region proposal networks: Advances in neural information processing systems,
46
47 91–99.
48
49
Ronneberger, O., P. Fischer, and T. Brox, 2015, U-net: Convolutional networks for biomed-
50
51
52 ical image segmentation: International Conference on Medical image computing and
53
54 computer-assisted intervention, Springer, 234–241.
55
56 Rowan, M. G., M. P. Jackson, and B. D. Trudgill, 1999, Salt-related fault families and fault
57
58
59
60 20
1
2
3
4 welds in the northern gulf of mexico: AAPG bulletin, 83, 1454–1484.
5
6
7
Stewart, S., 2001, Displacement distributions on extensional faults: Implications for fault
8
9 stretch, linkage, and seal: AAPG bulletin, 85, 587–599.
10
11 Van Bemmel, P. P., and R. E. Pepper, 2000, Seismic signal processing method and apparatus
12
13 for generating a cube of variance values. (US Patent 6,151,555).
14
15
16
Wu, X., 2017, Directional structure-tensor based coherence to detect seismic faults and
17
18 channels: Geophysics, 82, no. 2, A13–A17.
19
20 Wu, X., and S. Fomel, 2018, Automatic fault interpretation with optimal surface voting:
21
22 GEOPHYSICS, 83, O67–O82.
23
24
25 Wu, X., and D. Hale, 2016, 3D seismic image processing for faults: Geophysics, 81, no. 2,
26
27 IM1–IM11.
GEOPHYSICS
28
29 Wu, X., Y. Shi, S. Fomel, and L. Liang, 2018, Convolutional neural networks for fault
30
31 interpretation in seismic images: 88th Annual International Meeting, SEG, Expanded
32
33
34 Abstracts, 1946–1950.
35
36 Wu, X., and Z. Zhu, 2017, Methods to enhance seismic faults and construct fault surfaces:
37
38 Computers & Geosciences, 107, 37 – 48.
39
40
Xie, S., and Z. Tu, 2015, Holistically-nested edge detection: Proceedings of the IEEE
41
42
43 international conference on computer vision, 1395–1403.
44
45 Zhao, T., and P. Mukhopadhyay, 2018, A fault-detection workflow using deep learning
46
47 and image processing: 88th Annual International Meeting, SEG, Expanded Abstracts,
48
49
1966–1970.
50
51
52
53
54
55
56
57
58
59
60 21
1
2
3
4 LIST OF FIGURES
5
6
7
1 The workflow of creating 3D synthetic training datasets. We first generate a hor-
8
9
10 izontal reflectivity model (a) with a sequence of random numbers between 1 and 1. We
11
12 then add some folding structures (b) to the model by vertically shearing the model and the
13
14 shearing shifts are defined by a combination of several 2D Gaussian functions. We also add
15
16
17
some planar shearing (c) to the model to increase the complexity of folding structures. We
18
19 further add planar faulting to the model to obtain a folded and faulted reflectivity model
20
21 (d). We finally convolve the reflectivity model with a Ricker wavelet to obtain a synthetic
22
23 seismic image (e) and add some random noise to obtain a final image (f).
24
25
26 2 (a) A final synthetic seismic image is cropped from the larger image in Figure 1f.
27
GEOPHYSICS
28 (b) The corresponding true fault image (with labeling ones on faults while zeros elsewhere)
29
30 is overlaid with the cropped seismic image.
31
32 3 A simplified end-to-end convolutional neural network (U-net) for 3D fault detec-
33
34
35 tion.
36
37 4 The training and validation accuracy (a) increase with epochs while the training
38
39 and validation loss (b) decrease with epochs.
40
41 5 Fault detection on the synthetic validation volume (Figure 2a) by using 7 com-
42
43
44 monly used methods (a⇠g) and our CNN method (h). Compared to the methods of (a)
45
46 C3 (Gersztenkorn and Marfurt, 1999), (b) C2 (Marfurt et al., 1999), (c) planarity (Hale,
47
48 2009), (d) structure-oriented planarity (Wu, 2017), and (e) structure-oriented semblance (Hale,
49
50
2009), the (f) fault likelihood (Hale, 2013; Wu and Hale, 2016) and (g) optimal surface vot-
51
52
53 ing (Wu and Fomel, 2018) methods perform better fault detections. (h) Our CNN method
54
55 achieves the best performance in obtaining an accurate, clean and complete fault detec-
56
57 tion.
58
59
60 22
1
2
3
4 6 Precision-recall (a) and ROC (b) curves are used to evaluate the 8 fault detections
5
6
7
on the synthetic validation volume in Figure 5. Our CNN fault detection method performs
8
9 significantly better than the other methods.
10
11 7 A 3D seismic image (a) is displayed with faults that are detected by using the
12
13 trained CNN model (b), fault likelihood (c) and thinned fault likelihood (d).
14
15
16
8 A 3D seismic image (a) is displayed with faults that are detected by using the
17
18 trained CNN model (b) and thinned fault likelihood (c).
19
20 9 Faults are detected in a complicated 3D example by using the trained CNN model
21
22 ((a), (b) and (c)) and thinned fault likelihoods ((d), (e) and (f)).
23
24
25 10 A 3D seismic image (a) overlaid with the CNN fault probabilities at di↵erent slices
26
27 ((b), (c) and (d)), where most of the faults are clearly and accurately labelled.
GEOPHYSICS
28
29 11 Two sub-volumes of the seismic amplitude ((a) and (c)) and CNN fault probability
30
31 ((b) and (d)) are extracted from the full volumes in Figure 10.
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60 23
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
GEOPHYSICS
28
29
30
31
32
33
34 Figure 1: The workflow of creating 3D synthetic training datasets. We first generate a horizontal reflectivity
35 model (a) with a sequence of random numbers between 1 and 1. We then add some folding structures (b) to
36 the model by vertically shearing the model and the shearing shifts are defined by a combination of several
37 2D Gaussian functions. We also add some planar shearing (c) to the model to increase the complexity of
38 folding structures. We further add planar faulting to the model to obtain a folded and faulted reflectivity
39 model (d). We finally convolve the reflectivity model with a Ricker wavelet to obtain a synthetic seismic
image (e) and add some random noise to obtain a final image (f).
40
41 84x72mm (300 x 300 DPI)
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
GEOPHYSICS
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45 Figure 2: (a) A final synthetic seismic image is cropped from the larger image in Figure 1f. (b) The
46 corresponding true fault image (with labeling ones on faults while zeros elsewhere) is overlaid with the
47 cropped seismic image.
48 42x84mm (300 x 300 DPI)
49
50
51
52
53
54
55
56
57
58
59
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 Figure 3: A simplified end-to-end convolutional neural network (U-net) for 3D fault detection.
20
21 169x63mm (300 x 300 DPI)
22
23
24
25
26
27
GEOPHYSICS
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
GEOPHYSICS
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45 Figure 4: The training and validation accuracy (a) increase with epochs while the training and validation loss
46 (b) decrease with epochs.
47
101x129mm (200 x 200 DPI)
48
49
50
51
52
53
54
55
56
57
58
59
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Figure 5: Fault detection on the synthetic validation volume (Figure 2a) by using 7 commonly used methods
26
(a~g) and our CNN method (h). Compared to the methods of (a) C3 (Gersztenkorn and Marfurt, 1999), (b)
27 C2 (Marfurt et al., 1999), (c) planarity (Hale, 2009), (d) structure-oriented planarity (Wu, 2017), and (e)
GEOPHYSICS
28 structure-oriented semblance (Hale, 2009), the (f) fault likelihood (Hale, 2013; Wu and Hale, 2016) and (g)
29 optimal surface voting (Wu and Fomel, 2018) methods perform better fault detections. (h) Our CNN method
30 achieves the best performance in obtaining an accurate, clean and complete fault detection.
31
32 508x296mm (100 x 100 DPI)
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 Figure 6: Precision-recall (a) and ROC (b) curves are used to evaluate the 8 fault detections on the synthetic
23 validation volume in Figure 5. Our CNN fault detection method performs significantly better than the other
24 methods.
25
508x239mm (100 x 100 DPI)
26
27
GEOPHYSICS
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
GEOPHYSICS
28
29
30
31
32 Figure 7: A 3D seismic image (a) is displayed with faults that are detected by using the trained CNN model
(b), fault likelihood (c) and thinned fault likelihood (d).
33
34 406x316mm (100 x 100 DPI)
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
GEOPHYSICS
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45 Figure 8: A 3D seismic image (a) is displayed with faults that are detected by using the trained CNN model
46 (b) and thinned fault likelihood (c).
47
203x465mm (100 x 100 DPI)
48
49
50
51
52
53
54
55
56
57
58
59
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
GEOPHYSICS
28
29
30
31
32
33
34
35
36
37 Figure 9: Faults are detected in a complicated 3D example by using the trained CNN model ((a), (b) and (c))
38 and thinned fault likelihoods ((d), (e) and (f)).
39
40 406x385mm (100 x 100 DPI)
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
GEOPHYSICS
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45 Figure 10: A 3D seismic image (a) overlaid with the CNN fault probabilities at different slices ((b), (c) and
46 (d)), where most of the faults are clearly and accurately labelled.
47
304x489mm (100 x 100 DPI)
48
49
50
51
52
53
54
55
56
57
58
59
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
GEOPHYSICS
28
29
30
31
32
Figure 11: Two sub-volumes of the seismic amplitude ((a) and (c)) and CNN fault probability ((b) and (d))
33 are extracted from the full volumes in Figure 10.
34
35 406x325mm (100 x 100 DPI)
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
DATA AND MATERIALS AVAILABILITY
Data associated with this research are available and can be accessed via the following URL:lt;brgt; Note: A
digital object identifier (DOI) linking to the data in a general or discipline-specific data repository is strongly
preferred.
GEOPHYSICS

Wu - 2019-FaultSeg3D Using Synthetic Datasets To Train An End-To-End Convolutional Neural Network For 3D Seismic Fault Segmentation. GEOPHYSICS

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Wu - 2019-FaultSeg3D Using Synthetic Datasets To Train An End-To-End Convolutional Neural Network For 3D Seismic Fault Segmentation. GEOPHYSICS

Uploaded by

Copyright:

Available Formats

GEOPHYSICS

FaultSeg3D: using synthetic datasets to train an end-to-end

Manuscript Type: Technical Paper

Keywords: faults, interpretation, seismic attributes

Area of Expertise: Interpretation Methods

16 encoder-decoder architecture for image segmentation: IEEE transactions on pattern anal-

You might also like