def xs_compute_true_u(cb, nsamples, pi_line, kcmax=1, plot=False, write=False):
X = np.zeros((n_inputs))
y = np.zeros((1))
for n in range(nsamples):
for kc in range(1, kcmax + 1):
filename = "cpx_init_kc%d_%d" % (kc, n)
uu = harm.complex_init_sin(cb.line_x,
kc=kc,
inter_deph=pi_line,
L=cb.L,
plot=plot)
_, abs_work = LW_solver(uu,
cb.itmax,
filename=filename,
write=write,
plot=plot)
for it in range(1, cb.itmax):
u_curr = np.load(
osp.join(abs_work, filename + "_it%d.npy" % (it)))
u_next = np.load(
osp.join(abs_work, filename + "_it%d.npy" % (it + 1)))
for j in range(1, len(uu) - 1):
X = np.block([[X], add_block(u_curr, cb.line_x, j)])
y = np.block([[y], [u_next[j]]])
X = np.delete(X, 0, axis=0)
y = np.delete(y, 0, axis=0)
return X, y
def forward_multiNN_solver(nn_obj, cb=cb):
plt.figure()
p = min(np.random.choice(pi_line), np.random.choice(pi_line))
# u = cb.init_u(p, cpx=2)
u = harm.complex_init_sin(cb.line_x, 1, pi_line, cb.L)
_, abs_work = LW_solver(u, cb.itmax, "u_test", write=True)
print (abs_work)
fetch_real_u = lambda it : np.load(osp.join(abs_work, "u_test_it%d.npy"%(it)))
u_nNext = []
for it in range(1, cb.itmax) :
if it > 1 :
u = u_nNext
u_nNext = []
xs = np.array(u)
xs = nn_obj.scale_inputs(xs)
xs = xs.reshape(1, -1)
u_nNext.append(nn_obj.predict(u))
# u_nNext.shape = 30
# use of list type to insert in a second time boundary condition
if it % 5 == 0 :
plt.clf()
plt.plot(cb.line_x, fetch_real_u(it+1), label="True it = %d" %(it+1), c='k')
plt.plot(cb.line_x, u_nNext, label="Predicted at it = %d" %(it), marker='o', fillstyle = 'none', linestyle= 'none', c=nn_obj.kwargs["color"])
plt.legend()
plt.pause(2)
def init_fields(self, phase=0, kc=1, plot=False):
if self.type_init == "random":
U_intervals = np.linspace(-self.U, self.U, 10000)
H_intervals = np.linspace(-self.H, self.H, 10000)
u_init_field, h_init_field = [], []
for i in range(1, self.Nx - 1):
u_init_field.append(np.random.choice(U_intervals))
h_init_field.append(np.random.choice(H_intervals))
u_init_field.insert(0, 0.)
h_init_field.insert(0, 0.)
u_init_field.insert(len(u_init_field), 0.0)
h_init_field.insert(len(u_init_field), 0.0)
if self.type_init == "sin":
u_init_field = self.U * np.sin(2 * np.pi * self.line_x / self.L +
phase)
h_init_field = self.H * np.sin(2 * np.pi * self.line_x / self.L +
phase)
if self.type_init == "choc":
u_init_field, h_init_field = [], []
for x in self.line_x:
if 0.5 < x < self.L / 2. + 0.5:
u_init_field.append(self.U)
h_init_field.append(self.H)
else:
u_init_field.append(0.)
h_init_field.append(0.)
if self.type_init == 'complex':
inter_deph = np.linspace(-np.pi, np.pi, 10000)
u_init_field = harm.complex_init_sin(self.line_x,
kc,
inter_deph,
self.L,
A=25)
h_init_field = self.H / self.U * u_init_field
if plot:
plt.figure()
plt.plot(self.line_x, u_init_field, label="u init", color='blue')
plt.plot(self.line_x,
h_init_field,
label="h init",
color='red',
linestyle='--')
plt.legend(loc='best')
self.u_init_field = np.array(u_init_field)
self.h_init_field = np.array(h_init_field)
def xs_multiNN_solver(nn_obj, cb=cb):
plt.figure()
p = min(np.random.choice(pi_line), np.random.choice(pi_line))
# u = cb.init_u(p, cpx=2)
u = harm.complex_init_sin(cb.line_x, 1, pi_line, cb.L)
_, abs_work = LW_solver(u, cb.itmax, "u_test", write=True)
print(abs_work)
fetch_real_u = lambda it: np.load(
osp.join(abs_work, "u_test_it%d.npy" % (it)))
u_nNext = []
for it in range(1, cb.itmax):
if it > 1:
u = u_nNext
u_nNext = []
for j in range(1, cb.Nx - 1):
xs = np.array(add_block(u, cb.line_x, j))
if nn_obj.scaler_name != "None":
# print ("Before : \n{}".format(xs))
xs = nn_obj.scale_inputs(xs)
# print ("After : \n{}".format(xs))
#
# time.sleep(2)
xs = xs.reshape(1, -1)
u_nNext.append(nn_obj.predict(xs)[0, 0])
# u_nNext.shape = 30
# use of list type to insert in a second time boundary condition
u_nNext.insert(0, u[-2])
u_nNext.insert(len(u), u[1])
u_nNext = np.array(u_nNext)
if it % 5 == 0:
plt.clf()
plt.plot(cb.line_x[1:cb.Nx - 1],
fetch_real_u(it + 1)[1:cb.Nx - 1],
label="True it = %d" % (it + 1),
c='k')
plt.plot(cb.line_x[1:cb.Nx - 1],
u_nNext[1:cb.Nx - 1],
label="Predicted at it = %d" % (it),
marker='o',
fillstyle='none',
linestyle='none',
c=nn_obj.kwargs["color"])
plt.legend()
plt.pause(2)
def create_init(tc ,phase, kc=1, plot=False):
if tc.type_init == "random" :
U_intervals = np.linspace(-tc.U, tc.U, 10000)
H_intervals = np.linspace(-tc.H, tc.H, 10000)
u_init_field, h_init_field = [], []
for i in range(1, tc.Nx-1):
u_init_field.append(np.random.choice(U_intervals))
h_init_field.append(np.random.choice(H_intervals))
u_init_field.insert(0, 0.)
h_init_field.insert(0, 0.)
u_init_field.insert(len(u_init_field), 0.0)
h_init_field.insert(len(u_init_field), 0.0)
if tc.type_init == "sin" :
u_init_field = tc.U*np.sin(2*np.pi*tc.line_x/tc.L + phase)
h_init_field = tc.H*np.sin(2*np.pi*tc.line_x/tc.L + phase)
if tc.type_init == "choc" :
u_init_field, h_init_field = [], []
for x in tc.line_x :
if 0.5 < x < tc.L/2. + 0.5 :
u_init_field.append(tc.U)
h_init_field.append(tc.H)
else :
u_init_field.append(0.)
h_init_field.append(0.)
if tc.type_init == 'complex' :
inter_deph = np.linspace(-np.pi, np.pi, 10000)
u_init_field = harm.complex_init_sin(tc.line_x, kc, inter_deph, tc.L, A=25)
h_init_field = tc.H / tc.U * u_init_field
if plot :
plt.figure()
plt.plot(tc.line_x, u_init_field, label="u init", color='blue')
plt.plot(tc.line_x, h_init_field, label="h init", color='red', linestyle='--')
plt.legend(loc='best')
return u_init_field, h_init_field
def Der_multiNN_solver(nn_obj, cb=cb):
plt.figure()
p = min(np.random.choice(pi_line), np.random.choice(pi_line))
# u = cb.init_u(p, cpx=2)
u = harm.complex_init_sin(cb.line_x, 1, pi_line, cb.L)
_, abs_work = LW_solver(u, cb.itmax, "u_test", write=True)
print(abs_work)
fetch_real_u = lambda it: np.load(
osp.join(abs_work, "u_test_it%d.npy" % (it)))
u_nNext = []
inf_errs = []
ax, axx = [], []
ax1 = plt.subplot(221) # Erreur a l'iteration n
ax2 = plt.subplot(222) # Evolution de la norme infinie de l'erreur
ax3 = plt.subplot(212) # Evolution de la prédiction
ax.append(ax1)
ax.append(ax2)
ax.append(ax3)
axx.append(ax1)
axx.append(ax3)
for it in range(1, cb.itmax):
if it > 1:
u = u_nNext
u_nNext = []
for j in range(1, cb.Nx - 1):
xs = np.array([
u[j - 1], u[j], u[j + 1], (u[j + 1] - u[j - 1]) / (2 * cb.dx)
])
xs = nn_obj.scale_inputs(xs)
xs = xs.reshape(1, -1)
u_nNext.append(nn_obj.predict(xs)[0, 0])
# u_nNext.shape = 30
# use of list type to insert in a second time boundary condition
u_nNext.insert(0, u[-2])
u_nNext.insert(len(u), u[1])
u_nNext = np.array(u_nNext)
u_nNext_ex = fetch_real_u(it + 1)
errs = np.array([(u_nNext[i] - u_nNext_ex[i]) for i in range(cb.Nx)])
inf_err = np.linalg.norm(errs, np.inf)
inf_errs.append(inf_err)
if it % 5 == 0:
axx[0] = ax[0]
axx[1] = ax[-1]
for a in axx:
a.cla()
# Erreur a l'iteration n
ax[0].plot(cb.line_x,
np.abs(errs),
label="Relative Erreur $\hat{u}^{n+1} - u^{n+1}_t$",
c=nn_obj.kwargs["color"])
# Evolution de la norme infinie de l'erreur
ax[1].scatter(it, inf_err, c=nn_obj.kwargs["color"], s=12)
ax[-1].plot(cb.line_x[1:cb.Nx - 1],
u_nNext_ex[1:cb.Nx - 1],
label="True it = %d" % (it + 1),
c='k')
ax[-1].plot(cb.line_x[1:cb.Nx - 1],
u_nNext[1:cb.Nx - 1],
label="Predicted at it = %d" % (it),
marker='o',
fillstyle='none',
linestyle='none',
c=nn_obj.kwargs["color"])
for a in ax:
a.legend(prop={'size': 8})
fig = plt.gcf()
fig.tight_layout()
plt.title("Iteration %d" % it)
plt.pause(2)
return inf_errs
def Der_bootstrap_solver(boot_obj, rescale, cb=cb):
plt.figure()
p = min(np.random.choice(pi_line), np.random.choice(pi_line))
u = harm.complex_init_sin(cb.line_x, 1, pi_line, cb.L)
_, abs_work = LW_solver(u, cb.itmax, "u_test", write=True)
print(abs_work)
fetch_real_u = lambda it: np.load(
osp.join(abs_work, "u_test_it%d.npy" % (it)))
u_nNext = []
var = []
colors = np.array(
[mpl.colors.to_rgb(cc) for cc in boot_obj.colors_dict.values()])
color = np.mean(colors, axis=0)
inf_errs = []
ax, axx = [], []
ax1 = plt.subplot(221) # Erreur a l'iteration n
ax2 = plt.subplot(222) # Evolution de la norme infinie de l'erreur
ax3 = plt.subplot(212) # Evolution de la prédiction
ax.append(ax1)
ax.append(ax2)
ax.append(ax3)
axx.append(ax1)
axx.append(ax3)
for it in range(1, cb.itmax):
if it > 1:
u = u_nNext
u_nNext = []
var = []
for j in range(1, cb.Nx - 1):
xs = np.array([
u[j - 1], u[j], u[j + 1], (u[j + 1] - u[j - 1]) / (2 * cb.dx)
])
mean_curr_pred = boot_obj.bootstrap_prediction(xs,
rescale=rescale,
variance=False)
var_curr_pred = boot_obj.bootstrap_variance(xs, rescale=rescale)
u_nNext.append(mean_curr_pred)
var.append(var_curr_pred)
# u_nNext.shape = 30
# use of list type to insert in a second time boundary condition
u_nNext.insert(0, u[-2])
u_nNext.insert(len(u), u[1])
u_nNext = np.array(u_nNext)
u_nNext_ex = fetch_real_u(it + 1)
errs = np.array([(u_nNext[i] - u_nNext_ex[i]) for i in range(cb.Nx)])
inf_err = np.linalg.norm(errs, np.inf)
inf_errs.append(inf_err)
if it % 5 == 0:
axx[0] = ax[0]
axx[1] = ax[-1]
for a in axx:
a.cla()
# Erreur a l'iteration n
ax[0].plot(cb.line_x,
np.abs(errs),
label="Abs error : $\hat{u}^{n+1} - u^{n+1}_t$",
c=color)
# Evolution de la norme infinie de l'erreur
ax[1].scatter(it, inf_err, c=color, s=12)
ax[-1].plot(cb.line_x[1:cb.Nx - 1],
u_nNext_ex[1:cb.Nx - 1],
label="True it = %d" % (it + 1),
c='k')
ax[-1].plot(cb.line_x[1:cb.Nx - 1],
u_nNext[1:cb.Nx - 1],
label="Predicted at it = %d" % (it),
marker='o',
fillstyle='none',
linestyle='none',
c=color)
ax[-1].fill_between(cb.line_x[1:cb.Nx - 1],
-10 * np.array(var),
10 * np.array(var),
facecolor="0.2",
alpha=0.4,
interpolate=True,
label="$\pm \sigma$")
for a in ax:
a.legend(prop={'size': 8})
fig = plt.gcf()
fig.tight_layout()
plt.title("Iteration %d" % it)
plt.pause(2)
return inf_errs
def MHD_NN_solver(nn_obj, tc=tc):
p = min(np.random.choice(inter_deph), np.random.choice(inter_deph))
# u = cb.init_u(p, cpx=2)
u = harm.complex_init_sin(tc.line_x, 1, inter_deph, tc.L)
filename = [osp.join(curr_work, "u", "test"), osp.join(curr_work, "h", "test")]
for i, (s,k) in enumerate(zip(filename, ["u","h"])) :
filename[i] = osp.join(s, "%s_test" % k)
if osp.exists(s) == False :
os.mkdir(s)
phase = np.random.choice(inter_deph)
u, h = create_init(tc, phase, kc=1, plot=False)
solve_case(tc, u, h, filename)
print ("filename = % s" % filename)
u_test_dir = osp.join(curr_work, "u", "test")
h_test_dir = osp.join(curr_work, "h", "test")
fetch_fields = [ lambda it : np.load(osp.join(f, "%s_test_it%d.npy"%(k, it))) for f,k in zip([u_test_dir, h_test_dir], ["u", "h"])]
fig, axes = plt.subplots(1, 2, figsize=(9,9), num="Evolution u et h -- Prediction")
for it in range(1, tc.itmax) :
if it > 1 :
u = u_nNext
h = h_nNext
u_nNext = []
h_nNext = []
for j in range(1, tc.Nx-1) :
xs = np.array(add_block(u, h, j))
xs = nn_obj.scale_inputs(xs)
xs = xs.reshape(1, -1)
u_nNext.append(nn_obj.predict(xs)[0,0])
# u_nNext.shape = 30
# use of list type to insert in a second time boundary condition
u_nNext.insert(0, u[-2])
u_nNext.insert(len(u), u[1])
h_nNext.insert(0, h[-2])
u_nNext.insert(len(h), h[1])
u_nNext = np.array(u_nNext)
h_nNext = np.array(h_nNext)
plt.clf()
color = iter(["navy", "darkred"])
for n, (ax, k, MLfield) in enumerate(zip(axes, ["u", "h"], [u_nNext, h_nNext])):
c = next(color)
ax.plot(tc.line_x[1:tc.Nx-1], fetch_fields[n](it+1)[1:tc.Nx-1], label="True %s it = %d" %(k, it+1), c='k')
ax.plot(tc.line_x[1:tc.Nx-1], MLfield[1:tc.Nx-1], label="Predicted %s at it = %d" %(k, it), marker='o', fillstyle = 'none', linestyle= 'none', c=c)
ax.legend(loc="best")
plt.pause(2)
def Der_bootstrap_solver(boot_obj, rescale, cb=cb):
plt.figure()
p = min(np.random.choice(pi_line), np.random.choice(pi_line))
u = harm.complex_init_sin(cb.line_x, 1, pi_line, cb.L)
_, abs_work = LW_solver(u, cb.itmax, "u_test", write=True)
print(abs_work)
fetch_real_u = lambda it: np.load(
osp.join(abs_work, "u_test_it%d.npy" % (it)))
u_nNext = []
var = []
for it in range(1, cb.itmax):
if it > 1:
u = u_nNext
u_nNext = []
var = []
for j in range(1, cb.Nx - 1):
xs = np.array([
u[j - 1], u[j], u[j + 1], (u[j + 1] - u[j - 1]) / (2 * cb.dx)
])
mean_curr_pred = boot_obj.bootstrap_prediction(xs,
rescale=rescale,
variance=False)
var_curr_pred = boot_obj.bootstrap_variance(xs, rescale=rescale)
u_nNext.append(mean_curr_pred)
var.append(var_curr_pred)
# u_nNext.shape = 30
# use of list type to insert in a second time boundary condition
u_nNext.insert(0, u[-2])
u_nNext.insert(len(u), u[1])
u_nNext = np.array(u_nNext)
if it % 5 == 0:
plt.clf()
plt.plot(cb.line_x[1:cb.Nx - 1],
fetch_real_u(it + 1)[1:cb.Nx - 1],
label="True it = %d" % (it + 1),
c='k')
plt.plot(cb.line_x[1:cb.Nx - 1],
u_nNext[1:cb.Nx - 1],
label="Predicted at it = %d" % (it),
marker='o',
fillstyle='none',
linestyle='none',
c="red")
plt.fill_between(cb.line_x[1:cb.Nx - 1],
-var,
var,
facecolor="0.2",
alpha=0.4,
interpolate=True,
label="$\pm \sigma$")
plt.legend()
plt.pause(2)
