def load_data_from_file(self, directory):
self.x = np.loadtxt(directory + "regression_x.csv", delimiter=',')
self.y = np.loadtxt(directory + "regression_y.csv", delimiter=',')
self.u = np.loadtxt(directory + "regression_u.csv", delimiter=',')
self.v = np.loadtxt(directory + "regression_v.csv", delimiter=',')
self.ur = np.loadtxt(directory + "regression_ur.csv", delimiter=',')
self.vr = np.loadtxt(directory + "regression_vr.csv", delimiter=',')
self.Xo = np.loadtxt(directory + "regression_xo.csv", delimiter=',')
self.obs = np.loadtxt(directory + "regression_obs.csv", delimiter=',')
self.ku = np.loadtxt(directory + "regression_ku.csv", delimiter=',')
self.kv = np.loadtxt(directory + "regression_kv.csv", delimiter=',')
if os.path.exists(directory + 'trajectory_data.csv'):
print("Loading Trajectory")
self.trajectory = Trajectory(0, 0, 0)
self.trajectory.load_positions_from_file()
k = GPy.kern.RBF(input_dim=2, variance=1)
self.model_u = GPy.models.GPRegression(self.Xo, self.obs[:, 1][:,
None],
k.copy())
self.model_v = GPy.models.GPRegression(self.Xo, self.obs[:, 0][:,
None],
k.copy())
self.model_u.update_model(False)
self.model_u.initialize_parameter()
self.model_u[:] = np.loadtxt(directory + 'regression_model_u.npy')
self.model_u.update_model(True)
self.model_v.update_model(False)
self.model_v.initialize_parameter()
self.model_v[:] = np.loadtxt(directory + 'regression_model_v.npy')
self.model_v.update_model(True)
def f(S, D):
zs = np.zeros(shape=(D.size, S.size))
print(zs)
for i in range(len(S)):
for j in range(len(D)):
s = S[i][j]
d = D[i][j]
regression = reg.Regression(dim=3)
trajectory = Trajectory(nsamples=s,
integration_time=30,
n_timesteps=10,
density=d)
regression.initialize_samples(1, trajectory=trajectory)
regression.run_model()
print("{}, {}".format(s, d))
e = regression.compute_error(errors=['ge_av_raw'])
print(e)
zs[i][j] = e[0]
return zs
def main(directory, drifters):
ur_file, vr_file, ku_file, kv_file = None, None, None, None
try:
ur_file = directory + str(drifters) + "_samples_ur.npy"
vr_file = directory + str(drifters) + "_samples_vr.npy"
except Exception as e:
print("File not found")
ur = np.load(ur_file) if ur_file is not None else None
vr = np.load(vr_file) if vr_file is not None else None
reg = TimeseriesRegression()
trajectory = Trajectory(nsamples=drifters,
integration_time=360,
n_timesteps=48,
pattern=Pattern.grid)
reg.initialize_samples(trajectory=trajectory)
reg.ur = ur
reg.vr = vr
reg.plot_quiver(show=False, save=True)
reg.plot_raw_error(show=False, save=True)
reg.plot_curl(show=False, save=True)
reg.plot_div(show=False, save=True)
def run_models(samples):
trajectory = Trajectory(nsamples=samples,
integration_time=30,
n_timesteps=15,
pattern=Pattern.grid)
regression = reg.Regression(dim=3)
regression.initialize_samples(ndrifters=samples, trajectory=trajectory)
regression.run_model()
rbf_e = regression.compute_error(errors=["ge_av_raw"])
return rbf_e
def run_models(samples):
trajectory = Trajectory(nsamples=samples,
integration_time=30,
n_timesteps=15,
pattern=Pattern.grid)
div_k = dfk.DivFreeK(3)
curl_k = cfk.CurlFreeK(3)
k = div_k + curl_k
regression = reg.Regression(dim=3)
regression.initialize_samples(ndrifters=samples, trajectory=trajectory)
regression.run_model(kernel=k)
cdk_e = regression.compute_error(errors=["ge_av_raw"])
return cdk_e
def main():
drifters = np.arange(30, 180, 30)
ux_lengthscales = []
uy_lengthscales = []
ut_lengthscales = []
ugaussian_noise = []
vx_lengthscales = []
vy_lengthscales = []
vt_lengthscales = []
vgaussian_noise = []
for d in drifters:
print(d)
regression = TimeseriesRegression()
trajectory = Trajectory(nsamples=d,
integration_time=360,
n_timesteps=48,
pattern=Pattern.grid)
regression.initialize_samples(d, trajectory=trajectory)
regression.run_model()
model_u = regression.model_u
model_v = regression.model_v
u_lengthscales = model_u.kern.lengthscale
v_lengthscales = model_v.kern.lengthscale
ux_lengthscales.append(u_lengthscales[2])
uy_lengthscales.append(u_lengthscales[1])
ut_lengthscales.append(u_lengthscales[0])
ugaussian_noise.append(model_u.Gaussian_noise.variance[0])
vx_lengthscales.append(v_lengthscales[2])
vy_lengthscales.append(v_lengthscales[1])
vt_lengthscales.append(v_lengthscales[0])
vgaussian_noise.append(model_v.Gaussian_noise.variance[0])
np.savetxt('u_x_lscale.csv', ux_lengthscales, delimiter=",")
np.savetxt('u_y_lscale.csv', uy_lengthscales, delimiter=",")
np.savetxt('u_t_lscale.csv', ut_lengthscales, delimiter=",")
np.savetxt('u_gaussian_noise.csv', ugaussian_noise, delimiter=",")
np.savetxt('v_x_lscale.csv', vx_lengthscales, delimiter=",")
np.savetxt('v_y_lscale.csv', vy_lengthscales, delimiter=",")
np.savetxt('v_t_lscale.csv', vt_lengthscales, delimiter=",")
np.savetxt('v_gaussian_noise.csv', vgaussian_noise, delimiter=",")
if d in [30, 90, 150]:
trajectory.save_parameters_to_file(str(d) + "_trajectory_info.csv")
file_name_base = str(d) + "_samples_"
np.savetxt(file_name_base + "ur.csv", regression.ur, delimiter=",")
np.savetxt(file_name_base + "vr.csv", regression.vr, delimiter=",")
np.savetxt(file_name_base + "ku.csv", regression.ku, delimiter=",")
np.savetxt(file_name_base + "kv.csv", regression.kv, delimiter=",")
s = np.arange(1, 181, 20)
d = np.arange(0.01, 2.26, 0.25)
S, D = np.meshgrid(s, d)
zs = np.zeros(shape=(len(S), len(D)))
for i in range(len(S)):
for j in range(len(D)):
si = S[i][j]
di = D[i][j]
regression = reg.Regression(dim=3)
trajectory = Trajectory(nsamples=si,
integration_time=30,
n_timesteps=10,
density=di)
regression.initialize_samples(1, trajectory=trajectory)
regression.run_model()
print("{}, {}".format(si, di))
e = regression.compute_error(errors=['ge_av_raw'])
print(e)
zs[i][j] = e[0]
np.savetxt("sample_density.csv", zs, delimiter=",")
class Regression:
def __init__(self, dim=2):
self.dim = dim
self.n_drifters = 0
self.x = np.empty(shape=(1, 1))
self.y = np.empty(shape=(1, 1))
self.u = np.empty(shape=(1, 1))
self.v = np.empty(shape=(1, 1))
self.X = np.empty(shape=(1, 1))
self.Y = np.empty(shape=(1, 1))
self.obs = np.empty(shape=(1, 1), dtype=np.float64)
self.Xo = np.empty(shape=(1, 1), dtype=np.float64)
self.grid_points = np.empty(shape=(1, 1))
self.ur = np.empty(shape=(1, 1))
self.vr = np.empty(shape=(1, 1))
self.ku = np.empty(shape=(1, 1))
self.kv = np.empty(shape=(1, 1))
self.model_u = None
self.model_v = None
self.trajectory = None
self.ds = 2 # What is this property?
self.figW = 11.
self.figH = 6.
self.marker_size = 4
self.text_size = 18
self.scale = 5
self.title_pad = 15
self.tick_label_size = 16
self.cbar_label_size = 12
def generate_vector_field(self):
field = svf.SpiralVectorField.generate_spiral()
self.x = field[0]
self.y = field[1]
self.u = field[3]
self.v = field[4]
print(self.u)
def create_and_shape_grid(self):
self.X, self.Y = np.meshgrid(self.x, self.y)
# X and Y are reshaped so as to be able to be read off as (y, x) coordinate pairs
self.X = self.X.reshape([self.X.size, 1])
self.Y = self.Y.reshape([self.Y.size, 1])
self.grid_points = np.concatenate([self.Y, self.X], axis=1)
def initialize_samples(self,
ndrifters=None,
obs=None,
Xo=None,
trajectory=None,
random=True):
if ndrifters is None and trajectory is None:
sys.exit(0)
if obs is not None and Xo is not None:
self.obs = obs
self.Xo = Xo
return
if trajectory is not None:
self.n_drifters = trajectory.n_particles
self.trajectory = trajectory
self.trajectory.lagtransport()
inter = self.trajectory.get_intermediates()
times = self.trajectory.get_times()
inter_times = np.concatenate([inter, times], axis=1)
print(inter_times)
vels = np.apply_along_axis(svf.SpiralVectorField.get_velocity, 1,
inter_times)
gaussian_variance = np.random.normal(0,
0.01 * np.nanmax(vels),
size=vels.shape)
vels = vels + gaussian_variance
self.obs = np.concatenate(
[vels[:, 1][:, None], vels[:, 0][:, None]], axis=1)
self.Xo = np.concatenate(
[inter[:, 1][:, None], inter[:, 0][:, None]], axis=1)
return
self.n_drifters = ndrifters
if random:
init = Initializations(np.zeros(shape=(ndrifters, self.dim)),
ndrifters)
grid_pos = init.initialize_particles_random()
else:
init = Initializations(np.zeros(shape=(ndrifters, self.dim)),
ndrifters)
grid_pos = init.initialize_particles_grid()
vels = np.apply_along_axis(vel.get_velocity, 1, grid_pos[:, 0:2])
gaussian_variance = np.random.normal(0, 0.01, size=vels.shape)
vels = vels + gaussian_variance
self.obs = np.concatenate([vels[:, 1][:, None], vels[:, 0][:, None]],
axis=1)
self.Xo = np.concatenate(
[grid_pos[:, 1][:, None], grid_pos[:, 0][:, None]], axis=1)
def run_model(self, kernel=None):
self.generate_vector_field()
self.create_and_shape_grid()
if kernel is None:
k = GPy.kern.RBF(input_dim=self.dim, ARD=True)
self.model_u = GPy.models.GPRegression(self.Xo,
self.obs[:, 1][:, None],
k.copy())
self.model_v = GPy.models.GPRegression(self.Xo,
self.obs[:, 0][:, None],
k.copy())
self.model_u.optimize_restarts(num_restarts=3)
self.model_v.optimize_restarts(num_restarts=3)
Ur, Ku = self.model_u.predict(
self.grid_points) # Kr = posterior covariance
Vr, Kv = self.model_v.predict(self.grid_points)
# Reshape the output velocity component matrices to be the same size and shape as
# the inital matrices of x, y points
self.ur = np.reshape(Ur, [self.y.size, self.x.size])
self.vr = np.reshape(Vr, [self.y.size, self.x.size])
self.ku = np.reshape(Ku, [self.y.size, self.x.size])
self.kv = np.reshape(Kv, [self.y.size, self.x.size])
else:
self.format_obs()
k = kernel
self.model_u = GPy.models.GPRegression(self.Xo,
self.obs[:, 0][:, None],
k.copy())
self.model_u.optimize_restarts(num_restarts=3, verbose=False)
Ur, Ku = self.model_u.predict(
self.grid_points) # Kr = posterior covariance
# Reshape the output velocity component matrices to be the same size and shape as
# the inital matrices of x, y points
self.ur = np.reshape(Ur[:Ur.size // 2], [self.y.size, self.x.size])
self.vr = np.reshape(Ur[Ur.size // 2:], [self.y.size, self.x.size])
self.ku = np.reshape(Ku[:Ur.size // 2], [self.y.size, self.x.size])
self.kv = np.reshape(Ku[Ur.size // 2:], [self.y.size, self.x.size])
def get_params(self):
return self.x, self.y, self.u, self.v, self.ur, self.vr, self.Xo, self.ku, self.kv
def compute_error(self, errors=None):
ue_raw = np.absolute(np.subtract(self.u, self.ur))
ve_raw = np.absolute(np.subtract(self.v, self.vr))
ea = np.sqrt(
np.divide(np.add(np.power(ue_raw, 2), np.power(ve_raw, 2)), 2))
ue_scaled = np.absolute(np.divide(ue_raw, self.u))
ve_scaled = np.absolute(np.divide(ve_raw, self.v))
er = np.sqrt(
np.divide(np.add(np.power(ue_scaled, 2), np.power(ve_scaled, 2)),
2))
ue_av_raw = np.sum(ue_raw) / ue_raw.size
ve_av_raw = np.sum(ve_raw) / ve_raw.size
ue_av_scaled = np.sum(ue_scaled) / ue_scaled.size
ve_av_scaled = np.sum(ve_scaled) / ve_scaled.size
ge_av_raw = np.add(ue_av_raw, ve_av_raw) / 2
ge_av_scaled = np.add(ue_av_scaled, ve_av_scaled) / 2
error_dict = {
"ue_raw": ue_raw,
"ve_raw": ve_raw,
"ea": ea,
"ue_scaled": ue_scaled,
"ve_scaled": ve_scaled,
"er": er,
"ue_av_scaled": ue_av_scaled,
"ve_av_scaled": ve_av_scaled,
"ge_av_raw": ge_av_raw,
"ge_av_scaled": ge_av_scaled
}
if errors is not None:
to_return = []
for key in errors:
to_return.append(error_dict[key])
return to_return
return error_dict.values()
def plot_quiver(self, show=True, save=False):
fig1 = pl.figure(figsize=(self.figW, self.figH))
# Plot the Original Velocity Field
plot = fig1.add_subplot(1, 2, 1, aspect='equal')
plot.quiver(self.x[::self.ds],
self.y[::self.ds],
self.u[::self.ds, ::self.ds],
self.v[::self.ds, ::self.ds],
scale=self.scale)
plot.streamplot(self.x, self.y, self.u, self.v)
plot.plot(self.Xo[:, self.dim - 1],
self.Xo[:, self.dim - 2],
'og',
markersize=self.marker_size)
plot.set_xlim(-5, 5)
plot.set_xlabel("km")
plot.set_ylim(-5, 5)
plot.set_ylabel("km")
plot.set_title('Original Velocity Field (' + str(self.n_drifters) +
' drifters)',
size=self.text_size,
pad=self.title_pad)
plot.tick_params(labelsize=self.tick_label_size)
# Plot the Velocity Field Generated by the Gaussian Process Regression
plot = fig1.add_subplot(1, 2, 2, aspect='equal')
plot.quiver(self.x[::self.ds],
self.y[::self.ds],
self.ur[::self.ds, ::self.ds],
self.vr[::self.ds, ::self.ds],
scale=self.scale)
plot.streamplot(self.x, self.y, self.ur, self.vr)
plot.plot(self.Xo[:, self.dim - 1],
self.Xo[:, self.dim - 2],
'og',
markersize=self.marker_size)
plot.set_xlim(-5, 5)
plot.set_xlabel("km")
plot.set_ylim(-5, 5)
plot.set_ylabel("km")
plot.set_title('GPR Velocity Field (' + str(self.n_drifters) +
' drifters)',
size=self.text_size,
pad=self.title_pad)
plot.tick_params(labelsize=self.tick_label_size)
pl.subplots_adjust(left=0.05,
bottom=0.05,
right=0.95,
top=0.95,
wspace=0.2,
hspace=0.2)
if show:
pl.show()
if save:
fig1.savefig("vel-field.png", dpi=300)
def plot_curl(self, show=True, save=False):
init_curl = svf.SpiralVectorField.get_curl(self.u, self.v)
reg_curl = svf.SpiralVectorField.get_curl(self.ur, self.vr)
c_diff = init_curl - reg_curl
fig8 = pl.figure(figsize=(self.figW, self.figH))
plot = fig8.add_subplot(1, 3, 1, aspect='equal')
im1 = plot.imshow(init_curl,
vmin=0,
vmax=2,
origin='center',
extent=plot_extent,
cmap='jet')
plot.set_title("Initial Curl", size=self.text_size, pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
cbar = fig8.colorbar(im1, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
plot = fig8.add_subplot(1, 3, 2, aspect='equal')
im2 = plot.imshow(reg_curl,
vmin=0,
vmax=2,
origin='center',
extent=plot_extent,
cmap='jet')
plot.set_title("GPR Model Curl",
size=self.text_size,
pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
cbar = fig8.colorbar(im2, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
plot = fig8.add_subplot(1, 3, 3, aspect='equal')
im3 = plot.imshow(c_diff,
vmin=0,
vmax=2,
origin='center',
extent=plot_extent,
cmap='jet')
plot.set_title("Curl Error", size=self.text_size, pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
cbar = fig8.colorbar(im3, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
pl.subplots_adjust(left=0.06,
bottom=0.47,
right=0.94,
top=0.88,
wspace=0.48,
hspace=0.0)
if show:
pl.show()
if save:
fig8.savefig("curl.png", dpi=300)
def plot_div(self, show=True, save=False):
init_div = svf.SpiralVectorField.get_divergence(self.u, self.v)
reg_div = svf.SpiralVectorField.get_divergence(self.ur, self.vr)
diff = init_div - reg_div
plot_extent = [self.x.min(), self.x.max(), self.y.min(), self.y.max()]
fig8 = pl.figure(figsize=(self.figW, self.figH))
plot = fig8.add_subplot(1, 3, 1, aspect='equal')
im1 = plot.imshow(init_div,
vmin=-0.5,
vmax=0.5,
origin='center',
extent=plot_extent,
cmap='jet')
plot.set_title("Initial Divergence",
size=self.text_size,
pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
cbar = fig8.colorbar(im1, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
plot = fig8.add_subplot(1, 3, 2, aspect='equal')
im2 = plot.imshow(reg_div,
vmin=-0.5,
vmax=0.5,
origin='center',
extent=plot_extent,
cmap='jet')
plot.set_title("GPR Model Divergence",
size=self.text_size,
pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
cbar = fig8.colorbar(im2, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
plot = fig8.add_subplot(1, 3, 3, aspect='equal')
im3 = plot.imshow(diff,
vmin=-0.5,
vmax=0.5,
origin='center',
extent=plot_extent,
cmap='jet')
plot.set_title("Divergence Error",
size=self.text_size,
pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
cbar = fig8.colorbar(im3, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
pl.subplots_adjust(left=0.06,
bottom=0.47,
right=0.94,
top=0.88,
wspace=0.48,
hspace=0.0)
if show:
pl.show()
if save:
fig8.savefig("divergence.png", dpi=300)
def plot_raw_error(self, show=True, save=False):
ue_raw, ve_raw, ea = self.compute_error(
errors=["ue_raw", "ve_raw", "ea"])
plot_extent = [self.x.min(), self.x.max(), self.y.min(), self.y.max()]
fig2 = pl.figure(figsize=(self.figW, self.figH))
plot = fig2.add_subplot(1, 3, 1, aspect='equal')
im1 = plot.imshow(ue_raw,
vmin=0,
vmax=0.5,
origin='center',
extent=plot_extent,
cmap='jet')
plot.plot(self.Xo[:, self.dim - 1],
self.Xo[:, self.dim - 2],
'or',
markersize=self.marker_size)
plot.set_title("GPR Abs. Error U",
size=self.text_size,
pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
cbar = fig2.colorbar(im1, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
plot = fig2.add_subplot(1, 3, 2, aspect='equal')
im2 = plot.imshow(ve_raw,
vmin=0,
vmax=0.5,
origin='center',
extent=plot_extent,
cmap='jet')
plot.plot(self.Xo[:, self.dim - 1],
self.Xo[:, self.dim - 2],
'or',
markersize=self.marker_size)
plot.set_title("GPR Abs. Error V",
size=self.text_size,
pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
cbar = fig2.colorbar(im2, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
plot = fig2.add_subplot(1, 3, 3, aspect='equal')
im3 = plot.imshow(ea,
vmin=0,
vmax=0.5,
origin='center',
extent=plot_extent,
cmap='jet')
plot.plot(self.Xo[:, self.dim - 1],
self.Xo[:, self.dim - 2],
'or',
markersize=self.marker_size)
plot.set_title("GPR Abs. Error",
size=self.text_size,
pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
cbar = fig2.colorbar(im3, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
pl.subplots_adjust(left=0.06,
bottom=0.47,
right=0.94,
top=0.88,
wspace=0.48,
hspace=0.0)
if show:
pl.show()
if save:
fig2.savefig("abs_error.png", dpi=300)
def plot_relative_error(self, show=True, save=False):
ue_scaled, ve_scaled, er = self.compute_error(
errors=["ue_scaled", "ve_scaled", "er"])
plot_extent = [self.x.min(), self.x.max(), self.y.min(), self.y.max()]
fig3 = pl.figure(figsize=(self.figW, self.figH))
plot = fig3.add_subplot(1, 3, 1, aspect='equal')
im3 = plot.imshow(ue_scaled,
vmin=0,
vmax=10,
origin='center',
extent=plot_extent,
cmap='jet')
plot.plot(self.Xo[:, self.dim - 1],
self.Xo[:, self.dim - 2],
'or',
markersize=self.marker_size)
plot.set_title("GPR Rel. Error U",
size=self.text_size,
pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
cbar = fig3.colorbar(im3, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
plot = fig3.add_subplot(1, 3, 2, aspect='equal')
im3 = plot.imshow(ve_scaled,
vmin=0,
vmax=10,
origin='center',
extent=plot_extent,
cmap='jet')
plot.plot(self.Xo[:, self.dim - 1],
self.Xo[:, self.dim - 2],
'or',
markersize=self.marker_size)
plot.set_title("GPR Rel. Error U",
size=self.text_size,
pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
cbar = fig3.colorbar(im3, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
plot = fig3.add_subplot(1, 3, 3, aspect='equal')
im3 = plot.imshow(er,
vmin=0,
vmax=10,
origin='center',
extent=plot_extent,
cmap='jet')
plot.plot(self.Xo[:, self.dim - 1],
self.Xo[:, self.dim - 2],
'or',
markersize=self.marker_size)
plot.set_title("GPR Rel. Error U",
size=self.text_size,
pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
cbar = fig3.colorbar(im3, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
pl.subplots_adjust(left=0.06,
bottom=0.47,
right=0.94,
top=0.88,
wspace=0.48,
hspace=0.0)
if show:
pl.show()
if save:
fig3.savefig("rel_error.png", dpi=300)
def plot_kukv(self, show=True, save=False):
plot_extent = [self.x.min(), self.x.max(), self.y.min(), self.y.max()]
raw_ku = self.ku
raw_kv = self.kv
ku = np.sqrt(self.ku)
kv = np.sqrt(self.kv)
fig3 = pl.figure(figsize=(self.figW, self.figH))
plot = fig3.add_subplot(1, 3, 1, aspect='equal')
im5 = plot.imshow(ku,
vmin=0,
vmax=0.5,
origin='center',
extent=plot_extent,
cmap='jet')
plot.plot(self.Xo[:, self.dim - 1],
self.Xo[:, self.dim - 2],
'or',
markersize=self.marker_size)
plot.set_title("GPR Ku (Standard Deviation)", size=self.text_size)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
fig3.colorbar(im5, fraction=0.046, pad=0.04)
plot = fig3.add_subplot(1, 3, 2, aspect='equal')
im6 = plot.imshow(kv,
vmin=0,
vmax=0.5,
origin='center',
extent=plot_extent,
cmap='jet')
plot.plot(self.Xo[:, self.dim - 1],
self.Xo[:, self.dim - 2],
'or',
markersize=self.marker_size)
plot.set_title("GPR Ku (Standard Deviation)", size=self.text_size)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
fig3.colorbar(im6, fraction=0.046, pad=0.04)
plot = fig3.add_subplot(1, 3, 3, aspect='equal')
im7 = plot.imshow(np.sqrt(
np.divide(np.add(np.power(raw_ku, 2), np.power(raw_kv, 2)), 2)),
vmin=0,
vmax=0.5,
origin='center',
extent=plot_extent,
cmap='jet')
plot.plot(self.Xo[:, self.dim - 1],
self.Xo[:, self.dim - 2],
'or',
markersize=self.marker_size)
plot.set_title("GPR Ku (Standard Deviation)", size=self.text_size)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
fig3.colorbar(im7, fraction=0.046, pad=0.04)
pl.subplots_adjust(left=0.05,
bottom=0.47,
right=0.95,
top=0.88,
wspace=0.35,
hspace=0.0)
if show:
pl.show()
if save:
fig3.savefig("kukv.png", dpi=300)
def plot_errors(self, save=False):
self.plot_quiver(show=False, save=save)
self.plot_curl(show=False, save=save)
self.plot_div(show=False, save=save)
self.plot_raw_error(show=False, save=save)
self.plot_relative_error(show=False, save=save)
self.plot_kukv(show=False, save=save)
pl.show()
def save_data_to_file(self, directory):
np.savetxt(directory + "regression_x.csv",
self.x,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_y.csv",
self.y,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_u.csv",
self.u,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_v.csv",
self.v,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_ur.csv",
self.ur,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_vr.csv",
self.vr,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_xo.csv",
self.Xo,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_obs.csv",
self.obs,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_ku.csv",
self.ku,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_kv.csv",
self.kv,
fmt="%.6e",
delimiter=',')
if self.trajectory is not None:
print("Saving Trajectory")
self.trajectory.save_positions_to_file()
np.savetxt(directory + "regression_model_u.npy",
self.model_u.param_array,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_model_v.npy",
self.model_v.param_array,
fmt="%.6e",
delimiter=',')
def load_data_from_file(self, directory):
self.x = np.loadtxt(directory + "regression_x.csv", delimiter=',')
self.y = np.loadtxt(directory + "regression_y.csv", delimiter=',')
self.u = np.loadtxt(directory + "regression_u.csv", delimiter=',')
self.v = np.loadtxt(directory + "regression_v.csv", delimiter=',')
self.ur = np.loadtxt(directory + "regression_ur.csv", delimiter=',')
self.vr = np.loadtxt(directory + "regression_vr.csv", delimiter=',')
self.Xo = np.loadtxt(directory + "regression_xo.csv", delimiter=',')
self.obs = np.loadtxt(directory + "regression_obs.csv", delimiter=',')
self.ku = np.loadtxt(directory + "regression_ku.csv", delimiter=',')
self.kv = np.loadtxt(directory + "regression_kv.csv", delimiter=',')
if os.path.exists(directory + 'trajectory_data.csv'):
print("Loading Trajectory")
self.trajectory = Trajectory(0, 0, 0)
self.trajectory.load_positions_from_file()
k = GPy.kern.RBF(input_dim=2, variance=1)
self.model_u = GPy.models.GPRegression(self.Xo, self.obs[:, 1][:,
None],
k.copy())
self.model_v = GPy.models.GPRegression(self.Xo, self.obs[:, 0][:,
None],
k.copy())
self.model_u.update_model(False)
self.model_u.initialize_parameter()
self.model_u[:] = np.loadtxt(directory + 'regression_model_u.npy')
self.model_u.update_model(True)
self.model_v.update_model(False)
self.model_v.initialize_parameter()
self.model_v[:] = np.loadtxt(directory + 'regression_model_v.npy')
self.model_v.update_model(True)
def format_obs(self):
us = self.obs[:, 2][:, None]
vs = self.obs[:, 1][:, None]
self.obs = np.concatenate([us, vs], axis=0)
self.obs = np.concatenate([us, vs], axis=0)
if __name__ == "__main__":
div_k = dfk.DivFreeK(3)
curl_k = cfk.CurlFreeK(3)
kernel = div_k + curl_k
# REGULAR REGRESSION TESTS
regression = Regression()
pattern = Pattern.grid
trajectory = Trajectory(nsamples=50,
integration_time=30,
n_timesteps=15,
pattern=pattern)
regression.initialize_samples(ndrifters=10, trajectory=trajectory)
#regression.initialize_samples(nsamples=50, random=False)
regression.run_model()
# TIMESERIES REGRESSION TESTS
# regression = TimeseriesRegression()
#
# print(time.time())
# trajectory = Trajectory(nsamples=60, integration_time=30, n_timesteps=15, pattern=pattern)
# print(time.time())
# regression.initialize_samples(nsamples=150, trajectory=trajectory)
# #regression.initialize_samples(nsamples=150)
# print(time.time())
class TimeseriesRegression(Regression):
def __init__(self):
super(TimeseriesRegression, self).__init__()
self.dim = 3
self.t = np.empty(shape=(1, 1), dtype=np.float64)
self.T = np.empty(shape=(1, 1), dtype=np.float64)
def create_and_shape_grid_3D(self, trajectory):
self.generate_vector_field()
self.t = np.linspace(0, trajectory.integration_time,
trajectory.n_timesteps)
self.X, self.T, self.Y = np.meshgrid(self.x, self.t, self.y)
# X and Y are reshaped so as to be able to be read off as (y, x) coordinate pairs
self.X = self.X.reshape([self.X.size, 1])
self.Y = self.Y.reshape([self.Y.size, 1])
self.T = self.T.reshape([self.T.size, 1])
self.grid_points = np.concatenate([self.T, self.X, self.Y], axis=1)
def initialize_samples(self,
ndrifters=None,
obs=None,
Xo=None,
trajectory=None,
random=True):
super(TimeseriesRegression,
self).initialize_samples(ndrifters=ndrifters,
obs=obs,
Xo=Xo,
trajectory=trajectory,
random=random)
if trajectory:
times = self.trajectory.get_times()
else:
times = np.ones(shape=self.obs.shape)
self.obs = np.concatenate([times[:, 0][:, None], self.obs], axis=1)
self.Xo = np.concatenate([times[:, 0][:, None], self.Xo], axis=1)
self.create_and_shape_grid_3D(trajectory=trajectory)
def run_model(self, kernel=None, step=None):
if step is not None:
min = (step - 1) * self.n_drifters
max = min + self.n_drifters
self.Xo = self.Xo[min:max, :]
self.obs = self.obs[min:max, :]
self.Xo[:, 0] = np.ones(shape=self.Xo[:, 0].shape)
self.obs[:, 0] = np.ones(shape=self.obs[:, 0].shape)
if kernel is None:
print(self.dim)
k = GPy.kern.RBF(input_dim=self.dim, ARD=True)
self.model_u = GPy.models.GPRegression(self.Xo,
self.obs[:, 2][:, None],
k.copy())
self.model_v = GPy.models.GPRegression(self.Xo,
self.obs[:, 1][:, None],
k.copy())
self.model_u.optimize_restarts(num_restarts=3, verbose=True)
self.model_v.optimize_restarts(num_restarts=3, verbose=True)
Ur, Ku = self.model_u.predict(
self.grid_points) # Kr = posterior covariance
Vr, Kv = self.model_v.predict(self.grid_points)
#print(Ur)
# Reshape the output velocity component matrices to be the same size and shape as
# the inital matrices of x, y points
self.ur = np.reshape(Ur, [self.t.size, self.y.size, self.x.size])
self.vr = np.reshape(Vr, [self.t.size, self.y.size, self.x.size])
#print(self.ur)
#print(self.vr)
self.ku = np.reshape(Ku, [self.t.size, self.y.size, self.x.size])
self.kv = np.reshape(Kv, [self.t.size, self.y.size, self.x.size])
else:
self.format_obs()
k = kernel
self.model_u = GPy.models.GPRegression(self.Xo,
self.obs[:, 0][:, None],
k.copy())
self.model_u.optimize_restarts(num_restarts=3, verbose=False)
Ur, Ku = self.model_u.predict(
self.grid_points) # Kr = posterior covariance
# Reshape the output velocity component matrices to be the same size and shape as
# the inital matrices of x, y points
self.ur = np.reshape(Ur[:Ur.size // 2], [self.y.size, self.x.size])
self.vr = np.reshape(Ur[Ur.size // 2:], [self.y.size, self.x.size])
self.ku = np.reshape(Ku[:Ur.size // 2], [self.y.size, self.x.size])
self.kv = np.reshape(Ku[Ur.size // 2:], [self.y.size, self.x.size])
def get_params(self):
return self.x, self.y, self.u, self.v, self.ur, self.vr, self.Xo, self.ku, self.kv
def save_data_to_file(self, directory):
np.savetxt(directory + "regression_x.csv",
self.x,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_y.csv",
self.y,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_u.csv",
self.u,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_v.csv",
self.v,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_ur.csv",
self.ur,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_vr.csv",
self.vr,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_xo.csv",
self.Xo,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_obs.csv",
self.obs,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_ku.csv",
self.ku,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_kv.csv",
self.kv,
fmt="%.6e",
delimiter=',')
if self.trajectory is not None:
print("Saving Trajectory")
self.trajectory.save_positions_to_file()
np.savetxt(directory + "regression_model_u.npy",
self.model_u.param_array,
fmt="%.6e",
delimiter=',')
np.savetxt(directory + "regression_model_v.npy",
self.model_v.param_array,
fmt="%.6e",
delimiter=',')
def load_data_from_file(self, directory):
self.x = np.loadtxt(directory + "regression_x.csv", delimiter=',')
self.y = np.loadtxt(directory + "regression_y.csv", delimiter=',')
self.u = np.loadtxt(directory + "regression_u.csv", delimiter=',')
self.v = np.loadtxt(directory + "regression_v.csv", delimiter=',')
self.ur = np.loadtxt(directory + "regression_ur.csv", delimiter=',')
self.vr = np.loadtxt(directory + "regression_vr.csv", delimiter=',')
self.Xo = np.loadtxt(directory + "regression_xo.csv", delimiter=',')
self.obs = np.loadtxt(directory + "regression_obs.csv", delimiter=',')
self.ku = np.loadtxt(directory + "regression_ku.csv", delimiter=',')
self.kv = np.loadtxt(directory + "regression_kv.csv", delimiter=',')
if os.path.exists(directory + 'trajectory_data.csv'):
print("Loading Trajectory")
self.trajectory = Trajectory(0, 0, 0)
self.trajectory.load_positions_from_file()
k = GPy.kern.RBF(input_dim=2, variance=1)
self.model_u = GPy.models.GPRegression(self.Xo, self.obs[:, 1][:,
None],
k.copy())
self.model_v = GPy.models.GPRegression(self.Xo, self.obs[:, 0][:,
None],
k.copy())
self.model_u.update_model(False)
self.model_u.initialize_parameter()
self.model_u[:] = np.loadtxt(directory + 'regression_model_u.npy')
self.model_u.update_model(True)
self.model_v.update_model(False)
self.model_v.initialize_parameter()
self.model_v[:] = np.loadtxt(directory + 'regression_model_v.npy')
self.model_v.update_model(True)
def format_obs(self):
us = self.obs[:, 2][:, None]
vs = self.obs[:, 1][:, None]
self.obs = np.concatenate([us, vs], axis=0)
def plot_quiver(self, show=True, save=False):
def setup_plot(plot, x, y, u, v, xo, title):
plot.quiver(x[::self.ds],
y[::self.ds],
u[::self.ds, ::self.ds],
v[::self.ds, ::self.ds],
scale=self.scale)
plot.streamplot(x, y, u, v)
plot.plot(xo[:, self.dim - 1],
xo[:, self.dim - 2],
'og',
markersize=self.marker_size)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.set_title(title, size=self.text_size, pad=self.title_pad)
plot.tick_params(labelsize=self.tick_label_size)
n = 0
print(self.u)
ur = self.ur[n, :, :]
vr = self.vr[n, :, :]
xo = self.Xo[self.n_drifters * n:self.n_drifters * n +
self.n_drifters, :]
fig1 = pl.figure(figsize=(self.figW, self.figH))
# Plot the Original Velocity Field
plot1 = fig1.add_subplot(1, 2, 1, aspect='equal')
orig_title = 'Original Velocity Field (' + str(
self.n_drifters) + ' drifters)'
setup_plot(plot1, self.x, self.y, self.u, self.v, self.Xo, orig_title)
# Plot the Velocity Field Generated by the Gaussian Process Regression
plot2 = fig1.add_subplot(1, 2, 2, aspect='equal')
gpr_title = 'GPR Velocity Field (' + str(
self.n_drifters) + ' drifters)'
setup_plot(plot2, self.x, self.y, ur, vr, xo, gpr_title)
pl.subplots_adjust(left=0.05,
bottom=0.20,
right=0.95,
top=0.88,
wspace=0.06,
hspace=0.15)
slider_color = 'lightgoldenrodyellow'
slider_ax = pl.axes([0.05, 0.05, 0.85, 0.05], facecolor=slider_color)
slider = Slider(slider_ax,
'Freq',
0,
self.trajectory.n_timesteps,
valinit=0,
valstep=1)
def update(val):
n = int(slider.val)
ur = self.ur[n, :, :]
vr = self.vr[n, :, :]
xo = self.Xo[self.n_drifters * n:self.n_drifters * n +
self.n_drifters, :]
plot1.cla()
setup_plot(plot1, self.x, self.y, self.u, self.v, xo, orig_title)
plot2.cla()
setup_plot(plot2, self.x, self.y, ur, vr, xo, gpr_title)
slider.on_changed(update)
slider.set_val(0)
if show:
pl.show()
if save:
slider_ax.set_axis_off()
fig1.savefig('quiver.png', dpi=300)
def plot_curl(self, show=True, save=False):
def plot_curl(plot, curl, title):
im = plot.imshow(curl,
vmin=0,
vmax=2,
origin='center',
extent=plot_extent,
cmap='jet')
plot.set_title(title, size=self.text_size, pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.tick_params(labelsize=self.tick_label_size)
plot.set_xticks([-5, 0, 5])
plot.set_yticks([-5, 0, 5])
return im
n = 0
ur = self.ur[n, :, :]
vr = self.vr[n, :, :]
init_curl = svf.SpiralVectorField.get_curl(self.u, self.v)
reg_curl = svf.SpiralVectorField.get_curl(ur, vr)
c_diff = init_curl - reg_curl
plot_extent = [self.x.min(), self.x.max(), self.y.min(), self.y.max()]
fig8 = pl.figure(figsize=(self.figW, self.figH))
orig_curl_plot = fig8.add_subplot(1, 3, 1, aspect='equal')
orig_title = "Initial Curl"
orig_im = plot_curl(orig_curl_plot, init_curl, orig_title)
gpr_curl_plot = fig8.add_subplot(1, 3, 2, aspect='equal')
gpr_title = "GPR Curl"
gpr_im = plot_curl(gpr_curl_plot, reg_curl, gpr_title)
error_plot = fig8.add_subplot(1, 3, 3, aspect='equal')
error_title = "Curl Error"
error_im = plot_curl(error_plot, c_diff, error_title)
# cbar = pl.colorbar(orig_im, fraction=0.046, pad=0.04, ax=orig_curl_plot)
# cbar.ax.tick_params(labelsize=self.cbar_label_size)
# cbar = pl.colorbar(gpr_im, fraction=0.046, pad=0.04, ax=gpr_curl_plot)
# cbar.ax.tick_params(labelsize=self.cbar_label_size)
cbar = pl.colorbar(error_im, fraction=0.046, pad=0.04, ax=error_plot)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
slider_color = 'lightgoldenrodyellow'
slider_ax = pl.axes([0.05, 0.15, 0.85, 0.05], facecolor=slider_color)
slider = Slider(slider_ax,
'Freq',
0,
self.trajectory.n_timesteps,
valinit=0,
valstep=1)
def update(val):
n = int(slider.val)
ur = self.ur[n, :, :]
vr = self.vr[n, :, :]
init_curl = svf.SpiralVectorField.get_curl(self.u, self.v)
reg_curl = svf.SpiralVectorField.get_curl(ur, vr)
c_diff = init_curl - reg_curl
orig_curl_plot.cla()
plot_curl(orig_curl_plot, init_curl, orig_title)
gpr_curl_plot.cla()
plot_curl(gpr_curl_plot, reg_curl, gpr_title)
error_plot.cla()
plot_curl(error_plot, c_diff, error_title)
slider.on_changed(update)
pl.subplots_adjust(left=0.03,
bottom=0.43,
right=0.93,
top=0.88,
wspace=0.01,
hspace=0.0)
if show:
pl.show()
if save:
slider_ax.set_axis_off()
fig8.savefig('curl.png', dpi=300)
def plot_div(self, show=True, save=False):
def plot_div(plot, div, title):
im = plot.imshow(div,
vmin=-0.5,
vmax=0.5,
origin='center',
extent=plot_extent,
cmap='jet')
plot.set_title(title, size=self.text_size, pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.set_xticks([-5, 0, 5])
plot.set_yticks([-5, 0, 5])
plot.tick_params(labelsize=self.tick_label_size)
return im
n = 0
ur = self.ur[n, :, :]
vr = self.vr[n, :, :]
init_div = svf.SpiralVectorField.get_divergence(self.u, self.v)
reg_div = svf.SpiralVectorField.get_divergence(ur, vr)
diff = init_div - reg_div
plot_extent = [self.x.min(), self.x.max(), self.y.min(), self.y.max()]
fig8 = pl.figure(figsize=(self.figW, self.figH))
orig_div_plot = fig8.add_subplot(1, 3, 1, aspect='equal')
orig_title = "Initial Divergence"
orig_im = plot_div(orig_div_plot, init_div, orig_title)
gpr_div_plot = fig8.add_subplot(1, 3, 2, aspect='equal')
gpr_title = "GPR Divergence"
gpr_im = plot_div(gpr_div_plot, reg_div, gpr_title)
error_plot = fig8.add_subplot(1, 3, 3, aspect='equal')
error_title = "Divergence Error"
error_im = plot_div(error_plot, diff, error_title)
# cbar = pl.colorbar(orig_im, fraction=0.046, pad=0.04, ax=orig_div_plot)
# cbar.ax.tick_params(labelsize=self.cbar_label_size)
# cbar = pl.colorbar(gpr_im, fraction=0.046, pad=0.04, ax=gpr_div_plot)
# cbar.ax.tick_params(labelsize=self.cbar_label_size)
cbar = pl.colorbar(error_im, fraction=0.046, pad=0.04, ax=error_plot)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
slider_color = 'lightgoldenrodyellow'
slider_ax = pl.axes([0.05, 0.15, 0.85, 0.05], facecolor=slider_color)
slider = Slider(slider_ax,
'Freq',
0,
self.trajectory.n_timesteps,
valinit=0,
valstep=1)
def update(val):
n = int(slider.val)
ur = self.ur[n, :, :]
vr = self.vr[n, :, :]
init_div = svf.SpiralVectorField.get_divergence(self.u, self.v)
reg_div = svf.SpiralVectorField.get_divergence(ur, vr)
diff = init_div - reg_div
orig_div_plot.cla()
plot_div(orig_div_plot, init_div, orig_title)
gpr_div_plot.cla()
plot_div(gpr_div_plot, reg_div, gpr_title)
error_plot.cla()
plot_div(error_plot, diff, error_title)
slider.on_changed(update)
pl.subplots_adjust(left=0.03,
bottom=0.43,
right=0.93,
top=0.88,
wspace=0.01,
hspace=0.0)
if show:
pl.show()
if save:
slider_ax.set_axis_off()
fig8.savefig('div.png', dpi=300)
def plot_raw_error(self, show=True, save=False):
def plot_error(plot, error, xo, title):
im = plot.imshow(error,
vmin=0,
vmax=0.5,
origin='center',
extent=plot_extent,
cmap='jet')
plot.set_title(title, size=self.text_size, pad=self.title_pad)
plot.plot(xo[:, 2], xo[:, 1], 'og', markersize=self.marker_size)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.set_xticks([-5, 0, 5])
plot.set_yticks([-5, 0, 5])
plot.tick_params(labelsize=self.tick_label_size)
return im
n = 0
ur = self.ur[n, :, :]
vr = self.vr[n, :, :]
xo = self.Xo[self.n_drifters * n:self.n_drifters * n +
self.n_drifters, :]
error_u = np.absolute(np.subtract(self.u, ur))
error_v = np.absolute(np.subtract(self.v, vr))
ea = np.sqrt(
np.divide(np.add(np.power(error_u, 2), np.power(error_v, 2)), 2))
plot_extent = [self.x.min(), self.x.max(), self.y.min(), self.y.max()]
fig8 = pl.figure(figsize=(self.figW, self.figH))
orig_div_plot = fig8.add_subplot(1, 3, 1, aspect='equal')
orig_title = "GPR Raw Error U"
orig_im = plot_error(orig_div_plot, error_u, xo, orig_title)
gpr_div_plot = fig8.add_subplot(1, 3, 2, aspect='equal')
gpr_title = "GPR Raw Error V"
gpr_im = plot_error(gpr_div_plot, error_v, xo, gpr_title)
error_plot = fig8.add_subplot(1, 3, 3, aspect='equal')
error_title = "GPR Raw Error U+V"
error_im = plot_error(error_plot, ea, xo, error_title)
# cbar = pl.colorbar(orig_im, fraction=0.046, pad=0.04, ax=orig_div_plot)
# cbar.ax.tick_params(labelsize=self.cbar_label_size)
# cbar = pl.colorbar(gpr_im, fraction=0.046, pad=0.04, ax=gpr_div_plot)
# cbar.ax.tick_params(labelsize=self.cbar_label_size)
cbar = pl.colorbar(error_im, fraction=0.046, pad=0.04, ax=error_plot)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
slider_color = 'lightgoldenrodyellow'
slider_ax = pl.axes([0.05, 0.15, 0.85, 0.05], facecolor=slider_color)
slider = Slider(slider_ax,
'Freq',
0,
self.trajectory.n_timesteps,
valinit=0,
valstep=1)
def update(val):
n = int(slider.val)
ur = self.ur[n, :, :]
vr = self.vr[n, :, :]
xo = self.Xo[self.n_drifters * n:self.n_drifters * n +
self.n_drifters, :]
error_u = np.absolute(np.subtract(self.u, ur))
error_v = np.absolute(np.subtract(self.v, vr))
ea = np.sqrt(
np.divide(np.add(np.power(error_u, 2), np.power(error_v, 2)),
2))
orig_div_plot.cla()
plot_error(orig_div_plot, error_u, xo, orig_title)
gpr_div_plot.cla()
plot_error(gpr_div_plot, error_v, xo, gpr_title)
error_plot.cla()
plot_error(error_plot, ea, xo, error_title)
slider.on_changed(update)
pl.subplots_adjust(left=0.03,
bottom=0.43,
right=0.93,
top=0.88,
wspace=0.01,
hspace=0.0)
if show:
pl.show()
if save:
slider_ax.set_axis_off()
fig8.savefig('abs_error.png', dpi=300)
def plot_relative_error(self, show=True, save=False):
def plot_error(plot, error, title):
im = plot.imshow(error,
vmin=0,
vmax=0.5,
origin='center',
extent=plot_extent,
cmap='jet')
plot.set_title(title, size=self.text_size, pad=self.title_pad)
plot.set_xlim(-5, 5)
plot.set_ylim(-5, 5)
plot.set_xticks([-5, 0, 5])
plot.set_yticks([-5, 0, 5])
plot.tick_params(labelsize=self.tick_label_size)
return im
n = 0
ur = self.ur[n, :, :]
vr = self.vr[n, :, :]
error_u = np.absolute((self.u - ur) / self.u)
error_v = np.absolute((self.v - vr) / self.v)
ea = np.sqrt(
np.divide(np.add(np.power(error_u, 2), np.power(error_v, 2)), 2))
plot_extent = [self.x.min(), self.x.max(), self.y.min(), self.y.max()]
fig8 = pl.figure(figsize=(self.figW, self.figH))
orig_div_plot = fig8.add_subplot(1, 3, 1, aspect='equal')
orig_title = "GPR Relative Error U"
orig_im = plot_error(orig_div_plot, error_u, orig_title)
gpr_div_plot = fig8.add_subplot(1, 3, 2, aspect='equal')
gpr_title = "GPR Relative Error V"
gpr_im = plot_error(gpr_div_plot, error_v, gpr_title)
error_plot = fig8.add_subplot(1, 3, 3, aspect='equal')
error_title = "GPR Relative Error U+V"
error_im = plot_error(error_plot, ea, error_title)
# cbar = pl.colorbar(orig_im, fraction=0.046, pad=0.04, ax=orig_div_plot)
# cbar.ax.tick_params(labelsize=self.cbar_label_size)
# cbar = pl.colorbar(gpr_im, fraction=0.046, pad=0.04, ax=gpr_div_plot)
# cbar.ax.tick_params(labelsize=self.cbar_label_size)
cbar = pl.colorbar(error_im, fraction=0.046, pad=0.04, ax=error_plot)
cbar.ax.tick_params(labelsize=self.cbar_label_size)
slider_color = 'lightgoldenrodyellow'
slider_ax = pl.axes([0.05, 0.15, 0.85, 0.05], facecolor=slider_color)
slider = Slider(slider_ax,
'Freq',
0,
self.trajectory.n_timesteps,
valinit=0,
valstep=1)
def update(val):
n = int(slider.val)
ur = self.ur[n, :, :]
vr = self.vr[n, :, :]
error_u = np.absolute((self.u - ur) / self.u)
error_v = np.absolute((self.v - vr) / self.v)
ea = np.sqrt(
np.divide(np.add(np.power(error_u, 2), np.power(error_v, 2)),
2))
orig_div_plot.cla()
plot_error(orig_div_plot, error_u, orig_title)
gpr_div_plot.cla()
plot_error(gpr_div_plot, error_v, gpr_title)
error_plot.cla()
plot_error(error_plot, ea, error_title)
slider.on_changed(update)
pl.subplots_adjust(left=0.03,
bottom=0.43,
right=0.93,
top=0.88,
wspace=0.01,
hspace=0.0)
if show:
pl.show()
if save:
slider_ax.set_axis_off()
fig8.savefig('rel_error.png', dpi=300)
def plot_errors(self, save=False):
self.plot_quiver(save=save)
self.plot_curl(save=save)
self.plot_div(save=save)
self.plot_raw_error(save=save)
self.plot_relative_error(save=save)
def plot_errors(self, save=False):
self.plot_quiver(save=save)
self.plot_curl(save=save)
self.plot_div(save=save)
self.plot_raw_error(save=save)
self.plot_relative_error(save=save)
if __name__ == "__main__":
regression = TimeseriesRegression()
div_k = dfk.DivFreeK(3)
curl_k = cfk.CurlFreeK(3)
kernel = div_k + curl_k
trajectory = Trajectory(nsamples=30,
integration_time=30,
n_timesteps=10,
pattern=Pattern.grid)
regression.initialize_samples(trajectory=trajectory)
regression.run_model()
#print(regression.model_u.kern.lengthscale[2])
regression.plot_curl()