├── README.md
├── LICENSE
└── MalenoV Code 5 layer CNN 65x65x65 voxels


/README.md:
--------------------------------------------------------------------------------
 1 | # MalenoV_nD (MAchine LEarNing Of Voxels)
 2 | <h1> Tool for training &amp;  classifying 3D (4D, nD) SEGY seismic facies using deep neural networks</h1>
 3 | 
 4 | <h3>For attribution nets check out https://github.com/crild/facies_net </h3>
 5 | 
 6 | •	MalenoV reads standard 3D SEGY seismic and performs a 3D neural network architecture of choice on a given set of classification data points (facies annotation /supervision).  It then uses the learned weights and filters of the neural network to classify seismic at any other location in the seismic cube into the facies classes that have been previously been defined by the user. Finally the facies classification is written out as a SEGY cube with the same dimensions as the input cube.
 7 | 
 8 | The tool reads can handle n seismic input cubes (offest stacks, 4D data, attributes, etc) and n number of facies training datasets. The more input seismic cubes are trained / classified  simultaneously the more memory is needed and the slower training /classification will be (linear scaling).
 9 | 
10 | •	MalenoV was created as part of the Summer project of Charles Rutherford Ildstad in ConocoPhillips in July 2017.
11 | 
12 | •	The tool was inspired by the work of Anders U. Waldeland who showed at that he was successfully classifying the seismic facies of salt using 3D convolutional networks (http://earthdoc.eage.org/publication/publicationdetails/?publication=88635). 
13 | 
14 | •	Currently a 5 layer basic 3D convolutional network is implemented but this can be changed by the users at liberty. 
15 | 
16 | •	This tool is essentially an I/O function for machine learning with seismic. Better neural architectures for AVO, rock property prediction, fault classifications are to be implemented. (Think Unet resnet or GAN).
17 | 
18 | •	The tool is public with a GNU Lesser General Public License v3.0
19 | 
20 | •	The tool  has been updated to handle multiple input volumes (offest stacks, 4D seismic) for better classification results and more fun
21 | 
22 | <h3>The User Manual, seismic data, training data and set up scripts for the tool can be found here</h3>
23 | https://drive.google.com/drive/folders/0B7brcf-eGK8CRUhfRW9rSG91bW8
24 | 
25 | 
26 | 
27 | 
28 | 
29 | <h3>Seismic training data for testing the tool:</h3>
30 | 
31 | •	We decided to make available the Poseidon (3500km2) seismic dataset acquired for ConocoPhillips Australia including Near, Mid, Far stacks, well data and velocity data
32 | 
33 | •	The seismic data is available here: https://drive.google.com/drive/folders/0B7brcf-eGK8CRUhfRW9rSG91bW8
34 | <b> BEAWRE one 32 bit SEGY File is 100 GB of data</b>
35 | 
36 | •	There is also inline, xline, z, training data for fault identification on the Poseidon survey
37 | 
38 | •	The Dutch government F3 seismic dataset can also be downloaded from the same location. 
39 | <b>This data is only 1 GB</b>
40 | 
41 | •	Training data locations for multi facies prediction, faults and steep dips is provided
42 | •	Trained neural network models for steep dips and multi facies can be assessed
43 | . 
44 | .
45 | 
46 | <b>MalenoV stands for MAchine LEarNing Of Voxels</b>
47 | 
48 | <b>nD stands for unlimited input dimensions</b>
49 |  
50 |  
51 |   
52 |  .
53 |  .
54 |  <h3>Improvement ideas:</h3>
55 |  
56 |  <b>Priority number 1 </b>is to improve the classification speed.
57 | 
58 | One easy  solution for this would be to do the classification only at a user defined spacing. Say every second inline and every third crossline and every other z sample. Once the classification is done a segy cube needs to be written out with a new inline xline z spacing but the same origin as the ingoing volumes. This undersampling will be really good to test hyper parameters because one would get a feel for the classification accuracy much quicker 
59 | 
60 | The second way to improve speed would be to make sure that the to be trained or classified numpy cubes are truly 8 bit integer. Currently there is the option to switch  to 8 bit but it seems not to do the right stuff.
61 | 
62 | <b>2nd priority </b>is implement 3d augmentation by allowing the user to choose how many and how a sub set of the training cubelets are deformed in 3d (squeezed stretched bent etc)  or adding gaussian noise to them. This would help to make more abstract models
63 | 
64 | 
65 | <b>3rd priority </b> is to implement tensor board or other visual tools to see how good the training goes and implement a scikit module to get an accuracy score for withheld training examples 
66 | 
67 | 
68 | <b>4th priority </b>would be to implement u nets Gan and other interesting architectures
69 | 
70 |  
71 | 
72 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                    GNU LESSER GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 | 
  9 |   This version of the GNU Lesser General Public License incorporates
 10 | the terms and conditions of version 3 of the GNU General Public
 11 | License, supplemented by the additional permissions listed below.
 12 | 
 13 |   0. Additional Definitions.
 14 | 
 15 |   As used herein, "this License" refers to version 3 of the GNU Lesser
 16 | General Public License, and the "GNU GPL" refers to version 3 of the GNU
 17 | General Public License.
 18 | 
 19 |   "The Library" refers to a covered work governed by this License,
 20 | other than an Application or a Combined Work as defined below.
 21 | 
 22 |   An "Application" is any work that makes use of an interface provided
 23 | by the Library, but which is not otherwise based on the Library.
 24 | Defining a subclass of a class defined by the Library is deemed a mode
 25 | of using an interface provided by the Library.
 26 | 
 27 |   A "Combined Work" is a work produced by combining or linking an
 28 | Application with the Library.  The particular version of the Library
 29 | with which the Combined Work was made is also called the "Linked
 30 | Version".
 31 | 
 32 |   The "Minimal Corresponding Source" for a Combined Work means the
 33 | Corresponding Source for the Combined Work, excluding any source code
 34 | for portions of the Combined Work that, considered in isolation, are
 35 | based on the Application, and not on the Linked Version.
 36 | 
 37 |   The "Corresponding Application Code" for a Combined Work means the
 38 | object code and/or source code for the Application, including any data
 39 | and utility programs needed for reproducing the Combined Work from the
 40 | Application, but excluding the System Libraries of the Combined Work.
 41 | 
 42 |   1. Exception to Section 3 of the GNU GPL.
 43 | 
 44 |   You may convey a covered work under sections 3 and 4 of this License
 45 | without being bound by section 3 of the GNU GPL.
 46 | 
 47 |   2. Conveying Modified Versions.
 48 | 
 49 |   If you modify a copy of the Library, and, in your modifications, a
 50 | facility refers to a function or data to be supplied by an Application
 51 | that uses the facility (other than as an argument passed when the
 52 | facility is invoked), then you may convey a copy of the modified
 53 | version:
 54 | 
 55 |    a) under this License, provided that you make a good faith effort to
 56 |    ensure that, in the event an Application does not supply the
 57 |    function or data, the facility still operates, and performs
 58 |    whatever part of its purpose remains meaningful, or
 59 | 
 60 |    b) under the GNU GPL, with none of the additional permissions of
 61 |    this License applicable to that copy.
 62 | 
 63 |   3. Object Code Incorporating Material from Library Header Files.
 64 | 
 65 |   The object code form of an Application may incorporate material from
 66 | a header file that is part of the Library.  You may convey such object
 67 | code under terms of your choice, provided that, if the incorporated
 68 | material is not limited to numerical parameters, data structure
 69 | layouts and accessors, or small macros, inline functions and templates
 70 | (ten or fewer lines in length), you do both of the following:
 71 | 
 72 |    a) Give prominent notice with each copy of the object code that the
 73 |    Library is used in it and that the Library and its use are
 74 |    covered by this License.
 75 | 
 76 |    b) Accompany the object code with a copy of the GNU GPL and this license
 77 |    document.
 78 | 
 79 |   4. Combined Works.
 80 | 
 81 |   You may convey a Combined Work under terms of your choice that,
 82 | taken together, effectively do not restrict modification of the
 83 | portions of the Library contained in the Combined Work and reverse
 84 | engineering for debugging such modifications, if you also do each of
 85 | the following:
 86 | 
 87 |    a) Give prominent notice with each copy of the Combined Work that
 88 |    the Library is used in it and that the Library and its use are
 89 |    covered by this License.
 90 | 
 91 |    b) Accompany the Combined Work with a copy of the GNU GPL and this license
 92 |    document.
 93 | 
 94 |    c) For a Combined Work that displays copyright notices during
 95 |    execution, include the copyright notice for the Library among
 96 |    these notices, as well as a reference directing the user to the
 97 |    copies of the GNU GPL and this license document.
 98 | 
 99 |    d) Do one of the following:
100 | 
101 |        0) Convey the Minimal Corresponding Source under the terms of this
102 |        License, and the Corresponding Application Code in a form
103 |        suitable for, and under terms that permit, the user to
104 |        recombine or relink the Application with a modified version of
105 |        the Linked Version to produce a modified Combined Work, in the
106 |        manner specified by section 6 of the GNU GPL for conveying
107 |        Corresponding Source.
108 | 
109 |        1) Use a suitable shared library mechanism for linking with the
110 |        Library.  A suitable mechanism is one that (a) uses at run time
111 |        a copy of the Library already present on the user's computer
112 |        system, and (b) will operate properly with a modified version
113 |        of the Library that is interface-compatible with the Linked
114 |        Version.
115 | 
116 |    e) Provide Installation Information, but only if you would otherwise
117 |    be required to provide such information under section 6 of the
118 |    GNU GPL, and only to the extent that such information is
119 |    necessary to install and execute a modified version of the
120 |    Combined Work produced by recombining or relinking the
121 |    Application with a modified version of the Linked Version. (If
122 |    you use option 4d0, the Installation Information must accompany
123 |    the Minimal Corresponding Source and Corresponding Application
124 |    Code. If you use option 4d1, you must provide the Installation
125 |    Information in the manner specified by section 6 of the GNU GPL
126 |    for conveying Corresponding Source.)
127 | 
128 |   5. Combined Libraries.
129 | 
130 |   You may place library facilities that are a work based on the
131 | Library side by side in a single library together with other library
132 | facilities that are not Applications and are not covered by this
133 | License, and convey such a combined library under terms of your
134 | choice, if you do both of the following:
135 | 
136 |    a) Accompany the combined library with a copy of the same work based
137 |    on the Library, uncombined with any other library facilities,
138 |    conveyed under the terms of this License.
139 | 
140 |    b) Give prominent notice with the combined library that part of it
141 |    is a work based on the Library, and explaining where to find the
142 |    accompanying uncombined form of the same work.
143 | 
144 |   6. Revised Versions of the GNU Lesser General Public License.
145 | 
146 |   The Free Software Foundation may publish revised and/or new versions
147 | of the GNU Lesser General Public License from time to time. Such new
148 | versions will be similar in spirit to the present version, but may
149 | differ in detail to address new problems or concerns.
150 | 
151 |   Each version is given a distinguishing version number. If the
152 | Library as you received it specifies that a certain numbered version
153 | of the GNU Lesser General Public License "or any later version"
154 | applies to it, you have the option of following the terms and
155 | conditions either of that published version or of any later version
156 | published by the Free Software Foundation. If the Library as you
157 | received it does not specify a version number of the GNU Lesser
158 | General Public License, you may choose any version of the GNU Lesser
159 | General Public License ever published by the Free Software Foundation.
160 | 
161 |   If the Library as you received it specifies that a proxy can decide
162 | whether future versions of the GNU Lesser General Public License shall
163 | apply, that proxy's public statement of acceptance of any version is
164 | permanent authorization for you to choose that version for the
165 | Library.
166 | 


