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,