def __init__(self,
model_parameters=ModelParameters(),
gpus=[]):
"""
This is the constructor for the class.
@params:
model_parameters (ModelParameters) : A ModelParameter object
gpus (list): A list of GPUs not to use for computation
wavefuns (list)L A list of wave function generator to source generation
@returns:
"""
self.pars = model_parameters
self.F = SeisCL()
# Overload to generate other kind of models
self.model_generator = ModelGenerator(model_parameters=model_parameters)
self.init_F(gpus)
self.image_size = [int(np.ceil(self.pars.NT/self.pars.resampling)),
self.F.rec_pos.shape[1]]
allwavefuns= [lambda f0, t, o: gaussian(f0, t, o, order=1),
lambda f0, t, o: gaussian(f0, t, o, order=2),
lambda f0, t, o: gaussian(f0, t, o, order=3),
lambda f0, t, o: morlet(f0, t, o, order=2),
lambda f0, t, o: morlet(f0, t, o, order=3),
lambda f0, t, o: morlet(f0, t, o, order=4)]
self.wavefuns = [allwavefuns[ii] for ii in model_parameters.wavefuns]
self.files_list = {}
def __init__(self, model_parameters=ModelParameters()):
"""
This is the constructor for the class.
@params:
model_parameters (ModelParameters) : A ModelParameter object
@returns:
"""
self.pars = model_parameters
self.vp = None
print("\nUsage error.\n")
parser.print_help()
if args.niter < 0:
print_usage_error_message()
exit()
if args.nlayers <= -1:
print_usage_error_message()
exit()
if args.nbatch <= 0:
print_usage_error_message()
exit()
parameters = ModelParameters()
parameters.read_parameters_from_disk(args.fileparam)
parameters.device_type = args.device
parameters.num_layers = args.nlayers
#parameters.read_parameters_from_disk(filename='dataset_3/dhmin40_layer_num_min5/model_parameters.hdf5')
gen = SeismicGenerator(parameters)
parameters.mute_nearoffset = False
parameters.random_static = False
parameters.random_noise = False
data, vrms, vint, valid, tlabels = gen.read_example(".",
filename=args.filename)
# data = mute_direct(data, 1500, parameters)
# #data = random_static(data, 2)
## data = random_noise(data, 0.01)
def Case_small():
return ModelParameters()
def Case_article(noise=0):
pars = ModelParameters()
pars.layer_dh_min = 5
pars.layer_num_min = 48
pars.dh = 6.25
pars.peak_freq = 26
pars.df = 5
pars.wavefuns = [0, 1]
pars.NX = 692 * 2
pars.NZ = 752 * 2
pars.dt = 0.0004
pars.NT = int(8.0 / pars.dt)
pars.resampling = 10
pars.dg = 8
pars.gmin = int(470 / pars.dh)
pars.gmax = int((470 + 72 * pars.dg * pars.dh) / pars.dh)
pars.minoffset = 470
pars.vp_min = 1300.0 # maximum value of vp (in m/s)
pars.vp_max = 4000.0 # minimum value of vp (in m/s)
pars.marine = True
pars.velwater = 1500
pars.d_velwater = 60
pars.water_depth = 3500
pars.dwater_depth = 1000
pars.fs = False
pars.source_depth = (pars.Npad + 4) * pars.dh
pars.receiver_depth = (pars.Npad + 4) * pars.dh
pars.identify_direct = False
pars.mute_dir = True
if noise == 1:
pars.random_static = True
pars.random_static_max = 1
pars.random_noise = True
pars.random_noise_max = 0.02
# pars.mute_nearoffset = True
# pars.mute_nearoffset_max = 10
return pars
)
# Parse the input for training parameters
args, unparsed = parser.parse_known_args()
savepath = "./dataset_1"
logdir = args.logdir
nthread = args.nthread
niter = 5000
batch_size = args.batchsize
"""
__________________Define the parameters for Case 1______________________
"""
pars = ModelParameters()
pars.num_layers = 0
dhmins = [40, 30, 20]
layer_num_mins = [5, 12]
nexamples = 10000
"""
_______________________Generate the dataset_____________________________
"""
if not os.path.isdir(savepath):
os.mkdir(savepath)
n = 100000
if args.training != 1:
for dhmin in dhmins:
for layer_num_min in layer_num_mins:
for dir1 in os.listdir('./'):
if os.path.isdir(dir1):
for dir2 in os.listdir(dir1):
path2 = os.path.join(dir1, dir2)
if os.path.isdir(path2):
dirs.append(path2)
logdirs = fnmatch.filter(dirs, args.logdir)
print(logdirs)
create_data = True
logdir = args.logdir
niter = args.niter
max_batch = 100
pars = ModelParameters()
pars.layer_dh_min = 5
pars.layer_num_min = 48
pars.dh = 6.25
pars.peak_freq = 26
pars.df = 5
pars.wavefuns = [0, 1]
pars.NX = 692 * 2
pars.NZ = 752 * 2
pars.dt = 0.0004
pars.NT = int(8.0 / pars.dt)
pars.resampling = 10
pars.dg = 8
pars.gmin = int(470 / pars.dh)
if __name__ == "__main__":
import matplotlib.pyplot as plt
# Initialize argument parser
parser = argparse.ArgumentParser()
parser.add_argument("--ND",
type=int,
default=1,
help="Dimension of the model to display")
# Parse the input for training parameters
args, unparsed = parser.parse_known_args()
pars = ModelParameters()
pars.layer_dh_min = 20
pars.num_layers = 0
if args.ND == 1:
vp, vs, rho = generate_random_1Dlayered(pars)
vp = vp[:, 0]
vint = interval_velocity_time(vp, pars)
vrms = calculate_vrms(vp, pars.dh, pars.Npad, pars.NT, pars.dt,
pars.tdelay, pars.source_depth)
plt.plot(vint)
plt.plot(vrms)
plt.show()
else:
vp, vs, rho = generate_random_2Dlayered(pars)
plt.imshow(vp)
def get_test_error(dirlog, savepath, dataset_path):
"""
Compute the error on a test set
@params:
dirlog (str) : Directory containing the trained model.
savepath (str): Directory in which to save the predictions
dataset_path (str): Directory of the test set
@returns:
vrms_rmse (float) : RMSE for Vrms
vint_rmse: RMSE for Vint
true_pos: Primary reflection identification: Ratio of true positive
true_neg: Primary reflection identification: Ratio of true negative
false_pos: Primary reflection identification: Ratio of false positive
false_neg: Primary reflection identification: Ratio of false negative
"""
if os.path.isfile(savepath + ".hdf5"):
file = h5.File(savepath + ".hdf5")
vint_rmse = file["vint_rmse"].value
vrms_rmse = file["vrms_rmse"].value
true_pos = file["true_pos"].value
true_neg = file["true_neg"].value
false_pos = file["false_pos"].value
false_neg = file["false_neg"].value
file.close()
else:
pars = ModelParameters()
pars.read_parameters_from_disk(dataset_path + "/model_parameters.hdf5")
seismic_gen = SeismicGenerator(model_parameters=pars)
nn = RCNN(input_size=seismic_gen.image_size, batch_size=100)
tester = Tester(NN=nn, data_generator=seismic_gen)
toeval = [nn.output_ref, nn.output_vrms, nn.output_vint]
toeval_names = ["ref", "vrms", "vint"]
vint_rmse_all = 0
vrms_rmse_all = 0
true_pos_all = 0
true_neg_all = 0
false_pos_all = 0
false_neg_all = 0
tester.test_dataset(savepath=savepath,
toeval=toeval,
toeval_names=toeval_names,
restore_from=dirlog,
testpath=dataset_path)
vp, vint_pred, masks, lfiles, pfiles = tester.get_preds(
labelname="vp",
predname="vint",
maskname="valid",
savepath=savepath,
testpath=dataset_path)
vrms, vrms_pred, _, _, _ = tester.get_preds(labelname="vrms",
predname="vrms",
savepath=savepath,
testpath=dataset_path)
ref, ref_pred, _, _, _ = tester.get_preds(labelname="tlabels",
predname="ref",
savepath=savepath,
testpath=dataset_path)
vint = [None for _ in range(len(vp))]
for ii in range(len(vint)):
vint[ii] = interval_velocity_time(vp[ii], pars=pars)
vint[ii] = vint[ii][::pars.resampling]
vint_pred[ii] = vint_pred[ii] * (pars.vp_max -
pars.vp_min) + pars.vp_min
vrms_pred[ii] = vrms_pred[ii] * (pars.vp_max -
pars.vp_min) + pars.vp_min
vrms[ii] = vrms[ii] * (pars.vp_max - pars.vp_min) + pars.vp_min
ref_pred[ii] = np.argmax(ref_pred[ii], axis=1)
ind0 = np.nonzero(ref[ii])[0][0]
masks[ii][0:ind0] = 0
vint = np.array(vint)
vint_pred = np.array(vint_pred)
vrms = np.array(vrms)
vrms_pred = np.array(vrms_pred)
ref = np.array(ref)
ref_pred = np.array(ref_pred)
masks = np.array(masks)
nsamples = np.sum(masks == 1)
vint_rmse = np.sqrt(np.sum(masks * (vint - vint_pred)**2) / nsamples)
vrms_rmse = np.sqrt(np.sum(masks * (vrms - vrms_pred)**2) / nsamples)
nsamples = ref.flatten().shape[0]
true_pos = np.sum(((ref - ref_pred) == 0) * (ref == 1)) / nsamples
true_neg = np.sum(((ref - ref_pred) == 0) * (ref == 0)) / nsamples
false_pos = np.sum((ref - ref_pred) == -1) / nsamples
false_neg = np.sum((ref - ref_pred) == 1) / nsamples
file = h5.File(savepath + ".hdf5")
file["vint_rmse"] = vint_rmse
file["vrms_rmse"] = vrms_rmse
file["true_pos"] = true_pos
file["true_neg"] = true_neg
file["false_pos"] = false_pos
file["false_neg"] = false_neg
file.close()
return vrms_rmse, vint_rmse, true_pos, true_neg, false_pos, false_neg
__________________Find model directories______________________
"""
dirs = []
for dir1 in os.listdir('./'):
if os.path.isdir(dir1):
for dir2 in os.listdir(dir1):
path2 = os.path.join(dir1, dir2)
if os.path.isdir(path2):
dirs.append(path2)
logdirs = fnmatch.filter(dirs, args.logdir)
logdirs.sort()
"""
_________________________Define the parameters______________________
"""
pars = ModelParameters()
pars.flat = False
pars.NX = 1700
pars.NZ = 750 * 2
pars.dh = 6.25
pars.peak_freq = 26
pars.num_layers = 0
pars.layer_dh_min = 10 # minimum number of grid cells that a layer must span
pars.layer_num_min = 25 # minimum number of layers
pars.angle_max = 8
pars.dangle_max = 3
pars.amp_max = 0
pars.max_texture = 0.08
pars.texture_xrange = 1
pars.texture_zrange = 1.95 * pars.NZ