--------------------------------------------------------------------------------
/MalenoV Code 5 layer CNN 65x65x65 voxels:
--------------------------------------------------------------------------------
   1 | ### Function for n-dimensional seismic facies training /classification using Convolutional Neural Nets (CNN)
   2 | ### By: Charles Rutherford Ildstad (University of Trondheim), as part of a summer intern project in ConocoPhillips and private work
   3 | ### Contributions from Anders U. Waldeland (University of Oslo), Chris Olsen (ConocoPhillips), Doug Hakkarinen (ConocoPhillips)
   4 | ### Date: 26.10.2017
   5 | ### For: ConocoPhillips, Norway,
   6 | ### GNU V3.0 lesser license
   7 | 
   8 | # Make initial package imports
   9 | import segyio
  10 | import random
  11 | import keras
  12 | import numpy as np
  13 | import matplotlib.pyplot as plt
  14 | import math
  15 | import time
  16 | 
  17 | from keras.models import Sequential
  18 | from keras.models import Model
  19 | from keras.layers import Dense, Activation, Flatten, Dropout
  20 | from keras.layers import Conv3D
  21 | from keras.callbacks import EarlyStopping
  22 | from keras.callbacks import TensorBoard
  23 | from keras.callbacks import LearningRateScheduler
  24 | from matplotlib import gridspec
  25 | 
  26 | from keras.layers.normalization import BatchNormalization
  27 | 
  28 | from shutil import copyfile
  29 | 
  30 | # Set random seed for reproducability
  31 | np.random.seed(7)
  32 | # Confirm backend if in doubt
  33 | #keras.backend.backend()
  34 | 
  35 | 
  36 | ### ---- Functions for Input data(SEG-Y) formatting and reading ----
  37 | # Make a function that decompresses a segy-cube and creates a numpy array, and
  38 | # a dictionary with the specifications, like in-line range and time step length, etc.
  39 | def segy_decomp(segy_file, plot_data = False, read_direc='xline', inp_res = np.float64):
  40 |     # segy_file: filename of the segy-cube to be imported
  41 |     # plot_data: boolean that determines if a random xline should be plotted to test the reading
  42 |     # read_direc: which way the SEGY-cube should be read; 'xline', or 'inline'
  43 |     # inp_res: input resolution, the formatting of the seismic cube (could be changed to 8-bit data)
  44 | 
  45 |     # Make an empty object to hold the output data
  46 |     print('Starting SEG-Y decompressor')
  47 |     output = segyio.spec()
  48 | 
  49 |     # open the segyfile and start decomposing it
  50 |     with segyio.open(segy_file, "r" ) as segyfile:
  51 |         # Memory map file for faster reading (especially if file is big...)
  52 |         segyfile.mmap()
  53 | 
  54 |         # Store some initial object attributes
  55 |         output.inl_start = segyfile.ilines[0]
  56 |         output.inl_end = segyfile.ilines[-1]
  57 |         output.inl_step = segyfile.ilines[1] - segyfile.ilines[0]
  58 | 
  59 |         output.xl_start = segyfile.xlines[0]
  60 |         output.xl_end = segyfile.xlines[-1]
  61 |         output.xl_step = segyfile.xlines[1] - segyfile.xlines[0]
  62 | 
  63 |         output.t_start = int(segyfile.samples[0])
  64 |         output.t_end = int(segyfile.samples[-1])
  65 |         output.t_step = int(segyfile.samples[1] - segyfile.samples[0])
  66 | 
  67 | 
  68 |         # Pre-allocate a numpy array that holds the SEGY-cube
  69 |         output.data = np.empty((segyfile.xline.len,segyfile.iline.len,\
  70 |                         (output.t_end - output.t_start)//output.t_step+1), dtype = np.float32)
  71 | 
  72 |         # Read the entire cube line by line in the desired direction
  73 |         if read_direc == 'inline':
  74 |             # Potentially time this to find the "fast" direction
  75 |             #start = time.time()
  76 |             for il_index in range(segyfile.xline.len):
  77 |                 output.data[il_index,:,:] = segyfile.iline[segyfile.ilines[il_index]]
  78 |             #end = time.time()
  79 |             #print(end - start)
  80 | 
  81 |         elif read_direc == 'xline':
  82 |             # Potentially time this to find the "fast" direction
  83 |             #start = time.time()
  84 |             for xl_index in range(segyfile.iline.len):
  85 |                 output.data[:,xl_index,:] = segyfile.xline[segyfile.xlines[xl_index]]
  86 |             #end = time.time()
  87 |             #print(end - start)
  88 | 
  89 |         elif read_direc == 'full':
  90 |             ## NOTE: 'full' for some reason invokes float32 data
  91 |             # Potentially time this to find the "fast" direction
  92 |             #start = time.time()
  93 |             output.data = segyio.tools.cube(segy_file)
  94 |             #end = time.time()
  95 |             #print(end - start)
  96 |         else:
  97 |             print('Define reading direction(read_direc) using either ''inline'', ''xline'', or ''full''')
  98 | 
  99 | 
 100 |         # Convert the numpy array to span between -127 and 127 and convert to the desired format
 101 |         factor = 127/np.amax(np.absolute(output.data))
 102 |         if inp_res == np.float32:
 103 |             output.data = (output.data*factor)
 104 |         else:
 105 |             output.data = (output.data*factor).astype(dtype = inp_res)
 106 | 
 107 |         # If sepcified, plot a given x-line to test the read data
 108 |         if plot_data:
 109 |             # Take a given xline
 110 |             data = output.data[:,100,:]
 111 |             # Plot the read x-line
 112 |             plt.imshow(data.T,interpolation="nearest", cmap="gray")
 113 |             plt.colorbar()
 114 |             plt.show()
 115 | 
 116 | 
 117 |     # Return the output object
 118 |     print('Finished using the SEG-Y decompressor')
 119 |     return output
 120 | 
 121 | 
 122 | 
 123 | # Make a function that adds another layer to a segy-cube
 124 | def segy_adder(segy_file, inp_cube, read_direc='xline', inp_res = np.float64):
 125 |     # segy_file: filename of the segy-cube to be imported
 126 |     # inp_cube: the existing cube that we should add a layer to
 127 |     # cube_num: which chronological number of cube is this
 128 |     # read_direc: which way the SEGY-cube should be read; 'xline', or 'inline'
 129 |     # inp_res: input resolution, the formatting of the seismic cube (could be changed to 8-bit data)
 130 | 
 131 |     # Make a variable to hold the shape of the input cube and preallocate a data holder
 132 |     print('Starting SEG-Y adder')
 133 |     cube_shape = inp_cube.shape
 134 |     dataholder = np.empty(cube_shape[0:-1])
 135 | 
 136 |     # open the segyfile and start decomposing it
 137 |     with segyio.open(segy_file, "r" ) as segyfile:
 138 |         # Memory map file for faster reading (especially if file is big...)
 139 |         segyfile.mmap()
 140 | 
 141 |         # Read the entire cube line by line in the desired direction
 142 |         if read_direc == 'inline':
 143 |             # Potentially time this to find the "fast" direction
 144 |             #start = time.time()
 145 |             for il_index in range(segyfile.xline.len):
 146 |                 dataholder[il_index,:,:] = segyfile.iline[segyfile.ilines[il_index]]
 147 |             #end = time.time()
 148 |             #print(end - start)
 149 | 
 150 |         elif read_direc == 'xline':
 151 |             # Potentially time this to find the "fast" direction
 152 |             #start = time.time()
 153 |             for xl_index in range(segyfile.iline.len):
 154 |                 dataholder[:,xl_index,:] = segyfile.xline[segyfile.xlines[xl_index]]
 155 |             #end = time.time()
 156 |             #print(end - start)
 157 | 
 158 |         elif read_direc == 'full':
 159 |             ## NOTE: 'full' for some reason invokes float32 data
 160 |             # Potentially time this to find the "fast" direction
 161 |             #start = time.time()
 162 |             dataholder[:,:,:] = segyio.tools.cube(segy_file)
 163 |             #end = time.time()
 164 |             #print(end - start)
 165 |         else:
 166 |             print('Define reading direction(read_direc) using either ''inline'', ''xline'', or ''full''')
 167 | 
 168 | 
 169 |         # Convert the numpy array to span between -127 and 127 and convert to the desired format
 170 |         factor = 127/np.amax(np.absolute(dataholder))
 171 |         if inp_res == np.float32:
 172 |             dataholder = (dataholder*factor)
 173 |         else:
 174 |             dataholder = (dataholder*factor).astype(dtype = inp_res)
 175 | 
 176 | 
 177 |     # Return the output object
 178 |     print('Finished adding a SEG-Y layer')
 179 |     return dataholder
 180 | 
 181 | # Convert a numpy-cube and seismic specs into a csv file/numpy-csv-format,
 182 | def csv_struct(inp_numpy,spec_obj,section,inp_res=np.float64,save=False,savename='default_write.ixz'):
 183 |     # inp_numpy: array that should be converted to csv
 184 |     # spec_obj: object containing the seismic specifications, like starting depth, inlines, etc.
 185 |     # inp_res: input resolution, the formatting of the seismic cube (could be changed to 8-bit data)
 186 |     # save: whether or not to save the output of the function
 187 |     # savename: what to name the newly saved csv-file
 188 | 
 189 |     # Get some initial parameters of the data
 190 |     (ilen,xlen,zlen) = inp_numpy.shape
 191 |     i = 0
 192 | 
 193 |     # Preallocate the array that we want to make
 194 |     full_np = np.empty((ilen*xlen*zlen,4),dtype = inp_res)
 195 | 
 196 |     # Itterate through the numpy-cube and convert each trace individually to a section of csv
 197 |     for il in range(section[0]*spec_obj.inl_step,(section[1]+1)*spec_obj.inl_step,spec_obj.inl_step):
 198 |         j = 0
 199 |         for xl in range(section[2]*spec_obj.xl_step,(section[3]+1)*spec_obj.xl_step,spec_obj.xl_step):
 200 |             # Make a list of the inline number, xline number, and depth for the given trace
 201 |             I = (il+spec_obj.inl_start)*(np.ones((zlen,1)))
 202 |             X = (xl+spec_obj.xl_start)*(np.ones((zlen,1)))
 203 |             Z = np.expand_dims(np.arange(section[4]*spec_obj.t_step+spec_obj.t_start,\
 204 |                                          (section[5]+1)*spec_obj.t_step+spec_obj.t_start,spec_obj.t_step),\
 205 |                                axis=1)
 206 | 
 207 |             # Store the predicted class/probability at each og the given depths of the trace
 208 |             D = np.expand_dims(inp_numpy[i,j,:],axis = 1)
 209 | 
 210 |             # Concatenate these lists together and insert them into the full array
 211 |             inp_li = np.concatenate((I,X,Z,D),axis=1)
 212 |             full_np[i*xlen*zlen+j*zlen:i*xlen*zlen+(j+1)*zlen,:] = inp_li
 213 |             j+=1
 214 |         i+=1
 215 | 
 216 |     # Add the option to save it as an external file
 217 |     if save:
 218 |         # save the file as the given str-name
 219 |         np.savetxt(savename, full_np, fmt = '%f')
 220 | 
 221 |     # Return the list of adresses and classes as a numpy array
 222 |     return full_np
 223 | 
 224 | 
 225 | ### ---- Functions for data augmentation ---- (Needs further development)
 226 | # RotationXY
 227 | def randomRotationXY(X, max_rot):
 228 |     max_rot = 6.28318530718 / 360 * max_rot #Deg 2 rad
 229 |     theta = tf.random_uniform([1], minval=-max_rot, maxval=max_rot, dtype='float32')
 230 |     x = X[2] * tf.cos(theta) - X[1] * tf.sin(theta)
 231 |     y = X[2] * tf.sin(theta) + X[1] * tf.cos(theta)
 232 |     return tf.stack([X[0],y,x])
 233 | 
 234 | 
 235 | # RotationZ
 236 | def randomRotationZ(X, max_rot):
 237 |     max_rot = 6.28318530718 / 360 * max_rot  # Deg 2 rad
 238 |     theta = tf.random_uniform([1], minval=-max_rot, maxval=max_rot, dtype='float32')
 239 |     t = X[0] * tf.cos(theta) - X[1] * tf.sin(theta)
 240 |     x = X[0] * tf.sin(theta) + X[1] * tf.cos(theta)
 241 |     return tf.stack([t,x,X[2]])
 242 | 
 243 | 
 244 | # Stretching
 245 | def randomStretch(window_function, strech):
 246 |     return tf.cast(window_function,'float32') * (1 + tf.random_uniform([1],minval=-strech,maxval=strech))
 247 | 
 248 | 
 249 | # Flip
 250 | def randomFlip(window_function):
 251 |     should_flip = tf.cast(tf.random_uniform([1], 0, 2, dtype=tf.int32)[0] > 0, tf.bool)
 252 |     window_function = tf.reverse(window_function, tf.pack([should_flip]))
 253 |     return window_function
 254 | 
 255 | 
 256 | 
 257 | ### ---- Functions for the training part of the program ----
 258 | # Make a function that combines the adress cubes and makes a list of class adresses
 259 | def convert(file_list, save = False, savename = 'adress_list', ex_adjust = False):
 260 |     # file_list: list of file names(strings) of adresses for the different classes
 261 |     # save: boolean that determines if a new ixz file should be saved with adresses and class numbers
 262 |     # savename: desired name of new .ixz-file
 263 |     # ex_adjust: boolean that determines if the amount of each class should be approximately equalized
 264 | 
 265 |     # Make an array of that holds the number of each example provided, if equalization is needed
 266 |     if ex_adjust:
 267 |         len_array = np.zeros(len(file_list),dtype = np.float32)
 268 |         for i in range(len(file_list)):
 269 |             len_array[i] = len(np.loadtxt(file_list[i], skiprows=0, usecols = range(3), dtype = np.float32))
 270 | 
 271 |         # Cnvert this array to a multiplier that determines how many times a given class set needs to be
 272 |         len_array /= max(len_array)
 273 |         multiplier = 1//len_array
 274 | 
 275 | 
 276 |     # preallocate space for the adr_list, the output containing all the adresses and classes
 277 |     adr_list = np.empty([0,4], dtype = np.int32)
 278 | 
 279 |     # Itterate through the list of example adresses and store the class as an integer
 280 |     for i in range(len(file_list)):
 281 |         a = np.loadtxt(file_list[i], skiprows=0, usecols = range(3), dtype = np.int32)
 282 |         adr_list = np.append(adr_list,np.append(a,i*np.ones((len(a),1),dtype = np.int32),axis=1),axis=0)
 283 | 
 284 |         # If desired copy the entire list by the multiplier calculated
 285 |         if ex_adjust:
 286 |             for k in range(int(multiplier[i])-1):
 287 |                 adr_list = np.append(adr_list,np.append(a,i*np.ones((len(a),1),dtype = np.int32),axis=1),axis=0)
 288 | 
 289 |     # Add the option to save it as an external file
 290 |     if save:
 291 |         # save the file as the given str-name
 292 |         np.savetxt(savename + '.ixz', adr_list, fmt = '%i')
 293 | 
 294 |     # Return the list of adresses and classes as a numpy array
 295 |     return adr_list
 296 | 
 297 | 
 298 | 
 299 | # Function for example creating
 300 | # Outputs a dictionary with pairs of cube tuples and labels
 301 | def ex_create(adr_arr,seis_arr,seis_spec,num_examp,cube_incr,inp_res=np.float64,sort_adr = False,replace_illegals = True):
 302 |     # adr_arr: 4-column numpy matrix that holds a header in the first row, then adress and class information for examples
 303 |     # seis_arr: 3D numpy array that holds a seismic cube
 304 |     # seis_spec: object that holds the specifications of the seismic cube;
 305 |     # num_examp: the number of output mini-cubes that should be created
 306 |     # cube_incr: the number of increments included in each direction from the example to make a mini-cube
 307 |     # inp_res: input resolution, the formatting of the seismic cube (could be changed to 8-bit data)
 308 |     # sort_adr: boolean; whether or not to sort the randomly drawn adresses before making the example cubes
 309 |     # replace_illegals: boolean; whether or not to draw a new sample in place for an illegal one, or not
 310 | 
 311 |     # Define the cube size
 312 |     cube_size = 2*cube_incr+1
 313 | 
 314 |     # Define some boundary parameters given in the input object
 315 |     inline_start = seis_spec.inl_start
 316 |     inline_end = seis_spec.inl_end
 317 |     inline_step = seis_spec.inl_step
 318 |     xline_start = seis_spec.xl_start
 319 |     xline_end = seis_spec.xl_end
 320 |     xline_step = seis_spec.xl_step
 321 |     t_start = seis_spec.t_start
 322 |     t_end = seis_spec.t_end
 323 |     t_step = seis_spec.t_step
 324 |     num_channels = seis_spec.cube_num
 325 | 
 326 |     # Define the buffer zone around the edge of the cube that defines the legal/illegal adresses
 327 |     inl_min = inline_start + inline_step*cube_incr
 328 |     inl_max = inline_end - inline_step*cube_incr
 329 |     xl_min = xline_start + xline_step*cube_incr
 330 |     xl_max = xline_end - xline_step*cube_incr
 331 |     t_min = t_start + t_step*cube_incr
 332 |     t_max = t_end - t_step*cube_incr
 333 | 
 334 |     # Print the buffer zone edges
 335 |     print('Defining the buffer zone:')
 336 |     print('(inl_min,','inl_max,','xl_min,','xl_max,','t_min,','t_max)')
 337 |     print('(',inl_min,',',inl_max,',',xl_min,',',xl_max,',',t_min,',',t_max,')')
 338 |     # Also give the buffer values in terms of indexes
 339 |     print('(',cube_incr,',',((inline_end-inline_start)//inline_step) - cube_incr,\
 340 |           ',',cube_incr,',',((xline_end-xline_start)//xline_step) - cube_incr,\
 341 |           ',',cube_incr,',',((t_end-t_start)//t_step) - cube_incr,')')
 342 | 
 343 |     # We preallocate the function outputs; a list of examples and a list of labels
 344 |     examples = np.empty((num_examp,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 345 |     labels = np.empty(num_examp,dtype=np.int8)
 346 | 
 347 |     # If we want to stack the examples in the third dimension we use the following example preallocation in stead
 348 |     # examples = np.empty((num_examp*(cube_size),(cube_size),(cube_size)),dtype=inp_res)
 349 | 
 350 |     # Generate a random list of indexes to be drawn, and make sure it only takes a legal amount of examples
 351 |     try:
 352 |         max_row_idx = len(adr_arr)-1
 353 |         rand_idx = random.sample(range(0, max_row_idx), num_examp)
 354 |         # NOTE: Could be faster to sort indexes before making examples for algorithm optimization
 355 |         if sort_adr:
 356 |             rand_idx.sort()
 357 |     except ValueError:
 358 |         print('Sample size exceeded population size.')
 359 | 
 360 |     # Make an iterator for when the lists should become shorter(if we have replacement of illegals or not)
 361 |     n=0
 362 |     for i in range(num_examp):
 363 |         # Get a random in-line, x-line, and time value, and store the label
 364 |         # Make sure there is room for an example at this index
 365 |         for j in range(50):
 366 |             adr = adr_arr[rand_idx[i]]
 367 |             # Check that the given example is within the legal zone
 368 |             if (adr[0]>=inl_min and adr[0]<inl_max) and \
 369 |                 (adr[1]>=xl_min and adr[1]<xl_max) and \
 370 |                 (adr[2]>=t_min and adr[2]<t_max):
 371 |                 # Make the example for the given address
 372 |                 # Convert the adresses to indexes and store the examples in the 4th dimension
 373 |                 idx = [(adr[0]-inline_start)//inline_step,(adr[1]-xline_start)//xline_step,(adr[2]-t_start)//t_step]
 374 | 
 375 | 
 376 |                 examples[i-n,:,:,:,:] = seis_arr[idx[0]-cube_incr:idx[0]+cube_incr+1,\
 377 |                               idx[1]-cube_incr:idx[1]+cube_incr+1,\
 378 |                               idx[2]-cube_incr:idx[2]+cube_incr+1,:]
 379 | 
 380 |                 # Put the cube and label into the lists
 381 |                 labels[i-n] = adr[-1]
 382 | 
 383 |                 # Alternatively; stack the examples in the third dimension
 384 |                 #datasets[(i-n)*(cube_size):(i-n+1)*(cube_size),:,:] = ex
 385 |                 break
 386 |             else:
 387 |                 # If we want to replace the illegals, draw again
 388 |                 if replace_illegals:
 389 |                     rand_idx[i] = random.randint(0,max_row_idx)
 390 |                 else:
 391 |                     # if not, just make the output lists shorter
 392 |                     n += 1
 393 |                     break
 394 | 
 395 |             if j == 50:
 396 |                 # If we can't get a proper cube in 50 consequtive tries
 397 |                 print('Badly conditioned dataset!')
 398 | 
 399 |     # Slice the data if desired
 400 |     #labels = labels[0:i-n+1]
 401 |     #examples = examples[0:i-n+1,:,:,:]
 402 | 
 403 |     # Return the output list/tuple (slice it if it has been shortened)
 404 |     return (examples[0:i-n+1,:,:,:,:], labels[0:i-n+1])
 405 | 
 406 | 
 407 | # Function that takes the epoch as input and returns the desired learning rate
 408 | def adaptive_lr(input_int):
 409 |     # input_int: the epoch that is currently being entered
 410 | 
 411 |     # define the learning rate (quite arbitrarily decaying)
 412 |     lr = 0.1**input_int
 413 | 
 414 |     #return the learning rate
 415 |     return lr
 416 | 
 417 | 
 418 | # Make the network structure and outline, and train it
 419 | def train_model(segy_obj,class_array,num_classes,cube_incr,inp_res = np.float64,\
 420 |                 num_bunch = 10,num_epochs = 100,num_examples = 10000,batch_size = 32,\
 421 |                 opt_patience = 5, data_augmentation=False,num_channels = 1,\
 422 |                 keras_model = None,write_out = False,write_location = 'default_write'):
 423 |     # segy_obj: Object returned from the segy_decomp function
 424 |     # class_array: numpy array of class adresses and type, returned from the convert function
 425 |     # num_classes: number of destinct classes we are training on
 426 |     # cube_incr: number of increments included in each direction from the example to make a mini-cube
 427 |     # inp_res: input resolution, the formatting of the seismic cube (could be changed to 8-bit data)
 428 |     # num_bunch: number of times we draw a new ensemble of training data and train on it
 429 |     # num_epochs: number of epochs we train on a given ensemble of training data
 430 |     # num_examples: number of examples we draw in an ensemble
 431 |     # batch_size: number of mini-batches we go through at a time from the number of examples
 432 |     # opt_patience: epochs that can pass without improvement in accuracy before the system breaks the loop
 433 |     # data_augmentation: boolean which determines whether or not to apply augmentation on the examples
 434 |     # num_channels: number of segy-cubes we have imported simultaneously
 435 |     # keras_model: existing keras model to be improved if the user wants to improve and not create a new model
 436 |     # write_out: boolean; save the trained model to disk or not,
 437 |     # write_location: desired location on the disk for the model to be saved
 438 | 
 439 |     # Check if the user wants to make a new model, or train an existing input model
 440 |     if keras_model == None:
 441 |         # Begin setting up model architecture and parameters
 442 |         cube_size = 2*cube_incr+1
 443 | 
 444 |         #  This model is loosely built after that of Anders Waldeland (5 Convolutional layers
 445 |         #  and 2 fully connected layers with rectified linear and softmax activations)
 446 |         # We have added drop out and batch normalization our selves, and experimented with multi-prediction
 447 |         model = Sequential()
 448 |         model.add(Conv3D(50, (5, 5, 5), padding='same', input_shape=(cube_size,cube_size,cube_size,num_channels), strides=(4, 4, 4), \
 449 |                          data_format="channels_last",name = 'conv_layer1'))
 450 |         model.add(BatchNormalization())
 451 |         model.add(Activation('relu'))
 452 |         model.add(Conv3D(50, (3, 3, 3), strides=(2, 2, 2), padding = 'same',name = 'conv_layer2'))
 453 |         model.add(Dropout(0.2))
 454 |         model.add(BatchNormalization())
 455 |         model.add(Activation('relu'))
 456 |         model.add(Conv3D(50, (3, 3, 3), strides=(2, 2, 2), padding= 'same',name = 'conv_layer3'))
 457 |         model.add(Dropout(0.2))
 458 |         model.add(BatchNormalization())
 459 |         model.add(Activation('relu'))
 460 |         model.add(Conv3D(50, (3, 3, 3), strides=(2, 2, 2), padding= 'same',name = 'conv_layer4'))
 461 |         model.add(Dropout(0.2))
 462 |         model.add(BatchNormalization())
 463 |         model.add(Activation('relu'))
 464 |         model.add(Conv3D(50, (3, 3, 3), strides=(2, 2, 2), padding= 'same',name = 'conv_layer5'))
 465 |         model.add(Flatten())
 466 |         model.add(Dense(50,name = 'dense_layer1'))
 467 |         model.add(BatchNormalization())
 468 |         model.add(Activation('relu'))
 469 |         model.add(Dense(10,name = 'attribute_layer'))
 470 |         model.add(BatchNormalization())
 471 |         model.add(Activation('relu'))
 472 |         model.add(Dense(num_classes, name = 'pre-softmax_layer'))
 473 |         model.add(BatchNormalization())
 474 |         model.add(Activation('softmax'))
 475 | 
 476 |         # initiate the Adam optimizer with a given learning rate (Note that this is adapted later)
 477 |         opt = keras.optimizers.adam(lr=0.001)
 478 | 
 479 |         # Compile the model with the desired loss, optimizer, and metric
 480 |         model.compile(loss='categorical_crossentropy',
 481 |                   optimizer=opt,
 482 |                   metrics=['accuracy'])
 483 |     else:
 484 |         # Define the model we are performing training on as the input model
 485 |         model = keras_model
 486 | 
 487 |     ### Begin actual model training
 488 |     # Define some initial parameters, and the early stopping and adaptive learning rate callback
 489 |     early_stopping = EarlyStopping(monitor='acc', patience=opt_patience)
 490 |     LR_sched = LearningRateScheduler(schedule = adaptive_lr)
 491 | 
 492 |     # Potential for adding tensor board functionality to see the change of parameters with time
 493 |     #tensor_board = TensorBoard(log_dir='./logs', histogram_freq=1, batch_size=32,\
 494 |     #                            write_graph=True, write_grads=True, write_images=True,\
 495 |     #                            embeddings_freq=1, embeddings_layer_names=None, embeddings_metadata=None)
 496 | 
 497 |     # Start the timer for the training iterations
 498 |     start = time.time()
 499 | 
 500 |     # Train the model
 501 |     for i in range(num_bunch):
 502 |         # Give an update as to how many times we have drawn a new example set
 503 |         print('Iteration number:',i+1,'/',num_bunch)
 504 | 
 505 |         # Make the examples
 506 |         print('Starting training data creation:')
 507 |         (x_train, y_train) = ex_create(adr_arr = class_array,
 508 |                                        seis_arr = segy_obj.data,
 509 |                                        seis_spec = segy_obj,
 510 |                                        num_examp = num_examples,
 511 |                                        cube_incr = cube_incr,
 512 |                                        inp_res = inp_res,
 513 |                                        sort_adr = False,
 514 |                                        replace_illegals = True)
 515 | 
 516 |         print('Finished creating',num_examples,'examples!')
 517 | 
 518 |         # Define and reshape the training data
 519 |         # x_train = np.expand_dims(x_train,axis=4)
 520 | 
 521 |         # Convert labels to one-hot encoding(and if necessary change the data type and scale as needed)
 522 |         y_train = keras.utils.to_categorical(y_train, num_classes)
 523 | 
 524 |         # See if the user has chosen to implement data_augmentation and implement it if so
 525 |         if not data_augmentation:
 526 |             print('Not using data augmentation.')
 527 |             # Run the model training
 528 |             history = model.fit(x=x_train,
 529 |                                 y=y_train,
 530 |                                 batch_size=batch_size,
 531 |                                 validation_split=0.2,
 532 |                                 callbacks=[early_stopping, LR_sched],
 533 |                                 epochs=num_epochs,
 534 |                                 shuffle=True)
 535 | 
 536 |         else:
 537 |             # !!! Currently does not work
 538 |             print('Using real-time data augmentation.')
 539 |             # This will do preprocessing and realtime data augmentation
 540 |             datagen = ImageDataGenerator(featurewise_center=False,  # set input mean to 0 over the dataset
 541 |                                          samplewise_center=False,  # set each sample mean to 0
 542 |                                          featurewise_std_normalization=False,  # divide inputs by std of the dataset
 543 |                                          samplewise_std_normalization=False,  # divide each input by its std
 544 |                                          zca_whitening=False,  # apply ZCA whitening
 545 |                                          rotation_range=20,  # randomly rotate images in the range (degrees, 0 to 180)
 546 |                                          width_shift_range=0.2,  # randomly shift images horizontally (fraction of total width)
 547 |                                          height_shift_range=0.2,  # randomly shift images vertically (fraction of total height)
 548 |                                          horizontal_flip=True,  # randomly flip images
 549 |                                          vertical_flip=False,    # randomly flip images
 550 |                                          shear_range = 0.349, # shear intensity (counter-clockwise direction in radians)
 551 |                                          zoom_range = 0.2,   # range for random zoom (float)
 552 |                                          rescale = 1.5)  # rescaling factor which multiplies data by the value provided
 553 | 
 554 |             # Compute quantities required for feature-wise normalization
 555 |             # (std, mean, and principal components if ZCA whitening is applied).
 556 |             datagen.fit(x_train)
 557 | 
 558 |             # Fit the model on the batches generated by datagen.flow().
 559 |             history = model.fit_generator(datagen.flow(x_train,
 560 |                                                        y_train,
 561 |                                                        batch_size = batch_size),
 562 |                                           steps_per_epoch = x_train.shape[0] // batch_size,
 563 |                                           epochs = num_epochs,
 564 |                                           validation_data = (x_test, y_test))
 565 | 
 566 |         # Print the training summary
 567 |         print(model.summary())
 568 | 
 569 | 
 570 | 
 571 |         # Set the time for one training iteration
 572 |         if i == 0:
 573 |             end = time.time()
 574 |             tot_time = (end-start)*num_bunch
 575 | 
 576 | 
 577 | 
 578 |         # Give an update on the time remaining
 579 |         rem_time = ((num_bunch-(i+1))/num_bunch)*tot_time
 580 | 
 581 |         if rem_time <= 300:
 582 |             print('Approximate time remaining of the training:',rem_time,' sec.')
 583 |         elif 300 < rem_time <= 60*60:
 584 |             minutes = rem_time//60
 585 |             seconds = (rem_time%60)*(60/100)
 586 |             print('Approximate time remaining of the training:',minutes,' min., ',seconds,' sec.')
 587 |         elif 60*60 < rem_time <= 60*60*24:
 588 |             hours = rem_time//(60*60)
 589 |             minutes = (rem_time%(60*60))*(1/60)*(60/100)
 590 |             print('Approximate time remaining of the training:',hours,' hrs., ',minutes,' min., ')
 591 |         else:
 592 |             days = time_rem//(24*60*60)
 593 |             hours = (time_rem%(24*60*60))*(1/60)*((1/60))*(24/100)
 594 |             print('Approximate time remaining of the training:',days,' days, ',hours,' hrs., ')
 595 | 
 596 | 
 597 |     # Save the trained model if the user has chosen to do so
 598 |     if write_out:
 599 |         print('Saving model: ...')
 600 |         model.save(write_location + '.h5')
 601 |         print('Model saved.')
 602 | 
 603 | 
 604 |     # Return the trained model
 605 |     return model
 606 | 
 607 | 
 608 | 
 609 | ### ---- Functions for the prediction part of the program ----
 610 | # Parse the cube into sub-cubes suitable as model input
 611 | def cube_parse(seis_arr,cube_incr,inp_res = np.float64, mode = 'trace', padding = False,\
 612 |                conc = False, inline_num = 0, xline_num = 0, depth = 0):
 613 |     # seis_arr: a 3D numpy array that holds a seismic cube
 614 |     # cube_incr: number of increments included in each direction from the example to make a mini-cube
 615 |     # inp_res: input resolution, the formatting of the seismic cube (could be changed to 8-bit data)
 616 |     # mode: how much of the 3D-cube should be converted to examples ('full','xline','inline','trace', or 'point')
 617 |     # padding: do we want to pad the zone which is outside our buffer with zeroes?
 618 |     # conc: do we want to concattenate the examples, or store them in the same matrix they were fed to us?
 619 |     # inline_num: if mode is inline or point; what inline do we use?
 620 |     # xline_num: if mode is xline or point; what xline do we use?
 621 |     # depth: if mode is point; what depth do we use?
 622 | 
 623 |     # Make some initial definitions wrt. dimensionality
 624 |     inls = seis_arr.shape[0]
 625 |     xls = seis_arr.shape[1]
 626 |     zls = seis_arr.shape[2]
 627 |     num_channels = seis_arr.shape[3]
 628 |     cube_size = 2*cube_incr+1
 629 | 
 630 |     # Define the indent where the saved data will start, if user wants padding this is 0, else it is cube_incr
 631 |     if padding:
 632 |         i_re = 0
 633 |         x_re = 0
 634 |         z_re = 0
 635 |         # Preallocate the output array, if concatenated it's 4 dimensional, if not it's 6 dimensional
 636 |         if conc:
 637 |             # Make adjustments to the parameters so that we iterate over the right number of samples, etc.
 638 |             if mode == 'full':
 639 |                 examples = np.zeros((inls*xls*zls,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 640 |             elif mode == 'inline':
 641 |                 examples = np.zeros((xls*zls,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 642 |                 x_re = cube_incr
 643 |             elif mode == 'xline':
 644 |                 examples = np.zeros((inls*zls,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 645 |                 i_re = cube_incr
 646 |             elif mode == 'trace':
 647 |                 examples = np.zeros((zls,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 648 |                 i_re = cube_incr
 649 |                 x_re = cube_incr
 650 |             elif mode == 'point':
 651 |                 examples = np.zeros((1,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 652 |                 i_re = cube_incr
 653 |                 x_re = cube_incr
 654 |                 z_re = cube_incr
 655 |             else:
 656 |                 print('ERROR: invalid mode! use: ''full'',''xline'',''inline'',''trace'', or ''point''')
 657 |             # Take into account that we will have a total smaller dimensionality of data due to illegals
 658 |             inls -= 2*cube_incr
 659 |             xls -= 2*cube_incr
 660 |             zls -= 2*cube_incr
 661 |         else:
 662 |             # Make adjustments to the parameters so that we iterate over the right number of samples, etc.
 663 |             if mode == 'full':
 664 |                 examples = np.zeros((inls,xls,zls,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 665 |             elif mode == 'inline':
 666 |                 examples = np.zeros((1,xls,zls,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 667 |                 x_re = cube_incr
 668 |             elif mode == 'xline':
 669 |                 examples = np.zeros((inls,1,zls,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 670 |                 i_re = cube_incr
 671 |             elif mode == 'trace':
 672 |                 examples = np.zeros((1,1,zls,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 673 |                 i_re = cube_incr
 674 |                 x_re = cube_incr
 675 |             elif mode == 'point':
 676 |                 examples = np.zeros((1,1,1,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 677 |                 i_re = cube_incr
 678 |                 x_re = cube_incr
 679 |                 z_re = cube_incr
 680 |             else:
 681 |                 print('ERROR: invalid mode! use: ''full'',''xline'',''inline'',''trace'', or ''point''')
 682 |     else:
 683 |         i_re = cube_incr
 684 |         x_re = cube_incr
 685 |         z_re = cube_incr
 686 |         # Preallocate the output array, if concatenated it's 5 dimensional, if not it's 7 dimensional
 687 |         if conc:
 688 |             # Make adjustments to the parameters so that we iterate over the right number of samples, etc.
 689 |             if mode == 'full':
 690 |                 examples = np.empty(((inls-2*cube_incr)*(xls-2*cube_incr)*(zls-2*cube_incr),cube_size,cube_size,cube_size,num_channels),\
 691 |                                    dtype=inp_res)
 692 |             elif mode == 'inline':
 693 |                 examples = np.empty(((xls-2*cube_incr)*(zls-2*cube_incr),cube_size,cube_size,cube_size,num_channels),\
 694 |                                    dtype=inp_res)
 695 |                 inline_num -= cube_incr
 696 |                 xline_num = 0
 697 |                 depth = 0
 698 |             elif mode == 'xline':
 699 |                 examples = np.empty(((inls-2*cube_incr)*(zls-2*cube_incr),cube_size1,cube_size,cube_size,num_channels),\
 700 |                                    dtype=inp_res)
 701 |                 inline_num = 0
 702 |                 xline_num -= cube_incr
 703 |                 depth = 0
 704 |             elif mode == 'trace':
 705 |                 examples = np.empty((zls-2*cube_incr,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 706 |                 inline_num -= cube_incr
 707 |                 xline_num -= cube_incr
 708 |                 depth = 0
 709 |             elif mode == 'point':
 710 |                 examples = np.empty((1,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 711 |                 inline_num -= cube_incr
 712 |                 xline_num -= cube_incr
 713 |                 depth -= cube_incr
 714 |             else:
 715 |                 print('ERROR: invalid mode! use: ''full'',''xline'',''inline'',''trace'', or ''point''')
 716 |             # Take into account that we will have a total smaller dimensionality of data due to illegals
 717 |             inls -= 2*cube_incr
 718 |             xls -= 2*cube_incr
 719 |             zls -= 2*cube_incr
 720 |         else:
 721 |             if mode == 'full':
 722 |                 examples = np.empty(((inls-2*cube_incr),(xls-2*cube_incr),(zls-2*cube_incr),cube_size,cube_size,cube_size,num_channels),\
 723 |                                    dtype=inp_res)
 724 |             elif mode == 'inline':
 725 |                 examples = np.empty((1,(xls-2*cube_incr),(zls-2*cube_incr),cube_size,cube_size,cube_size,num_channels),\
 726 |                                    dtype=inp_res)
 727 |             elif mode == 'xline':
 728 |                 examples = np.empty(((inls-2*cube_incr),1,(zls-2*cube_incr),cube_size,cube_size,cube_size,num_channels),\
 729 |                                    dtype=inp_res)
 730 |             elif mode == 'trace':
 731 |                 examples = np.empty((1,1,(zls-2*cube_incr),cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 732 |             elif mode == 'point':
 733 |                 examples = np.empty((1,1,1,cube_size,cube_size,cube_size,num_channels),dtype=inp_res)
 734 |             else:
 735 |                 print('ERROR: invalid mode! use: ''full'',''xline'',''inline'',''trace'', or ''point''')
 736 | 
 737 | 
 738 |     # Iterate through the desired section of the 3D input array, create the example cubes, and store them as desired
 739 |     if conc:
 740 |         # Make the cubes
 741 |         for i in range(cube_incr, inls+cube_incr):
 742 |             if mode == 'xline':
 743 |                 j = xline_num
 744 |                 for k in range(cube_size, zls+cube_size):
 745 |                     examples[inls*(i-i_re)+k-z_re,:,:,:,:] = seis_arr[i-cube_incr+inline_num:i+cube_incr+inline_num+1,\
 746 |                                                                     j-cube_incr:j+cube_incr+1,\
 747 |                                                                     k-cube_incr+depth:k+cube_incr+depth+1,:]
 748 |             else:
 749 |                 for j in range(cube_incr, xls+cube_incr):
 750 |                     for k in range(cube_incr, zls+cube_incr):
 751 |                         examples[(i-i_re)*inls+(j-x_re)*xls+k-z_re,:,:,:,:] = \
 752 |                                                             seis_arr[i-cube_incr+inline_num:i+cube_incr+inline_num+1,\
 753 |                                                                      j-cube_incr+xline_num:j+cube_incr+xline_num+1,\
 754 |                                                                      k-cube_incr+depth:k+cube_incr+depth+1,:]
 755 | 
 756 |                         # Make sure we stop after the appropriate number of iterations
 757 |                         if mode == 'point':
 758 |                             break
 759 |                     if mode == 'point' or mode == 'trace':
 760 |                         break
 761 |                 if mode == 'point' or mode == 'trace' or mode == 'inline':
 762 |                     break
 763 | 
 764 | 
 765 |     else:
 766 |         # Make the cubes
 767 |         for i in range(cube_incr, inls-cube_incr):
 768 |             if mode == 'xline':
 769 |                 for k in range(cube_incr, zls-cube_incr):
 770 |                     examples[i-i_re,1,k-z_re,:,:,:,:] = seis_arr[i-cube_incr:i+cube_incr+1,\
 771 |                                                                xline_num-cube_incr:xline_num+cube_incr+1,\
 772 |                                                                k-cube_incr:k+cube_incr+1,:]
 773 |             else:
 774 |                 for j in range(cube_incr, xls-cube_incr):
 775 |                     for k in range(cube_incr, zls-cube_incr):
 776 |                         examples[i-i_re,j-x_re,k-z_re,:,:,:,:] = seis_arr[i+inline_num-cube_incr:i+inline_num+cube_incr+1,\
 777 |                                                                         j+xline_num-cube_incr:j+xline_num+cube_incr+1,\
 778 |                                                                         k+depth-cube_incr:k+depth+cube_incr+1,:]
 779 | 
 780 |                         # Make sure we stop after the appropriate number of iterations
 781 |                         if mode == 'point':
 782 |                             break
 783 |                     if mode == 'point' or mode == 'trace':
 784 |                         break
 785 |                 if mode == 'point' or mode == 'trace' or mode == 'inline':
 786 |                     break
 787 | 
 788 | 
 789 |     # Return the list of examples stored as the desired type of array
 790 |     return examples
 791 | 
 792 | 
 793 | 
 794 | # Make an intermediate output model to check filters
 795 | def makeIntermediate(keras_model,layer_name):
 796 |     # keras_model: keras model that has been trained previously
 797 |     # layer_name: name of the layer with the desired output
 798 | 
 799 |     # Define the new model that stops at the desired layer
 800 |     intermediate_layer_model = Model(inputs=keras_model.input,\
 801 |                                      outputs=keras_model.get_layer(layer_name).output)
 802 | 
 803 |     # Return the newly defined model
 804 |     return intermediate_layer_model
 805 | 
 806 | 
 807 | 
 808 | # Predict the output class of the given input traces
 809 | def predicting(filename,inp_seis,seis_obj,keras_model,cube_incr,num_classes,inp_res=np.float64,mode='xline',\
 810 |                section=np.asarray([0,0,0,0,0,0]),line_num=0, print_segy = False,savename = 'default_write',\
 811 |                pred_batch = 1,show_features = False, layer_name='attribute_layer', show_prob = False):
 812 |     # filename: filename of the segy-cube to be imported (necessary for copying the segy-frame before writing a new segy)
 813 |     # inp_seis: a 3D numpy array that holds the input seismic cube
 814 |     # seis_obj: Object returned from the segy_decomp function
 815 |     # keras_model: keras model that has been trained previously
 816 |     # cube_incr: number of increments included in each direction from the example to make a mini-cube
 817 |     # num_classes: num_classes: number of destinct classes we are training on
 818 |     # inp_res: input resolution, the formatting of the seismic cube (could be changed to 8-bit data)
 819 |     # mode: what part of the cube to predict along; 'inline', 'xline', 'section, or 'full' (entire cube)
 820 |     # section: edge locations(index) of the sub-section (min. inline, max. inline, min. xline, max xline, min z, max z)
 821 |     # line_num: xline/inline number to predict along
 822 |     # print_segy: whether or not to save the prediction as a segy, npy and csv file (previously just segy)
 823 |     # savename: name of the files to be saved (extensions are added automatically)
 824 |     # pred_batch: number of traces to predict on at a time
 825 |     # show_features: whether or not to get the features or the classes
 826 |     # layer_name: optionally give a different layer to get the features from (name defined in keras.model)
 827 |     # show_prob: if the user wants to get out probabilities or classifications
 828 | 
 829 |     # Define some initial parameters
 830 |     num_channels = seis_obj.cube_num
 831 |     inls = inp_seis.shape[0]
 832 |     xls = inp_seis.shape[1]
 833 |     zls = inp_seis.shape[2]
 834 |     cube_size = 2*cube_incr+1
 835 | 
 836 |     # If the user simply wants the classification we only need 1 value for each input point,
 837 |     if not show_prob:
 838 |         num_classes = 1
 839 | 
 840 |     # Read the section needed for prediction depending on the mode
 841 |     if mode == 'inline':
 842 |         section_edge = np.asarray([line_num,line_num,cube_incr,xls-cube_incr,cube_incr,zls-cube_incr])
 843 |     elif mode == 'xline':
 844 |         section_edge = np.asarray([cube_incr,inls-cube_incr,line_num,line_num,cube_incr,zls-cube_incr])
 845 |     elif mode == 'section':
 846 |         section_edge = section
 847 |     elif mode == 'full':
 848 |         section_edge = np.asarray([cube_incr,inls-cube_incr,cube_incr,xls-cube_incr,cube_incr,zls-cube_incr])
 849 |     else:
 850 |         print('invalid mode, please input inline, xline, section, or full')
 851 | 
 852 |     # Preallocate the full prediction array and if the user wants to show the features make the intermediate model,
 853 |     if show_features:
 854 |         intermediate_layer_model = Model(inputs=keras_model.input,
 855 |                                          outputs=keras_model.get_layer(layer_name).output)
 856 |         prediction = np.empty((\
 857 |             (section_edge[5]-section_edge[4]+1)*(section_edge[3]-section_edge[2]+1)*(section_edge[1]-section_edge[0]+1),10),\
 858 |                               dtype=np.float32)
 859 |     else:
 860 |         prediction = np.empty((\
 861 |             (section_edge[5]-section_edge[4]+1)*(section_edge[3]-section_edge[2]+1)*(section_edge[1]-section_edge[0]+1),\
 862 |                                num_classes),dtype=np.float32)
 863 | 
 864 |     # Preallocate the data array to fill for each batch and initiate iterators
 865 |     data = np.empty((pred_batch*(section_edge[5]-section_edge[4]+1),cube_size,cube_size,cube_size,num_channels), dtype=inp_res)
 866 |     indx = 0
 867 |     jndx = 0
 868 | 
 869 |     # Calculate how many sets of batches need to be done and define parameters needed for the final batch
 870 |     tot_len = (section[1]-section[0]+1)*(section[3]-section[2]+1)
 871 |     rem = tot_len % pred_batch
 872 |     num_it = tot_len // pred_batch
 873 |     # Time the sub_prediction
 874 |     start = time.time()
 875 | 
 876 |     # Start making sub-cubes from the input traces and store then in the data array
 877 |     print('Retrieving to memory:')
 878 |     for il_num in range(section_edge[0],section_edge[1]+1):
 879 |         # Make a progres update for the inline number
 880 |         print('inline-num:',il_num-section_edge[0]+1,'/',section_edge[1]-section_edge[0]+1)
 881 |         for xl_num in range(section_edge[2],section_edge[3]+1):
 882 |             # Make a progres update for the xline number
 883 |             print('xline-num:',xl_num-section_edge[2]+1,'/',section_edge[3]-section_edge[2]+1)
 884 |             for z_num in range(section_edge[5]-section_edge[4]+1):
 885 |                 # Call the cube_parse function to get the cubes corresponding to the current point
 886 |                 data[indx*(section_edge[5]-section_edge[4]+1)+z_num,:,:,:,:] = cube_parse(seis_arr = inp_seis,
 887 |                                                                                         cube_incr = cube_incr,
 888 |                                                                                         inp_res = inp_res,
 889 |                                                                                         mode = 'point',
 890 |                                                                                         padding = False,
 891 |                                                                                         conc = True,
 892 |                                                                                         inline_num = il_num,
 893 |                                                                                         xline_num = xl_num,
 894 |                                                                                         depth = z_num+section_edge[4])
 895 | 
 896 |             # Check if we have filled up the data array and need to do a prediction
 897 |             if (indx+1) % pred_batch == 0:
 898 |                 print('Making prediction on sub-section:')
 899 | 
 900 |                 # Predict the given class or features dependant on the user input
 901 |                 if show_features:
 902 |                     prediction[jndx*(pred_batch*(section_edge[5]-section_edge[4]+1)):\
 903 |                               (jndx+1)*(pred_batch*(section_edge[5]-section_edge[4]+1)),:] = \
 904 |                                     intermediate_layer_model.predict((data))
 905 | 
 906 |                 else:
 907 |                     if show_prob:
 908 |                         # Simple model prediction with probabilities
 909 |                         prediction[jndx*(pred_batch*(section_edge[5]-section_edge[4]+1)):\
 910 |                                    (jndx+1)*(pred_batch*(section_edge[5]-section_edge[4]+1)),:] = \
 911 |                         keras_model.predict((data))
 912 |                     else:
 913 |                         # Model prediction of classes
 914 |                         prediction[jndx*(pred_batch*(section_edge[5]-section_edge[4]+1)):\
 915 |                                    (jndx+1)*(pred_batch*(section_edge[5]-section_edge[4]+1)),:] = \
 916 |                         np.expand_dims(keras_model.predict_classes((data)),axis = 1)
 917 | 
 918 |                 # Tell the user the section is finished
 919 |                 print('Section finished!')
 920 | 
 921 |                 if jndx == 0:
 922 |                     # Finish the timer and calculate how long the user should expect the program to take:
 923 |                     end = time.time()
 924 |                     DT = end-start # seconds per iteration
 925 |                     tot_time = num_it*DT+(rem/pred_batch)*DT #seconds
 926 | 
 927 |                 # Give the user an update regarding the time remaining
 928 |                 time_rem = (tot_time-DT*(jndx+1))
 929 |                 if time_rem <= 300:
 930 |                     print('Approximate time remaining of the prediction:',time_rem, ' sec.')
 931 |                 elif 300 < time_rem <= 60*60:
 932 |                     minutes = time_rem//60
 933 |                     seconds = (time_rem%60)*(60/100)
 934 |                     print('Approximate time remaining of the prediction:',minutes,' min., ',seconds,' sec.')
 935 |                 elif 60*60 < time_rem <= 60*60*24:
 936 |                     hours = time_rem//(60*60)
 937 |                     minutes = (time_rem%(60*60))*(1/60)*(60/100)
 938 |                     print('Approximate time remaining of the prediction:',hours,' hrs., ',minutes,' min., ')
 939 |                 else:
 940 |                     days = time_rem//(24*60*60)
 941 |                     hours = (time_rem%(24*60*60))*(1/60)*((1/60))*(24/100)
 942 |                     print('Approximate time remaining of the prediction:',days,' days, ',hours,' hrs., ')
 943 | 
 944 | 
 945 |                 # Update iterators and give updates to user
 946 |                 indx = 0
 947 |                 jndx+=1
 948 |                 print('Retrieving to memory:')
 949 | 
 950 |             # Check if we have exhausted the range of data to be predicted and need to finish the function
 951 |             elif jndx == num_it and indx == rem-1:
 952 |                 # Slice the data array to only include the relevant part
 953 |                 data = data[:indx*(section_edge[5]-section_edge[4]+1)+z_num+1]
 954 | 
 955 |                 print('Finalizing prediction:')
 956 | 
 957 |                 # Make the final prediction
 958 |                 if show_features:
 959 |                     prediction[jndx*(pred_batch*(section_edge[5]-section_edge[4]+1)):,:] = \
 960 |                                     intermediate_layer_model.predict((data))
 961 |                 else:
 962 |                     if show_prob:
 963 |                         prediction[jndx*(pred_batch*(section_edge[5]-section_edge[4]+1)):,:] = \
 964 |                                     keras_model.predict((data))
 965 |                     else:
 966 |                         prediction[jndx*(pred_batch*(section_edge[5]-section_edge[4]+1)):,:] = \
 967 |                                     np.expand_dims(keras_model.predict_classes((data)),axis = 1)
 968 | 
 969 |             # If we should keep filling the data and not predict yet, simply increase the iterator
 970 |             else:
 971 |                 indx+=1
 972 | 
 973 |     # Reshape the prediction to the shape of the desired cube
 974 |     print('Reshaping prediction:')
 975 |     if show_features:
 976 |         prediction = prediction.reshape((section_edge[1]-section_edge[0]+1,\
 977 |                                          section_edge[3]-section_edge[2]+1,\
 978 |                                          section_edge[5]-section_edge[4]+1,10),order='C')
 979 |     else:
 980 |         prediction = prediction.reshape((section_edge[1]-section_edge[0]+1,\
 981 |                                          section_edge[3]-section_edge[2]+1,\
 982 |                                          section_edge[5]-section_edge[4]+1,num_classes),order='C')
 983 | 
 984 |     print('Prediction finished!')
 985 | 
 986 |     # Save the prediction as a segy, numpy and csv file
 987 |     # NOTE: Everything SEGY and CSV is made into 32bit-float to conform to commonly used reading programs
 988 |     if print_segy:
 989 |         # Update the data we send to the saver functions dependant on what we have predicted
 990 |         if show_prob:
 991 |             class_row = 1
 992 |         else:
 993 |             class_row = 0
 994 | 
 995 |         print('Saving prediction: ...')
 996 | 
 997 |         # Save the numpy file
 998 |         np.save(savename + '.npy', prediction)
 999 | 
1000 |         # Get the right filename in case the input is given as a list
1001 |         if type(filename) is list:
1002 |             # Save the segy file using the input filename as a framework
1003 |             # Just use the first member of the list as the reference
1004 |             input_file = filename[0]
1005 |         else:
1006 |             # Save the segy file using the input filename as a framework
1007 |             input_file=filename
1008 | 
1009 |         output_file=savename + '.sgy'
1010 | 
1011 |         copyfile(input_file, output_file)
1012 | 
1013 |         with segyio.open( output_file, "r+" ) as src:
1014 |             # iterate through each inline and update the values
1015 |             i = 0
1016 |             for ilno in src.ilines:
1017 |                 src.iline[ilno] = -1*(np.ones((src.iline[ilno].shape),dtype = np.float32))
1018 | 
1019 |                 if src.ilines[section_edge[0]] <= ilno <= src.ilines[section_edge[1]]:
1020 |                     line = src.iline[ilno]
1021 |                     line[section_edge[2]:section_edge[3]+1,section_edge[4]:section_edge[5]+1] = prediction[i,:,:,class_row]
1022 |                     src.iline[ilno]=line
1023 |                     i += 1
1024 | 
1025 |         # Save the csv(ixz) file
1026 |         csv_struct(inp_numpy = prediction[:,:,:,class_row],
1027 |                    spec_obj = seis_obj,
1028 |                    section = section_edge,
1029 |                    inp_res = np.float32,
1030 |                    save = True,
1031 |                    savename = (savename + '.ixz'))
1032 | 
1033 |         # Print to the user that the function has finished saving
1034 |         print('Prediction saved.')
1035 | 
1036 |     # Return the prediction array
1037 |     return prediction
1038 | 
1039 | 
1040 | 
1041 | ### ---- Functions for visualizing the predictions from the program ----
1042 | # Make a plotting function for plotting the features
1043 | def plotNNpred(pred,im_per_line,line_num,section):
1044 |     # pred: 4D-numpy array with the features in the 4th dimension
1045 |     # im_per_line: How many sub plot images to have in each row of the display
1046 |     # line_num: what xline to use as a reference
1047 |     # section: the section that was used for prediction
1048 | 
1049 |     # Define some initial parameters, like the number of features and plot size, etc.
1050 |     features = pred.shape[3]
1051 |     plt.figure(2, figsize=(20,20))
1052 |     n_columns = im_per_line
1053 |     n_rows = math.ceil(features / n_columns) + 1
1054 | 
1055 |     # Itterate through the sub-plots and fill them with the features, do some simple formatting
1056 |     for i in range(features):
1057 |         plt.subplot(n_rows, n_columns, i+1)
1058 |         plt.title('Feature ' + str(i+1))
1059 |         plt.imshow(pred[:,line_num-1,:,i].T, interpolation="nearest", cmap="rainbow",\
1060 |                    extent=[section[0],section[1],-section[5],-section[4]])
1061 |         plt.colorbar()
1062 | 
1063 | 
1064 | # Make and visualize the predicted data
1065 | def visualization(filename,inp_seis,seis_obj,keras_model,cube_incr,section_edge,xline_ref,num_classes,\
1066 |                   inp_res=np.float64,sect_form = None,save_pred = False, save_file = 'default_write', \
1067 |                   pred_batch = 1,show_feature = False, show_prob = True):
1068 |     # filename: filename of the segy-cube to be imported (necessary for copying the segy-frame before writing a new segy)
1069 |     # inp_seis: a 3D numpy array that holds the input seismic cube
1070 |     # seis_obj: Object returned from the segy_decomp function
1071 |     # keras_model: keras model that has been trained previously
1072 |     # cube_incr: number of increments included in each direction from the example to make a mini-cube
1073 |     # section_edge: edge locations of the sub-section; either index or (min. inline, max. inline, min. xline, max xline, min z, max z)
1074 |     # xline_ref: reference crossline from the original seismic cube to be plotted with the prediction (must be within section)
1075 |     # num_classes: number of classes to be predicted
1076 |     # inp_res: input resolution, the formatting of the seismic cube (could be changed to 8-bit data)
1077 |     # sect_form: formatting of the section edges (if 'segy' we have to convert iline,xline,time to indexes)
1078 |     # save_pred: whether or not to save the prediction as a segy, numpy and csv(ixz) file.
1079 |     # save_file: name of the files to be saved (extensions are added automatically)
1080 |     # pred_batch: number of traces to predict on at a time
1081 |     # show_features: whether or not to get the features or the classes
1082 |     # show_prob: if the user wants to get out probabilities or classifications
1083 | 
1084 | 
1085 | 
1086 |     # Adjust the section numbering and reference xline from inline-xline-time to index if this is given in segy format
1087 |     if sect_form == 'segy':
1088 |         section_edge[0] = (section_edge[0] - seis_obj.inl_start)//seis_obj.inl_step
1089 |         section_edge[1] = (section_edge[1] - seis_obj.inl_start)//seis_obj.inl_step
1090 |         section_edge[2] = (section_edge[2] - seis_obj.xl_start)//seis_obj.xl_step
1091 |         section_edge[3] = (section_edge[3] - seis_obj.xl_start)//seis_obj.xl_step
1092 |         section_edge[4] = (section_edge[4] - seis_obj.t_start)//seis_obj.t_step
1093 |         section_edge[5] = (section_edge[5] - seis_obj.t_start)//seis_obj.t_step
1094 |         xline_ref = (xline_ref - seis_obj.xl_start)//seis_obj.xl_step
1095 | 
1096 |     # Make the prediction
1097 |     pred = predicting(filename=filename,
1098 |                       inp_seis=inp_seis,
1099 |                       seis_obj=seis_obj,
1100 |                       keras_model=keras_model,
1101 |                       cube_incr=cube_incr,
1102 |                       num_classes = num_classes,
1103 |                       inp_res = inp_res,
1104 |                       mode='section',
1105 |                       section=section_edge,
1106 |                       line_num=0,
1107 |                       print_segy=save_pred,
1108 |                       savename=save_file,
1109 |                       pred_batch = pred_batch,
1110 |                       show_features=show_feature,
1111 |                       layer_name='attribute_layer',
1112 |                       show_prob = show_prob)
1113 | 
1114 |     # Define some parameters used for getting nice plots(range of c-axis, and which row to show in the prediction)
1115 |     features = pred.shape[2]
1116 |     if show_prob:
1117 |         class_row = 1
1118 |         c_max = 1
1119 |     else:
1120 |         class_row = 0
1121 |         c_max = num_classes-1
1122 | 
1123 |     # Visualize the results from the prediction, either with features or classes/probabilities
1124 |     if show_feature:
1125 |         # Make the figure object/handle and plot the reference xline
1126 |         plt.figure(1, figsize=(15,15))
1127 |         plt.title('x-line')
1128 |         plt.imshow(inp_seis[cube_incr:-cube_incr,xline_ref,cube_incr:-cube_incr].T,interpolation="nearest",\
1129 |                    cmap="gray",extent=[cube_incr,-cube_incr+len(inp_seis),cube_incr-len(inp_seis[0,0]),-cube_incr])
1130 | 
1131 |         # Plot all the features and show the figures
1132 |         plotNNpred(pred,5,xline_ref-section_edge[2]+1,section_edge)
1133 |         plt.show()
1134 | 
1135 |     else:
1136 |         # Make the figure object/handle and plot the reference xline
1137 |         plt.figure(1, figsize=(15,15))
1138 |         gs = gridspec.GridSpec(1, 2, width_ratios=[3, 1])
1139 |         plt.subplot(gs[0])
1140 |         plt.title('x-line')
1141 |         plt.imshow(inp_seis[cube_incr:-cube_incr,xline_ref,cube_incr:-cube_incr].T,interpolation="nearest",\
1142 |                    cmap="gray",extent=[cube_incr,-cube_incr+len(inp_seis),cube_incr-len(inp_seis[0,0]),-cube_incr])
1143 |         plt.colorbar()
1144 | 
1145 |         # Plot the probability/classification and show the figures
1146 |         plt.subplot(gs[1])
1147 |         plt.title('classification/probability of 1')
1148 |         plt.imshow(pred[:,xline_ref-section_edge[2],:,class_row].T,interpolation="nearest", cmap="gist_rainbow", clim=(0.0, c_max),\
1149 |                   extent=[section_edge[0],section_edge[1],-section_edge[5],-section_edge[4]])
1150 |         plt.colorbar()
1151 |         plt.show()
1152 | 
1153 |     # Return the predicted numpy cube
1154 |     return pred
1155 | 
1156 | # Rough function to show more detailed plots of the predictions in python for QC before going to Petrel
1157 | def show_details(filename,cube_incr,predic,inline,inl_start,xline,xl_start,\
1158 |                  slice_number,slice_incr,inp_format=np.float64,show_prob = True,num_classes = 2):
1159 |     # filename: filename of the segy-cube to be imported (necessary for copying the segy-frame before writing a new segy)
1160 |     # cube_incr: number of increments included in each direction from the example to make a mini-cube
1161 |     # predic: numpy cube holding the prediction
1162 |     # inline: inline number to center our visualization on
1163 |     # inl_start: index of the first inline in the prediction
1164 |     # xline: xline number to center our visualization on
1165 |     # xl_start: index of the first xline in the prediction
1166 |     # slice_number: depth slice number to center our visualization on
1167 |     # slice_incr: increments to take in depth between each plot
1168 |     # inp_format: input resolution, the formatting of the seismic cube (could be changed to 8-bit data)
1169 |     # show_prob: if the user wants to get out probabilities or classifications
1170 |     # num_classes: number of classes that was predicted
1171 | 
1172 | 
1173 |     # Read out the reference segy object
1174 |     segy_obj = segy_decomp(segy_file = filename,
1175 |                            plot_data = False,
1176 |                            read_direc = 'xline',
1177 |                            inp_res = inp_format)
1178 | 
1179 |     # Get the numpy cube from the reference segy object
1180 |     inp_seis = segy_obj.data
1181 | 
1182 |     # define some parameters used for getting nice plots(range of c-axis, and which row to show in the prediction)
1183 |     if show_prob:
1184 |         class_row = 1
1185 |         c_max = 1
1186 |     else:
1187 |         class_row = 0
1188 |         c_max = num_classes-1
1189 | 
1190 |     # Make the figure object/handle and plot the reference xline
1191 |     plt.figure(1, figsize=(20,15))
1192 |     plt.subplot(1, 8, 1)
1193 |     plt.title('xline: ' + str(xline))
1194 |     plt.imshow(inp_seis[inline-cube_incr:inline+cube_incr,xline,cube_incr:-cube_incr].T,interpolation="nearest", cmap="gray")
1195 |     plt.colorbar()
1196 | 
1197 |     # Plot the prediciton for the reference xline along with 3 increments in each direction
1198 |     plt.subplot(1, 8, 2)
1199 |     plt.title('xline - 3')
1200 |     plt.imshow(predic[:,xline-xl_start - 3,:,class_row].T,interpolation="nearest", cmap="gist_rainbow", clim=(0.0, c_max))
1201 | 
1202 |     plt.subplot(1, 8, 3)
1203 |     plt.title('xline')
1204 |     plt.imshow(predic[:,xline-xl_start,:,class_row].T,interpolation="nearest", cmap="gist_rainbow", clim=(0.0, c_max))
1205 | 
1206 |     plt.subplot(1, 8, 4)
1207 |     plt.title('xline + 3')
1208 |     plt.imshow(predic[:,xline-xl_start + 3,:,class_row].T,interpolation="nearest", cmap="gist_rainbow", clim=(0.0, c_max))
1209 |     plt.colorbar()
1210 | 
1211 |     # Plot the reference inline
1212 |     plt.subplot(1, 8, 1+4)
1213 |     plt.title('inline: ' + str(inline))
1214 |     plt.imshow(inp_seis[inline,xline-cube_incr:xline+cube_incr,cube_incr:-cube_incr].T,interpolation="nearest", cmap="gray")
1215 |     plt.colorbar()
1216 | 
1217 |     # Plot the prediciton for the reference inline along with 3 increments in each direction
1218 |     plt.subplot(1, 8, 2+4)
1219 |     plt.title('inline - 3')
1220 |     plt.imshow(predic[inline-inl_start-3,:,:,class_row].T,interpolation="nearest", cmap="gist_rainbow", clim=(0.0, c_max))
1221 | 
1222 |     plt.subplot(1, 8, 3+4)
1223 |     plt.title('inline')
1224 |     plt.imshow(predic[inline-inl_start,:,:,class_row].T,interpolation="nearest", cmap="gist_rainbow", clim=(0.0, c_max))
1225 | 
1226 |     plt.subplot(1, 8, 4+4)
1227 |     plt.title('inline + 3')
1228 |     plt.imshow(predic[inline-inl_start+3,:,:,class_row].T,interpolation="nearest", cmap="gist_rainbow", clim=(0.0, c_max))
1229 |     plt.colorbar()
1230 | 
1231 |     # Make a new figure object/handle and plot 3 reference depth slices
1232 |     plt.figure(2, figsize=(20,5))
1233 |     plt.subplot(1, 3, 1)
1234 |     plt.title('slice - ' + str(slice_incr))
1235 |     plt.imshow(inp_seis[inline-cube_incr:inline+cube_incr,xline-cube_incr:xline+cube_incr,cube_incr+slice_number-slice_incr].T,\
1236 |                interpolation="nearest", cmap="gray")
1237 | 
1238 |     plt.subplot(1, 3, 2)
1239 |     plt.title('slice: ' + str(slice_number))
1240 |     plt.imshow(inp_seis[inline-cube_incr:inline+cube_incr,xline-cube_incr:xline+cube_incr,cube_incr+slice_number].T,\
1241 |                interpolation="nearest", cmap="gray")
1242 | 
1243 |     plt.subplot(1, 3, 3)
1244 |     plt.title('slice + ' + str(slice_incr))
1245 |     plt.imshow(inp_seis[inline-cube_incr:inline+cube_incr,xline-cube_incr:xline+cube_incr,cube_incr+slice_number+slice_incr].T,\
1246 |                interpolation="nearest", cmap="gray")
1247 |     plt.colorbar()
1248 | 
1249 |     # Make a new figure object/handle and plot the 3 corresponding predicted depth slices
1250 |     plt.figure(3, figsize=(20,5))
1251 |     plt.subplot(1, 3, 1)
1252 |     plt.title('slice - ' + str(slice_incr))
1253 |     plt.imshow(predic[:,:,slice_number-slice_incr,class_row].T,interpolation="nearest", cmap="gist_rainbow", clim=(0.0, c_max))
1254 | 
1255 |     plt.subplot(1, 3, 2)
1256 |     plt.title('slice: ' + str(slice_number))
1257 |     plt.imshow(predic[:,:,slice_number,class_row].T,interpolation="nearest", cmap="gist_rainbow", clim=(0.0, c_max))
1258 | 
1259 |     plt.subplot(1, 3, 3)
1260 |     plt.title('slice + ' + str(slice_incr))
1261 |     plt.imshow(predic[:,:,slice_number+slice_incr,class_row].T,interpolation="nearest", cmap="gist_rainbow", clim=(0.0, c_max))
1262 |     plt.colorbar()
1263 |     plt.show()
1264 | 
1265 | 
1266 | ### ---- MASTER/MAIN function ----
1267 | # Make an overall master function that takes inn some basic parameters,
1268 | # trains, predicts, and visualizes the results from a model
1269 | def master(segy_filename,inp_format,cube_incr,train_dict={},pred_dict={},mode = 'full'):
1270 |     # segy_filename: filename of the segy-cube to be imported (necessary for copying the segy-frame before writing a new segy)
1271 |     # inp_format: input resolution, the formatting of the seismic cube (could be changed to 8-bit data)
1272 |     # cube_incr: number of increments included in each direction from the example to make a mini-cube
1273 |     # train_dict: Training parameters packaged as a Python dictionary
1274 |     # pred_dict: Prediciton parameters packaged as a Python dictionary
1275 |     # mode: Do we want to train a model('train'), predict using an external model('predict'), or train a model and predict using it('full')
1276 | 
1277 |     # Implement more than one segy-cube if the input segy_filename is a list
1278 |     if type(segy_filename) is str or (type(segy_filename) is list and len(segy_filename) == 1):
1279 |         # Check if the filename needs to be retrieved from a list
1280 |         if type(segy_filename) is list:
1281 |             segy_filename = segy_filename[0]
1282 | 
1283 |         # Make a master segy object
1284 |         segy_obj = segy_decomp(segy_file = segy_filename,
1285 |                                plot_data = False,
1286 |                                read_direc = 'full',
1287 |                                inp_res = inp_format)
1288 | 
1289 |         # Define how many segy-cubes we're dealing with
1290 |         segy_obj.cube_num = 1
1291 |         segy_obj.data = np.expand_dims(segy_obj.data, axis = 4)
1292 | 
1293 |     elif type(segy_filename) is list:
1294 |         # start an iterator
1295 |         i = 0
1296 | 
1297 |         # iterate through the list of cube names and store them in a masterobject
1298 |         for filename in segy_filename:
1299 |             # Make a master segy object
1300 |             if i == 0:
1301 |                 segy_obj = segy_decomp(segy_file = filename,
1302 |                                        plot_data = False,
1303 |                                        read_direc = 'full',
1304 |                                        inp_res = inp_format)
1305 | 
1306 |                 # Define how many segy-cubes we're dealing with
1307 |                 segy_obj.cube_num = len(segy_filename)
1308 | 
1309 |                 # Reshape and preallocate the numpy-array for the rest of the cubes
1310 |                 print('Starting restructuring to 4D arrays')
1311 |                 ovr_data = np.empty((list(segy_obj.data.shape) + [len(segy_filename)]))
1312 |                 ovr_data[:,:,:,i] = segy_obj.data
1313 |                 segy_obj.data = ovr_data
1314 |                 ovr_data = None
1315 |                 print('Finished restructuring to 4D arrays')
1316 |             else:
1317 |                 # Add another cube to the numpy-array
1318 |                 segy_obj.data[:,:,:,i] = segy_adder(segy_file = filename,
1319 |                                                     inp_cube = segy_obj.data,
1320 |                                                     read_direc = 'full',
1321 |                                                     inp_res = inp_format)
1322 |             # Increase the itterator
1323 |             i+=1
1324 |     else:
1325 |         print('The input filename needs to be a string, or a list of strings')
1326 | 
1327 | 
1328 |     print('Finished unpaking and restructuring the numpy array')
1329 | 
1330 | 
1331 |     # Are we going to perform training?
1332 |     if mode == 'train' or mode == 'full':
1333 |         # Unpack the dictionary of training parameters
1334 |         label_list = train_dict['files']
1335 |         num_bunch = train_dict['num_tot_iterations']
1336 |         num_epochs = train_dict['epochs']
1337 |         num_examples = train_dict['num_train_ex']
1338 |         batch_size = train_dict['batch_size']
1339 |         opt_patience = train_dict['opt_patience']
1340 |         data_augmentation = train_dict['data_augmentation']
1341 |         write_out = train_dict['save_model']
1342 |         write_location = train_dict['save_location']
1343 | 
1344 |         # If there is a model given in the prediction dictionary continue training on this model
1345 |         if 'keras_model' in pred_dict:
1346 |             keras_model = pred_dict['keras_model']
1347 |         else:
1348 |             keras_model = None
1349 | 
1350 |         # Print out an initial statement to confirm the parameters(QC)
1351 |         print('num full iterations:', num_bunch)
1352 |         print('num epochs:',num_epochs)
1353 |         print('num examples per epoch:',num_examples)
1354 |         print('batch size:',batch_size)
1355 |         print('optimizer patience:',opt_patience)
1356 | 
1357 | 
1358 |         # Make the list of class data
1359 |         print('Making class-adresses')
1360 |         class_array = convert(file_list = label_list,
1361 |                               save = False,
1362 |                               savename = None,
1363 |                               ex_adjust = True)
1364 | 
1365 |         print('Finished making class-adresses')
1366 | 
1367 |         # Time the training process
1368 |         start_train_time = time.time()
1369 | 
1370 |         # Train a new model/further train the uploaded model and store the result as the model output
1371 |         model = train_model(segy_obj = segy_obj,
1372 |                             class_array = class_array,
1373 |                             num_classes = len(label_list),
1374 |                             cube_incr = cube_incr,
1375 |                             inp_res = inp_format,
1376 |                             num_bunch = num_bunch,
1377 |                             num_epochs = num_epochs,
1378 |                             num_examples = num_examples,
1379 |                             batch_size = batch_size,
1380 |                             opt_patience = opt_patience,
1381 |                             data_augmentation = data_augmentation,
1382 |                             num_channels = segy_obj.cube_num,
1383 |                             keras_model = keras_model,
1384 |                             write_out = write_out,
1385 |                             write_location = write_location)
1386 | 
1387 |         # Time the training process
1388 |         end_train_time = time.time()
1389 |         train_time = end_train_time-start_train_time # seconds
1390 | 
1391 |         # print to the user the total time spent training
1392 |         if train_time <= 300:
1393 |             print('Total time elapsed during training:',train_time, ' sec.')
1394 |         elif 300 < train_time <= 60*60:
1395 |             minutes = train_time//60
1396 |             seconds = (train_time%60)*(60/100)
1397 |             print('Total time elapsed during training:',minutes,' min., ',seconds,' sec.')
1398 |         elif 60*60 < train_time <= 60*60*24:
1399 |             hours = train_time//(60*60)
1400 |             minutes = (train_time%(60*60))*(1/60)*(60/100)
1401 |             print('Total time elapsed during training:',hours,' hrs., ',minutes,' min., ')
1402 |         else:
1403 |             days = train_time//(24*60*60)
1404 |             hours = (train_time%(24*60*60))*(1/60)*((1/60))*(24/100)
1405 |             print('Total time elapsed during training:',days,' days, ',hours,' hrs., ')
1406 | 
1407 |     elif mode == 'predict':
1408 |         # If we aren't performing any training
1409 |         print('Using uploaded model for prediction')
1410 |     else:
1411 |         print('Invalid mode! Accepted inputs are ''train'', ''predict'', or ''full''')
1412 |         return None
1413 | 
1414 |     # Are we going to perform prediction?
1415 |     if mode == 'predict' or mode == 'full':
1416 |         # Let the user know if we have made new computations on the model used for prediction
1417 |         if mode == 'full':
1418 |             print('Using the newly computed model for prediction')
1419 |         else:
1420 |             model  = pred_dict['keras_model']
1421 | 
1422 |         # Unpack the prediction dictionary
1423 |         section_edge  = pred_dict['section_edge']
1424 |         xline_ref = pred_dict['xline']
1425 |         num_classes = pred_dict['num_class']
1426 |         sect_form = pred_dict['cord_syst']
1427 |         show_feature  = pred_dict['show_feature']
1428 |         save_pred = pred_dict['save_pred']
1429 |         save_loc = pred_dict['save_location']
1430 |         pred_batch = pred_dict['pred_batch']
1431 |         prob = pred_dict['pred_prob']
1432 | 
1433 |         # Time the prediction process
1434 |         start_pred_time = time.time()
1435 | 
1436 |         # Make a prediction on the master segy object using the desired model, and plot the results
1437 |         pred = visualization(filename = segy_filename,
1438 |                              inp_seis = segy_obj.data,
1439 |                              seis_obj = segy_obj,
1440 |                              keras_model = model,
1441 |                              cube_incr = cube_incr,
1442 |                              section_edge = section_edge,
1443 |                              xline_ref = xline_ref,
1444 |                              num_classes = num_classes,
1445 |                              inp_res = inp_format,
1446 |                              sect_form = sect_form,
1447 |                              save_pred = save_pred,
1448 |                              save_file = save_loc,
1449 |                              pred_batch = pred_batch,
1450 |                              show_feature = show_feature,
1451 |                              show_prob = prob)
1452 | 
1453 |         # Print the time taken for the prediction
1454 |         end_pred_time = time.time()
1455 |         pred_time = end_pred_time-start_pred_time # seconds
1456 | 
1457 |         # print to the user the total time spent training
1458 |         if pred_time <= 300:
1459 |             print('Total time elapsed during prediction:',pred_time, ' sec.')
1460 |         elif 300 < pred_time <= 60*60:
1461 |             minutes = pred_time//60
1462 |             seconds = (pred_time%60)*(60/100)
1463 |             print('Total time elapsed during prediction:',minutes,' min., ',seconds,' sec.')
1464 |         elif 60*60 < pred_time <= 60*60*24:
1465 |             hours = pred_time//(60*60)
1466 |             minutes = (pred_time%(60*60))*(1/60)*(60/100)
1467 |             print('Total time elapsed during prediction:',hours,' hrs., ',minutes,' min., ')
1468 |         else:
1469 |             days = pred_time//(24*60*60)
1470 |             hours = (pred_time%(24*60*60))*(1/60)*((1/60))*(24/100)
1471 |             print('Total time elapsed during prediction:',days,' days, ',hours,' hrs., ')
1472 | 
1473 |     else:
1474 |         # Make an empty variable for the prediction output
1475 |         pred = None
1476 | 
1477 |     # Return the new model and/or prediction as an output dictionary
1478 |     output = {
1479 |         'model' : model,
1480 |         'pred' : pred
1481 |     }
1482 | 
1483 |     return output
1484 | 
1485 | 
1486 | 
1487 | #### ---- Run an instance of the master function ----
1488 | filenames=['PGS16902VIK_pstm_ang08_17_dec_crop','PGS16902VIK_pstm_ang17_27_dec_crop', 'PGS16902VIK_pstm_ang27_33_dec_crop']    # name of the segy-cube(s) with data
1489 | inp_res = np.float32    # formatting of the input seismic (e.g. np.int8 for 8-bit data, np.float32 for 32-bit data, etc)
1490 | cube_incr = 32    # number of increments in each direction to create a training cube
1491 | 
1492 | # Define the dictionary holding all the training parameters
1493 | train_dict = {
1494 |     'files' : ['multi_channel_new.pts','multi_coherent.pts','multi_else.pts','multi_fault.pts','multi_grid.pts','multi_grizzly.pts'],    # list of names of class-adresses
1495 |     'num_tot_iterations': 25,    # number of times we draw a new training ensemble/mini-batch
1496 |     'epochs' : 12,    # number of epochs we run on each training ensemble/mini-batch
1497 |     'num_train_ex' : 18000,    # number of training examples in each training ensemble/mini-batch
1498 |     'batch_size' : 32,    # number of training examples fed to the optimizer as a batch
1499 |     'opt_patience' : 10,    # number of epochs with the same accuracy before force breaking the training ensemble/mini-batch
1500 |     'data_augmentation' : False,    # whether or not we are using data augmentation
1501 |     'save_model' : True,    # whether or not we are saving the trained model
1502 |     'save_location' : 'F3_train'    # file name for the saved trained model
1503 | }
1504 | 
1505 | # Define the dictionary holding all the prediction parameters
1506 | pred_dict = {
1507 |     'keras_model' :  keras.models.load_model('mulitvolume_multifacies.h5'), # input model to be used for prediction, to load a model use: keras.models.load_model('write_location')
1508 |     'section_edge' : np.asarray([33282, 33282, 123898, 123900, 128, 2840]), # inline and xline section to be predicted (all depths), must contain xline
1509 |     'show_feature' : False,    # Show the distinct features before they are combined to a prediction
1510 |     'xline' : 123900,    # xline used for classification (index)(should be within section range)
1511 |     'num_class' : len(train_dict['files']),    # number of classes to output
1512 |     'cord_syst' : 'segy',    # Coordinate system used, default is 0,0. Set to 'segy' to give inputs in (inline,xline)
1513 |     'save_pred' : True,    # Save the prediction as a segy-cube
1514 |     'save_location' : 'sunday.segy',     # file name for the saved prediction
1515 |     'pred_batch' : 25,     # number of traces used to make batches of mini-cubes that are stored in memory at once
1516 |     #'pred_batch' : train_dict['num_train_ex']//(pred_dict['section_edge'][5]-pred_dict['section_edge'][4])    #Suggested value
1517 |     'pred_prob' : False     # Give the probabilities of the first class(True), or simply show where each class is classified(False)
1518 | }
1519 | 
1520 | 
1521 | # Run the master function and save the output in the output dictionary output_dict
1522 | output_dict1 = master(
1523 |     segy_filename = filenames,     # Seismic filenames
1524 |     inp_format = inp_res,     # Format of input seismic
1525 |     cube_incr = cube_incr,     # Increments in each direction to create a training cube
1526 |     train_dict = train_dict,     # Input training dictionary
1527 |     pred_dict = pred_dict,     # Input prediction dictionary
1528 |     mode = 'predict'     # Input mode ('train', 'predict', or 'full' for both training AND prediction)
1529 | )
1530 | 
1531 | 
1532 | # Show additional details about the prediciton
1533 | #show_details(
1534 | #    filename,
1535 | #    cube_incr,
1536 | #    output_dict['pred'],
1537 | #    inline = 100,
1538 | #    inl_start = 75,
1539 | #    xline = 169,
1540 | #    xl_start = 155,
1541 | #    slice_number = 400,
1542 | #    slice_incr = 3
1543 | #)
1544 | 
1545 | 
1546 | 
1547 | ### Save/load functions
1548 | ## returns a prediction cube
1549 | ## identical to the one saved
1550 | #prediction = np.load('filename.npy')
1551 | #
1552 | ## returns a compiled model
1553 | ## identical to the one saved
1554 | #loaded_model = keras.models.load_model('filename.h5')
1555 | 


--------------------------------------------------------------------------------