If using the project, please cite as follows:

Mikhailiuk A. and Faul A. 2018. "Deep Learning Applied To Seismic Signal Interpolation". 
EAGE2018.


============================================================================================
============================================================================================
Author: Aliaksei Mikhailiuk
Date: 20.07.2017
Contains: Deep Learning and Parallelisation applied to seismic data.
============================================================================================
============================================================================================
The enclosed program contains an implementaitoin of a neural network in C++ and OpenMP.
============================================================================================

The head folder contains:

config: folder with a configuration file
input: folder with input files (data)
obj: folder for object files (generated by compiler)
output: folder for an output of the algorithm (contains exmaple output - running the 
        algorithm with the configuration specified in config.cfg. There are two folders, 
        one ending with fu and another with es. Fu - fully trained (not in the minimum of 
        the validation error (2000 epochs)), es - early stop (when the network reaches
        the minima))
scripts: supplementary scripts for postprocessing of the results
src: folder with the source code of the algorithm
documentation: folder with documentation produced with doxygen containing code description. 
               to view the documentation go to the ./documentation/html/ and open index.html

Makefile: makefile
readme.txt: read me file

============================================================================================
Note: every folder contains associated readme.txt file explaining the contents, or has a 
      well documented code.
============================================================================================

============================================================================================
============================================================================================
Compilation:
============================================================================================

make 

============================================================================================
============================================================================================
Run (generates a folder with a unique id in the output folder):
============================================================================================

make run

============================================================================================
Note: to change the number of threads, go to Makefile and change OMP_NUM_THREADS (tested 
      range is 1 to 4)
============================================================================================

============================================================================================
============================================================================================
Visualise results in the output folder (requires matlab):
============================================================================================

make plot 

============================================================================================
============================================================================================
Required libraries
============================================================================================

libconfig.h++
omp.h

============================================================================================
============================================================================================
Implementation details:
============================================================================================

The implemented algorithms include: simple autoencoder with one hidden layer, two regularised 
autoencoders i.e. denoizing and contractive, and a deep autoencoder with a variable number and 
size of the hidden layers. The final implementation allows the user to specify the model 
parameters in a configuration file. A detailed output is produced in the output folder. The 
key results written in the .dat files can be visualised using a MatLab script. Furthermore 
model parameters are saved along with the output results. Thus a new model can be initialised 
from the saved parameters and training can be continued. Saved features can also be reused 
for other tasks - e.g. classification. In order to automate the process of results collection 
a number of bash scripts was written. T is documented using doxygen and a detailed description 
of files and functions is placed in index.html in the html folder. Detailed documentation on 
usage and scripts is given in the readme file in the head folder.

OpenMP:

The same serial code optimisations were applied to all parallel approach. These included: 
compiler flags, loop unrolling, loop blocking, single precision calculations, elimination of 
redundant variables, hoisting out computations from  for loops and inline functions.
 Mainly optimisations were aimed for reducing expensive memory access operation and 
minimising the number of cache misses. 

Different workload distributions were tried and the best preformance is achieved when 
guided is used on all loops.

One of the technical points taken into account is that when C++ classes are used the memory 
must be set to shared by default. This brings complications to loop counters updates. One 
more point is that when the functions are called from the parallel region all variable 
declared in these functions end up private. Thus points of explicit synchronisation are 
required in order to ensure memory consistency.