def backward(ctx, grad_output):
grad_output = grad_output.to('cpu')
grad_output = grad_output.detach().numpy()
# Adjoint linearized modeling
u0 = forward_modeling(ctx.model,
ctx.src.coordinates.data,
ctx.src.data,
ctx.rec.coordinates.data,
save=True)[1]
g = adjoint_born(ctx.model,
ctx.rec.coordinates.data,
grad_output.data[:],
u=u0)
# Remove padding
nb = ctx.model.nbpml
g = torch.from_numpy(g[nb:-nb, nb:-nb]).to(ctx.device)
return g.view(1, 1, g.shape[0], g.shape[1]), None, None, None, None
grid=model.grid,
ntime=nt_comp,
coordinates=rec_coordinates)
dpred.data[:] = -dorig
# Function value
fval = np.array([.5 * np.linalg.norm(dpred.data)**2], dtype='float32')
print("fval, dpred.shape, dobs.shape: ", fval, dpred.shape, dobs.shape)
# Wavefields in memory
t1 = time.time()
opF, u0 = forward_modeling(model,
geometry.src_positions,
geometry.src.data,
geometry.rec_positions,
save=True,
u_return=True,
op_return=True,
tsub_factor=12,
space_order=space_order)
g, summary1, summary2 = adjoint_born(model,
geometry.rec_positions,
dpred.data[:],
u=u0,
is_residual=True,
op_forward=opF,
tsub_factor=12,
space_order=space_order)
t2 = time.time()
print("Save in memory. Time [s]: ", t2 - t1)
d0.data,
f,
ufr,
ufi,
isic=True,
dt=dt,
factor=8)
t4 = time.time()
print('Adjoint: ', t4 - t3)
print('Total: ', (t2 - t1) + (t4 - t3))
timings[j] = (t2 - t1) + (t4 - t3)
timings.dump('timing_sigsbee_frequencies.dat')
# Checkpointing
d0, _ = forward_modeling(model0, src.coordinates.data, src.data,
rec_t.coordinates.data)
ta = time.time()
op_predicted = forward_modeling(model0,
src.coordinates.data,
src.data,
rec_t.coordinates.data,
op_return=True,
dt=dt)
f1, g1 = adjoint_born(model0,
rec_t.coordinates.data,
d0.data,
op_forward=op_predicted,
dt=dt)
tb = time.time()
print('Optimal checkpointing: ', tb - ta)
timings_oc = np.array(tb - ta)
print("Forward J")
t1 = time.time()
dD = forward_born(model0,
src.coordinates.data,
src.data,
rec_t.coordinates.data,
isic=True,
dt=dt)
t2 = time.time()
print(t2 - t1)
# Adjoint
print("Adjoint J")
d0, u0 = forward_modeling(model0,
src.coordinates.data,
src.data,
rec_t.coordinates.data,
dt=dt,
save=True)
t1 = time.time()
dm = adjoint_born(model0,
rec_t.coordinates.data,
dD_hat.data,
u0,
isic=True,
dt=dt)
t2 = time.time()
print(t2 - t1)
# Adjoint test
a = np.dot(dD_hat.flatten(), dD.flatten())
b = np.dot(dm_hat.flatten(), dm.flatten())
nt = int(1 + (tn - t0) / dt)
time = np.linspace(t0, tn, nt)
# Source
f0 = 0.010
src = RickerSource(name='src', grid=model.grid, f0=f0, time=time)
src.coordinates.data[0, :] = np.array(model.domain_size) * 0.5
src.coordinates.data[0, -1] = 20.
# Receiver for observed data
rec_t = Receiver(name='rec_t', grid=model.grid, npoint=101, ntime=nt)
rec_t.coordinates.data[:, 0] = np.linspace(0, model.domain_size[0], num=101)
rec_t.coordinates.data[:, 1] = 20.
# Observed data
dobs, utrue = forward_modeling(model, src.coordinates.data, src.data,
rec_t.coordinates.data)
##################################################################################################################
# Receiver for predicted data
rec = Receiver(name='rec', grid=model0.grid, npoint=101, ntime=nt)
rec.coordinates.data[:, 0] = np.linspace(0, model0.domain_size[0], num=101)
rec.coordinates.data[:, 1] = 20.
# Save wavefields
dpred_data, u0 = forward_modeling(model0,
src.coordinates.data,
src.data,
rec.coordinates.data,
save=True,
dt=dt)
rec_coordinates,
src_coordinates,
t0=0.0,
tn=tn,
src_type='Ricker',
f0=f0)
geometry0 = AcquisitionGeometry(model0,
rec_coordinates,
src_coordinates,
t0=0.0,
tn=tn,
src_type='Ricker',
f0=f0)
# Nonlinear modeling
dobs = forward_modeling(model, geometry, save=False, op_return=False)[0]
dpred = forward_modeling(model0, geometry0, save=False, op_return=False)[0]
dpred.data[:] = dpred.data[:] - dobs.data[:] # residual
#qad = adjoint_modeling(model, geometry)
# Linearized modeling
#dlin = forward_born(model, geometry, isic=False)
# Gradient
opF, u0 = forward_modeling(model0,
geometry0,
save=True,
u_return=True,
op_return=True,
tsub_factor=2)
ntime=nt_comp,
coordinates=rec_coordinates)
dpred.data[:] = -dorig
# Function value
fval = np.array([.5 * np.linalg.norm(dpred.data)**2], dtype='float32')
print("fval, dpred.shape, dobs.shape: ", fval, dpred.shape, dobs.shape)
# Wavefields in memory
t1 = time.time()
checkpointing = True
if checkpointing is False:
opF, u0 = forward_modeling(model,
geometry.src_positions,
geometry.src.data,
geometry.rec_positions,
save=True,
u_return=True,
op_return=True,
tsub_factor=12)
g = adjoint_born(model,
geometry.rec_positions,
dpred.data[:],
u=u0,
is_residual=True,
op_forward=opF,
tsub_factor=12)[0]
else:
opF, u0 = forward_modeling(model,
geometry.src_positions,
geometry.src.data,
geometry.rec_positions,
nt = int(1 + (tn - t0) / dt)
time = np.linspace(t0, tn, nt)
# Source
f0 = 0.010
src = RickerSource(name='src', grid=model.grid, f0=f0, time=time)
src.coordinates.data[0, :] = np.array(model.domain_size) * 0.5
src.coordinates.data[0, -1] = 20.
# Receiver for observed data
rec_t = Receiver(name='rec_t', grid=model.grid, npoint=101, ntime=nt)
rec_t.coordinates.data[:, 0] = np.linspace(0, model.domain_size[0], num=101)
rec_t.coordinates.data[:, 1] = 20.
# Observed data
dobs, utrue = forward_modeling(model, src.coordinates.data, src.data,
rec_t.coordinates.data)
##################################################################################################################
# Receiver for predicted data
rec = Receiver(name='rec', grid=model0.grid, npoint=101, ntime=nt)
rec.coordinates.data[:, 0] = np.linspace(0, model0.domain_size[0], num=101)
rec.coordinates.data[:, 1] = 20.
# Save wavefields
d0, u0 = forward_modeling(model,
src.coordinates.data,
src.data,
rec.coordinates.data,
save=True,
dt=dt)
src1.coordinates.data[0, -1] = 20.
f2 = 0.012
src2 = RickerSource(name='src', grid=model2.grid, f0=f2, time=time_axis)
src2.coordinates.data[0, :] = np.array(model2.domain_size) * 0.5
src2.coordinates.data[0, -1] = 20.
# Receiver for observed data
rec_t = Receiver(name='rec_t', grid=model1.grid, npoint=401, ntime=nt)
rec_t.coordinates.data[:, 0] = np.linspace(100, 900, num=401)
rec_t.coordinates.data[:, 1] = 20.
# Test data and source
d_hat, _ = forward_modeling(model1,
src1.coordinates.data,
src1.data,
rec_t.coordinates.data,
dt=dt)
q_hat = src2.data
# Forward
d0, _ = forward_modeling(model2,
src2.coordinates.data,
src2.data,
rec_t.coordinates.data,
dt=dt)
# Adjoint
q0 = adjoint_modeling(model2,
src2.coordinates.data,
rec_t.coordinates.data,
