def multi_burgers(self, loadnamenpy):
fu_list = []
ICparams_list = []
grid_list = []
# Load simulation results
fu, gridvars, ICparams = self.datamanager.loadSolution(loadnamenpy)
difflearn = PDElearn(grid=PdfGrid(gridvars),
fu=fu,
ICparams=ICparams,
trainratio=self.trainratio,
debug=False,
verbose=False)
F = Features(scase=self.case,
option=self.feature_opt,
variableCoef=self.variableCoef,
variableCoefOrder=self.variableCoefOrder,
variableCoefBasis=self.variableCoefBasis)
featurelist, labels, featurenames = F.makeFeatures(
PdfGrid(gridvars), fu, ICparams)
Xtrain, ytrain, Xtest, ytest = difflearn.makeTTsets(featurelist,
labels,
shuffle=False)
# Fit data
lin, rem_feature_idx = difflearn.train_sindy(Xtrain, ytrain, \
RegCoef=self.RegCoef, maxiter=self.maxiter, tolerance=self.tolerance, sindy_iter=self.sindy_iter, sindy_alpha=self.sindy_alpha)
difflearn.print_full_report(lin, Xtrain, ytrain, Xtest, ytest,
rem_feature_idx, featurenames)
return difflearn, featurenames, Xtrain, ytrain, Xtest, ytest
def multiIC(self):
fuk_list = []
fu_list = []
ICparams_list = []
grid_list = []
# Load simulation results
for i in range(len(self.loadname_list)):
if i >= self.numexamples:
break
fuk, fu, gridvars, ICparams = self.datamanager.loadSolution(
self.loadname_list[i] + '.npy')
difflearn = PDElearn(fuk=fuk,
grid=PdfGrid(gridvars),
fu=fu,
ICparams=ICparams,
trainratio=self.trainratio,
debug=False,
verbose=False)
F = Features(scase=self.case,
option=self.feature_opt,
variableCoef=self.variableCoef,
variableCoefOrder=self.variableCoefOrder,
variableCoefBasis=self.variableCoefBasis)
featurelist, labels, featurenames = F.makeFeatures(
PdfGrid(gridvars), fu, ICparams)
Xtrain, ytrain, Xtest, ytest = difflearn.makeTTsets(featurelist,
labels,
shuffle=False)
#pdb.set_trace()
if i == 0:
Xall_train = Xtrain
Xall_test = Xtest
yall_train = ytrain
yall_test = ytest
else:
Xall_train = np.concatenate((Xall_train, Xtrain), axis=0)
yall_train = np.concatenate((yall_train, ytrain), axis=0)
Xall_test = np.concatenate((Xall_test, Xtest), axis=0)
yall_test = np.concatenate((yall_test, ytest), axis=0)
# Fit data
lin, rem_feature_idx = difflearn.train_sindy(Xall_train, yall_train, \
RegCoef=self.RegCoef, maxiter=self.maxiter, tolerance=self.tolerance, sindy_iter=self.sindy_iter, sindy_alpha=self.sindy_alpha)
difflearn.print_full_report(lin, Xall_train, yall_train, Xall_test,
yall_test, rem_feature_idx, featurenames)
return difflearn, featurenames, Xall_train, yall_train, Xall_test, yall_test
def analyze(self, adjust=False, plot=False, learn=False, adjustparams={}, learnparams={'feature_opt':'1storder', 'coeforder':1}):
dataman = DataIO(self.case)
fu, gridvars, ICparams = dataman.loadSolution(self.loadnamenpy, array_opt='marginal')
##Make fu smaller (in time)
if adjust:
fu, gridvars = self.adjust(fu, gridvars, adjustparams)
grid = PdfGrid(gridvars)
if plot:
V = Visualize(grid)
V.plot_fu3D(fu)
V.plot_fu(fu, dim='t', steps=5)
V.plot_fu(fu, dim='x', steps=5)
V.show()
if learn:
t0 = time.time()
print('fu dimension: ', fu.shape)
print('fu num elem.: ', np.prod(fu.shape))
feature_opt = learnparams['feature_opt']
coeforder = learnparams['coeforder']
sindy_alpha = learnparams['sindy_alpha']
RegCoef = learnparams['RegCoef']
nzthresh = learnparams['nzthresh']
# Learn
difflearn = PDElearn(grid=grid, fu=fu, ICparams=ICparams, scase=self.case, trainratio=0.8, debug=False, verbose=True)
difflearn.fit_sparse(feature_opt=feature_opt, variableCoef=True, variableCoefBasis='simple_polynomial', \
variableCoefOrder=coeforder, use_sindy=True, sindy_alpha=sindy_alpha, RegCoef=RegCoef, nzthresh=nzthresh)
print('learning took t = ', str(t0 - time.time()))
def advection():
#loadnamenpy = 'advection_marginal_7397.npy'
loadnamenpy = 'advection_marginal_6328.npy'
loadnamenpy = 'advection_marginal_8028.npy'
loadnamenpy = 'advection_marginal_5765.npy'
#loadnamenpy = 'advection_marginal_4527.npy'
case = '_'.join(loadnamenpy.split('_')[:2])
dataman = DataIO(case)
fuk, fu, gridvars, ICparams = dataman.loadSolution(loadnamenpy)
grid = PdfGrid(gridvars)
V = Visualize(grid)
V.plot_fuk3D(fuk)
V.plot_fu3D(fu)
V.plot_fu(fu, dim='t', steps=5)
V.plot_fu(fu, dim='x', steps=5)
V.show()
# Learn
difflearn = PDElearn(fuk,
grid,
fu=fu,
ICparams=ICparams,
scase=case,
trainratio=0.8,
debug=False,
verbose=True)
difflearn.fit_sparse(feature_opt='2ndorder',
variableCoef=True,
variableCoefBasis='simple_polynomial',
variableCoefOrder=3,
use_sindy=True,
sindy_alpha=0.001)
def burgers():
loadnamenpy = 'burgersMC_9601.npy' # PDF - triangles
loadnamenpy = 'burgersMC_6095.npy' # CDF - triangles
loadnamenpy = 'burgersMC_4147.npy' # PDF - gaussians
#loadnamenpy = 'burgersMC_5042.npy' # CDF - gaussians
case = loadnamenpy.split('_')[0]
dataman = DataIO(case)
fu, gridvars, ICparams = dataman.loadSolution(loadnamenpy)
grid = PdfGrid(gridvars)
# Learn
difflearn = PDElearn(grid=grid,
fu=fu,
ICparams=ICparams,
scase=case,
trainratio=0.7,
debug=False,
verbose=True)
difflearn.fit_sparse(feature_opt='1storder',
variableCoef=True,
variableCoefBasis='simple_polynomial',
variableCoefOrder=1,
use_sindy=True,
sindy_alpha=0.01,
shuffle=False)
def advection_reaction():
loadnamenpy = 'advection_reaction_9987.npy' # PDF - gaussians
#loadnamenpy = 'advection_reaction_5739.npy' # PDF - gaussians
case = '_'.join(loadnamenpy.split('_')[:2])
dataman = DataIO(case)
fu, gridvars, ICparams = dataman.loadSolution(loadnamenpy)
# Make fu smaller (in time)
tt = np.linspace(
gridvars['t'][0], gridvars['t'][1],
round((gridvars['t'][1] - gridvars['t'][0]) / gridvars['t'][2]))
period = 6
indexes = np.array([i * period for i in range((len(tt)) // period)])
ttnew = tt[indexes]
fu = fu[:, :, indexes]
gridvars['t'][1] = ttnew[-1]
gridvars['t'][2] = (ttnew[-1] - ttnew[0]) / len(ttnew)
grid = PdfGrid(gridvars)
# Learn
difflearn = PDElearn(grid=grid,
fu=fu,
ICparams=ICparams,
scase=case,
trainratio=0.8,
debug=False,
verbose=True)
difflearn.fit_sparse(feature_opt='1storder',
variableCoef=True,
variableCoefBasis='simple_polynomial',
variableCoefOrder=2,
use_sindy=True,
sindy_alpha=0.005,
shuffle=False)
def reaction():
#loadnamenpy = 'reaction_linear_2204.npy'
#loadnamenpy = 'reaction_linear_6632.npy'
loadnamenpy = 'reaction_linear_5966.npy'
case = '_'.join(loadnamenpy.split('_')[:2])
dataman = DataIO(case)
fu, gridvars, ICparams = dataman.loadSolution(loadnamenpy)
grid = PdfGrid(gridvars)
# Learn
difflearn = PDElearn(grid=grid,
fu=fu,
ICparams=ICparams,
scase=case,
trainratio=0.8,
debug=False,
verbose=True)
difflearn.fit_sparse(feature_opt='1storder',
variableCoef=True,
variableCoefBasis='simple_polynomial',
variableCoefOrder=2,
use_sindy=True,
sindy_alpha=0.1)
def plot(self):
dataman = DataIO(self.case)
fu, gridvars, ICparams = dataman.loadSolution(self.loadnamenpy,
array_opt='marginal')
grid = PdfGrid(gridvars)
V = Visualize(grid)
V.plot_fu3D(fu)
V.plot_fu(fu, dim='t', steps=5)
V.plot_fu(fu, dim='x', steps=5)
V.show()
def learn(self):
dataman = DataIO(self.case)
fu, gridvars, ICparams = dataman.loadSolution(self.loadnamenpy,
array_opt='marginal')
grid = PdfGrid(gridvars)
feature_opt = '1storder'
coeforder = 2
# Learn
difflearn = PDElearn(grid=grid,
fu=fu,
ICparams=ICparams,
scase=self.case,
trainratio=0.8,
debug=False,
verbose=True)
difflearn.fit_sparse(feature_opt=feature_opt, variableCoef=True, variableCoefBasis='simple_polynomial', \
variableCoefOrder=coeforder, use_sindy=True, sindy_alpha=0.001)
def solve(self):
dt = 0.05
t0 = 0
tend = 5
dx = 0.05
x0 = -8.0
xend = 8.0
dk = 0.01
k0 = -6.3
kend = 6.3
du = 0.05
u0 = -6.5
uend = 6.5
sigu0 = 1.1
a = 1.0
b = 0.0
# IC fu(U; x)
mux = 0.5
sigx = 0.7
muU = 0
sigU = 1.2
rho = 0
## Gaussian k
muk = 0.5
sigk = 1.0
fkdist = 'gaussian'
fkparam = [muk, sigk]
## Uniform k
#mink=-0.5
#maxk=0.5
#fkdist = 'uniform'
#fkparam = [mink, maxk]
########
gridvars = {
'u': [u0, uend, du],
'k': [k0, kend, dk],
't': [t0, tend, dt],
'x': [x0, xend, dx]
}
ICparams = {
'fu0': 'compact_gaussian',
'fu0param': [mux, sigx, muU, sigU, rho],
'fk': fkdist,
'fkparam': fkparam
}
grid = PdfGrid(gridvars)
S = PdfSolver(grid, ICparams, save=True, case=self.case)
savename = S.solve_fu() # no need to return anything
print(savename)
return savename
def runsimulation():
dt = 0.03
t0 = 0.0
tend = 4
nt = int((tend - t0) / dt)
dx = 0.03
x0 = -1.5
xend = 1.5
nx = int((xend - x0) / dx)
dk = 0.05
k0 = -1.0
kend = 1.0
nk = int((kend - k0) / dk)
du = 0.04
u0 = -2.5
uend = 2.5
nu = int((uend - u0) / du)
muk = 0.0
sigk = 0.5
sigu = 1.0
mink = -0.5
maxk = 0.5
a = 1.0
b = 0.0
# Second set of data
muk_2 = 0.2
sigk_2 = 1
sigu_2 = 1.1
mink_2 = 0.0
maxk_2 = 1.0
a_2 = 1.0
b_2 = 0.0
runsimulation = 1
IC_opt = 1
solvopt = 'RandomKadvection'
for i in range(1, 5):
print(i)
grid = PdfGrid(x0=x0,
xend=xend,
k0=k0,
kend=kend,
t0=t0,
tend=tend,
u0=u0,
uend=uend,
nx=nx,
nt=nt,
nk=nk,
nu=nu)
grid.printDetails()
S = PdfSolver(grid, save=True)
S.setIC(option=i,
a=a,
b=b,
mink=mink,
maxk=maxk,
muk=muk,
sigk=sigk,
sigu=sigu)
time0 = time.time()
fuk, fu, kmean, uu, kk, xx, tt = S.solve(solver_opt=solvopt)
print('Compute time = ', time.time() - time0)
print(case)
# GET LEARNING DATA
output_vec = []
metadata_vec = []
for i, f in enumerate(files):
D = DataIO(case=case, directory=LEARNDIR)
output, metadata = D.readLearningResults(f)
output_vec.append(output)
metadata_vec.append(metadata)
# GET PDF
dataman = DataIO(case, directory=PDFDIR)
fu0, gridvars, ICparams = dataman.loadSolution(
'advection_reaction_analytical_635_195.npy', array_opt='marginal')
grid0 = PdfGrid(gridvars)
linestyles = ['solid', 'dashed', 'dashdot', 'dotted']
marker = ['o', 'v', 's',
'*'] #, '^', '>', '<', 'x', 'D', '1', '.', '2', '3', '4']
styles = [[l, m] for l in linestyles for m in marker]
## PLOT
A = Analyze()
portion_from_boundary = [
m['ICparams']['adjustgrid']['mu'][0] for m in metadata_vec
]
savename = 'advectreact_boundary_PLOT'
variable = portion_from_boundary
xlabel = 'Distance from $U=0$ (Domain Fraction)'
def runML(setting):
Tinc = 10
Tmin = 0.3
Tmax = 0.9
T = np.linspace(Tmin, Tmax, Tinc)
version = 1
loadname = [makesavename(i, version) for i in IC]
S1 = PdfSolver()
fuk = []
fu = []
kmean = []
gridvars = []
ICparams = []
for i in range(len(IC)):
fuki, fui, kmeani, gridvarsi, ICparamsi = S1.loadSolution(loadname[i])
fuk.append(fuki)
fu.append(fui)
kmean.append(kmeani)
uu, kk, xx, tt = gridvarsi
muk, sigk, mink, maxk, sigu, a, b = ICparamsi
grid = PdfGrid()
grid.setGrid(xx, tt, uu, kk)
grid.printDetails()
if setting == 'sepIC':
options = ['linear', '2ndorder']
for opt in options:
print('#################### %s ########################' % (opt))
DL = []
X = []
y = []
error = []
er = np.zeros((len(IC), 3, len(T)))
for i in range(len(fuk)):
print('---- Initial Condition ----')
print('u0: ' + IC[i]['u0'])
print('fu0: ' + IC[i]['fu0'])
print('fk: ' + IC[i]['fk'])
print('---- ----- ----')
for j in range(len(T)):
print('\n ###### Training %3.2f percent ###### \n ' %
(T[j]))
difflearn = PDElearn(fuk[i],
grid,
kmean[i],
fu=fu[i],
trainratio=T[j],
debug=False)
featurelist, labels, featurenames = difflearn.makeFeatures(
option=opt)
Xtrain, ytrain, Xtest, ytest = difflearn.makeTTsets(
featurelist, labels, shuffle=False)
lin0 = difflearn.train(Xtrain, ytrain, RegType='L0')
lin1 = difflearn.train(Xtrain,
ytrain,
RegType='L1',
RegCoef=0.000001,
maxiter=5000,
tolerance=0.00001)
lin2 = difflearn.train(Xtrain,
ytrain,
RegType='L2',
RegCoef=0.01,
maxiter=5000)
DL = [lin0, lin1, lin2]
for k in range(len(DL)):
# Do it for each initial condition
er[i, k,
j] = mean_squared_error(ytest, DL[k].predict(Xtest))
## Plotting
for l in range(len(DL)):
fig = plt.figure()
leg = []
for i in range(len(IC)):
plt.plot(T, np.reshape(er[i, l, :], (len(T), )))
leg.append(makesavename(IC[i], 1))
plt.xlabel('Training Time Span (\%)')
plt.ylabel('Error')
plt.title('Time Generalization for L%d reg, %s' % (l, opt))
plt.legend(leg)
plt.show()
if setting == 'lumpIC':
#### Lump initial conditions ####
opt = 'linear'
DL = []
er = np.zeros((3, len(T)))
for j in range(len(T)):
print('\n ###### Training %3.2f percent ###### \n ' % (T[j]))
for i in range(len(IC)):
difflearn = PDElearn(fuk[i],
grid,
kmean[i],
fu=fu[i],
trainratio=T[j],
debug=False)
featurelist, labels, featurenames = difflearn.makeFeatures(
option=opt)
Xtrain, ytrain, Xtest, ytest = difflearn.makeTTsets(
featurelist, labels, shuffle=False)
if i == 0:
X_train = Xtrain
y_train = ytrain
X_test = Xtest
y_test = ytest
np.append(X_train, Xtrain, axis=0)
np.append(y_train, ytrain, axis=0)
np.append(X_test, Xtest, axis=0)
np.append(y_test, ytest, axis=0)
lin0 = difflearn.train(X_train, y_train, RegType='L0')
lin1 = difflearn.train(X_train,
y_train,
RegType='L1',
RegCoef=0.00001,
maxiter=5000,
tolerance=0.00001)
lin2 = difflearn.train(X_train,
y_train,
RegType='L2',
RegCoef=0.01,
maxiter=5000)
DL = [lin0, lin1, lin2]
for k in range(len(DL)):
# Do it for each initial condition
er[k, j] = mean_squared_error(y_test, DL[k].predict(X_test))
## Plotting
for l in range(len(DL)):
fig = plt.figure()
figname = 'Time Generalization L%d reg - linear lumped IC' % (l)
plt.plot(T, er[l, :])
plt.xlabel('Training Time Span (\%)')
plt.ylabel('Error')
plt.title(figname)
fig.savefig(figname + '.pdf')
plt.show()
feature_opt = '1storder'
coeforder = 2
sindy_alpha = 0.01
nzthresh = 1e-190
RegCoef = 0.000004
maxiter = 10000
if "savenamepdf" not in locals():
# Check if there is already a loadfile (if not load it)
savenamepdf = 'advection_reaction_analytical_717_944.npy'
dataman = DataIO(case)
fu, gridvars, ICparams = dataman.loadSolution(savenamepdf,
array_opt='marginal')
grid = PdfGrid(gridvars)
fu = grid.adjust(fu, aparams)
if plot:
s = 10
V = Visualize(grid)
V.plot_fu3D(fu)
V.plot_fu(fu, dim='t', steps=s)
V.plot_fu(fu, dim='x', steps=s)
V.show()
difflearn = PDElearn(grid=grid,
fu=fu,
ICparams=ICparams,
scase=case,
trainratio=0.8,
for MCcount in MCcountvec:
print('---------------------')
print('\tMCcount = ', MCcount)
print('---------------------')
# BUILD PDF
MCprocess = MCprocessing(savenameMC, case=case)
savenamepdf = MCprocess.buildKDE(nu, distribution=distribution, MCcount=MCcount, save=save, u_margin=u_margin, bandwidth=bandwidth)
# LEARN
dataman = DataIO(case, directory=PDFDIR)
fu, gridvars, ICparams = dataman.loadSolution(savenamepdf, array_opt='marginal')
adjustgrid = {'mu':mu, 'mx':mx, 'mt':mt, 'pu':pu, 'px':px, 'pt':pt}
grid = PdfGrid(gridvars)
fu = grid.adjust(fu, adjustgrid)
difflearn = PDElearn(grid=grid, fu=fu, ICparams=ICparams, scase=case, trainratio=trainratio, verbose=printlearning)
filename = difflearn.fit_sparse(feature_opt=feature_opt, variableCoef=variableCoef, variableCoefBasis=variableCoefBasis, \
variableCoefOrder=coeforder, use_rfe=use_rfe, rfe_alpha=rfe_alpha, nzthresh=nzthresh, maxiter=maxiter, \
LassoType=LassoType, RegCoef=RegCoef, cv=cv, criterion=criterion, print_rfeiter=print_rfeiter, shuffle=shuffle, \
basefile=savenamepdf, adjustgrid=adjustgrid, save=save, normalize=normalize, comments=comments)
# Save Learning
D = DataIO(case, directory=LEARNDIR)
output, metadata = D.readLearningResults(filename)
output_vec.append(output)
metadata_vec.append(metadata)
filename_vec.append(filename)
def runML(setting):
version = 1
loadname = [makesavename(i, version) for i in IC]
S1 = PdfSolver()
fuk = []
fu = []
kmean = []
gridvars = []
ICparams = []
for i in range(len(IC)):
fuki, fui, kmeani, gridvarsi, ICparamsi = S1.loadSolution(loadname[i])
fuk.append(fuki)
fu.append(fui)
kmean.append(kmeani)
uu, kk, xx, tt = gridvarsi
muk, sigk, mink, maxk, sigu, a, b = ICparamsi
grid = PdfGrid()
grid.setGrid(xx, tt, uu, kk)
grid.printDetails()
lmnum = 40
lmmin = 0.0000001
lmmax = 0.00005
lm = np.linspace(lmmin, lmmax, lmnum)
options = ['linear', '2ndorder']
if setting == 'sepIC':
for opt in options:
# Get number of maximum number of coefficients: maxncoef
difflearn = PDElearn(fuk[0],
grid,
kmean[0],
fu=fu[0],
trainratio=0.8,
debug=False)
featurelist, labels, featurenames = difflearn.makeFeatures(
option=opt)
#pdb.set_trace()
maxncoef = len(featurenames) - 1
print('#################### %s ########################' % (opt))
DL = []
X = []
y = []
error = []
regopts = 2
er = np.zeros((len(IC), regopts, len(lm)))
coef = np.zeros((len(IC), regopts, len(lm), maxncoef))
numcoefl1 = np.zeros((len(IC), len(lm)))
for i in range(len(IC)):
print('---- Initial Condition ----')
print('u0: ' + IC[i]['u0'])
print('fu0: ' + IC[i]['fu0'])
print('fk: ' + IC[i]['fk'])
print('---- ----- ----')
difflearn = PDElearn(fuk[i],
grid,
kmean[i],
fu=fu[i],
trainratio=0.8,
debug=False)
featurelist, labels, featurenames = difflearn.makeFeatures(
option=opt)
Xtrain, ytrain, Xtest, ytest = difflearn.makeTTsets(
featurelist, labels, shuffle=False)
for j in range(len(lm)):
lin1 = difflearn.train(Xtrain,
ytrain,
RegType='L1',
RegCoef=lm[j],
maxiter=5000,
tolerance=0.00001)
lin2 = difflearn.train(Xtrain,
ytrain,
RegType='L2',
RegCoef=lm[j],
maxiter=5000)
DL = [lin1, lin2]
for k in range(len(DL)):
er[i, k,
j] = mean_squared_error(ytest, DL[k].predict(Xtest))
#pdb.set_trace()
for l in range(maxncoef):
coef[i, k, j, l] = DL[k].coef_[l]
numcoefl1[i, j] = DL[0].sparse_coef_.getnnz()
## Plotting
# Error as a function of lm
fig = plt.figure()
leg = []
for i in range(len(IC)):
plt.plot(lm, np.reshape(er[i, 0, :], (len(lm), )))
leg.append(makesavename(IC[i], 1))
figname = setting + ' reg coefficients L%d reg, %s' % (1, opt)
plt.xlabel('Regularization Coefficient')
plt.ylabel('Error')
plt.title(figname)
plt.legend(leg)
plt.savefig(FIGFILE + figname + '.pdf')
# Sparsity as a function of lm
fig = plt.figure()
leg = []
for i in range(len(IC)):
plt.plot(lm, numcoefl1[i])
leg.append(makesavename(IC[i], 1))
figname = setting + ' LinearIC Sparsity in L%d reg, %s' % (1, opt)
plt.xlabel('Regularization Coefficient')
plt.ylabel('Sparsity: Number of Coeffients')
plt.title(figname)
plt.legend(leg)
plt.savefig(FIGFILE + figname + '.pdf')
# All Coefficients values as a function of lm
for j in range(len(IC)):
fig = plt.figure()
leg = []
for i in range(len(featurenames) - 1):
plt.plot(lm, np.reshape(coef[j, 0, :, i], (len(lm), )))
leg.append(featurenames[i + 1])
figname = setting + ' Linear features L%d reg, %s' % (1, opt)
plt.xlabel('Regularization Coefficient')
plt.ylabel('Coefficient Values')
plt.title(figname)
plt.legend(leg)
plt.savefig(FIGFILE + figname)
plt.show()
if setting == 'lumpIC':
for opt in options:
# Get number of maximum number of coefficients: maxncoef
difflearn = PDElearn(fuk[0],
grid,
kmean[0],
fu=fu[0],
trainratio=0.8,
debug=False)
featurelist, labels, featurenames = difflearn.makeFeatures(
option=opt)
#pdb.set_trace()
maxncoef = len(featurenames) - 1
print('#################### %s ########################' % (opt))
DL = []
X = []
y = []
error = []
regopts = 2
er = np.zeros((regopts, len(lm)))
coef = np.zeros((regopts, len(lm), maxncoef))
numcoefl1 = np.zeros((len(lm), ))
for i in range(len(IC)):
difflearn = PDElearn(fuk[i],
grid,
kmean[i],
fu=fu[i],
trainratio=0.8,
debug=False)
featurelist, labels, featurenames = difflearn.makeFeatures(
option=opt)
Xtrain, ytrain, Xtest, ytest = difflearn.makeTTsets(
featurelist, labels, shuffle=False)
if i == 0:
X_train = Xtrain
y_train = ytrain
X_test = Xtest
y_test = ytest
np.append(X_train, Xtrain, axis=0)
np.append(y_train, ytrain, axis=0)
np.append(X_test, Xtest, axis=0)
np.append(y_test, ytest, axis=0)
for j in range(len(lm)):
lin1 = difflearn.train(X_train,
y_train,
RegType='L1',
RegCoef=lm[j],
maxiter=5000,
tolerance=0.00001)
lin2 = difflearn.train(X_train,
y_train,
RegType='L2',
RegCoef=lm[j],
maxiter=5000)
DL = [lin1, lin2]
for k in range(len(DL)):
er[k, j] = mean_squared_error(y_test,
DL[k].predict(X_test))
for l in range(maxncoef):
coef[k, j, l] = DL[k].coef_[l]
numcoefl1[j] = DL[0].sparse_coef_.getnnz()
## Plotting
# Error as a function of lm
fig = plt.figure()
leg = []
plt.plot(lm, er[0, :])
figname = setting + ' reg coefficients L%d reg, %s' % (1, opt)
plt.xlabel('Regularization Coefficient')
plt.ylabel('Error')
plt.title(figname)
plt.savefig(FIGFILE + figname + '.pdf')
# Sparsity as a function of lm
fig = plt.figure()
leg = []
plt.plot(lm, numcoefl1)
figname = setting + ' LinearIC Sparsity in L%d reg, %s' % (1, opt)
plt.xlabel('Regularization Coefficient')
plt.ylabel('Sparsity: Number of Coeffients')
plt.title(figname)
plt.savefig(FIGFILE + figname + '.pdf')
# All Coefficients values as a function of lm
fig = plt.figure()
leg = []
for i in range(len(featurenames) - 1):
plt.plot(lm, np.reshape(coef[0, :, i], (len(lm), )))
leg.append(featurenames[i + 1])
figname = setting + ' LinearIC Linear features L%d reg, %s' % (1,
opt)
plt.xlabel('Regularization Coefficient')
plt.ylabel('Coefficient Values')
plt.title(figname)
plt.legend(leg)
plt.savefig(FIGFILE + figname + '.pdf')
plt.show()
def runML():
loadname1 = 'u0exp_fu0gauss_fkgauss_1'
loadname2 = 'u0lin_fu0gauss_fkgauss_1'
loadname3 = 'u0lin_fu0gauss_fkuni_1'
loadname4 = 'u0exp_fu0gauss_fkuni_1'
loadname = [loadname1, loadname2, loadname3, loadname4]
#loadname1 = 'u0exp_fu0gauss_fkgauss_0'
#loadname2 = 'u0lin_fu0gauss_fkgauss_0'
#loadname3 = 'u0lin_fu0gauss_fkuni_0'
#loadname4 = 'u0exp_fu0gauss_fkuni_0'
#loadname = [loadname1,loadname2,loadname3,loadname4]
S1 = PdfSolver()
fuk = []
fu = []
kmean = []
gridvars = []
ICparams = []
for i in range(4):
fuki, fui, kmeani, gridvarsi, ICparamsi = S1.loadSolution(loadname[i])
fuk.append(fuki)
fu.append(fui)
kmean.append(kmeani)
uu, kk, xx, tt = gridvarsi
muk, sigk, mink, maxk, sigu, a, b = ICparamsi
grid = PdfGrid()
grid.setGrid(xx, tt, uu, kk)
grid.printDetails()
# Train on dataset 1
p = (0, 1, 2, 3)
options = ['all', 'linear', '2ndorder']
for opt in options:
print('#################### %s ########################' % (opt))
DL = []
X = []
y = []
for i in p:
difflearn = PDElearn(fuk[i],
grid,
kmean[i],
fu=fu[i],
trainratio=1,
debug=False)
featurelist, labels, featurenames = difflearn.makeFeatures(
option=opt)
Xtrain, ytrain, Xtest, ytest = difflearn.makeTTsets(featurelist,
labels,
shuffle=False)
X.append(Xtrain)
y.append(ytrain)
DL.append(difflearn)
for ti in range(4):
print('\n ###### Training on i = %d ###### \n ' % (ti))
lin1 = DL[ti].train(X[ti],
y[ti],
RegType='L1',
RegCoef=0.000001,
maxiter=5000,
tolerance=0.00001)
lin2 = DL[ti].train(X[ti],
y[ti],
RegType='L2',
RegCoef=0.01,
maxiter=5000)
lin0 = DL[ti].train(X[ti], y[ti], RegType='L0')
for i in range(4):
print('---- %d ----' % (i))
print(loadname[i])
print("L1 Reg Test Score = %5.3f | RMS = %7.5f" % (lin1.score(
X[i], y[i]), mean_squared_error(y[i], lin1.predict(X[i]))))
print("L2 Reg Test Score = %5.3f | RMS = %7.5f" % (lin2.score(
X[i], y[i]), mean_squared_error(y[i], lin2.predict(X[i]))))
print("L0 Reg Test Score = %5.3f | RMS = %7.5f" % (lin0.score(
X[i], y[i]), mean_squared_error(y[i], lin0.predict(X[i]))))
for term, val in fudict.items():
if term != 't':
featurenames.append('fu_' + term)
featurelist.append(val)
else:
raise Exception("wrong option")
return featurelist, labels, featurenames
if __name__ == "__main__":
# LEARN
if len(sys.argv) > 1:
basefile = sys.argv[1] + '.npy'
else:
basefile = 'advection_reaction_analytical_726_291.npy'
case = '_'.join(basefile.split('_')[:-2])
dataman = DataIO(case, directory=PDFDIR)
fu, gridvars, ICparams = dataman.loadSolution(basefile,
array_opt='marginal')
grid = PdfGrid(gridvars)
difflearn = PDElearn(grid=grid, fu=fu, ICparams=ICparams, scase=case)
filename = difflearn.fit_sparse(basefile=basefile)
print(filename)
fuk = []
fu = []
kmean = []
gridvars = []
ICparams = []
for i in range(len(IC)):
fuki, fui, kmeani, gridvarsi, ICparamsi = S1.loadSolution(loadname[i])
fuk.append(fuki)
fu.append(fui)
kmean.append(kmeani)
uu, kk, xx, tt = gridvarsi
muk, sigk, mink, maxk, sigu, a, b = ICparamsi
grid = PdfGrid()
grid.setGrid(xx, tt, uu, kk)
grid.printDetails()
lmnum = 40
lmmin = 0.0000001
lmmax = 0.00003
lm = np.linspace(lmmin, lmmax, lmnum)
options = ['linear', '2ndorder']
error = []
cf = []
fn = []
for opt in options:
# Get number of maximum number of coefficients: maxncoef
