def makeFeatures_Conservative(self, grid, fu, ICparams): nt = len(grid.tt) nx = len(grid.xx) nu = len(grid.uu) dx = grid.xx[1] - grid.xx[0] dt = grid.tt[1] - grid.tt[0] du = grid.uu[1] - grid.uu[0] ddict = {'', 't', 'x', 'xx', 'xxx', 'U', 'UU', 'xU', 'xUU', 'xxU'} # Derivative terms dictionary # Computationally inefficient (fix: use previous derivatives) dimaxis = {'U': 0, 'x': 1, 't': 2} diminc = {'U': du, 'x': dx, 't': dt} maxder = {'U': 0, 'x': 0, 't': 0} fudict = dict.fromkeys(ddict, None) # fu dictionary of derivatives dcount = dict.fromkeys(ddict, None) # Counts of derivatives for each term for term in ddict: dfu = fu.copy() # copy? md = {'U': 0, 'x': 0, 't': 0} if len(term) > 0: for dim in term: dfu = np.diff(dfu, axis=dimaxis[dim]) / diminc[dim] md[dim] += 1 dcount[term] = md fudict[term] = dfu for dim in term: maxder[dim] = md[dim] if md[dim] > maxder[dim] else maxder[dim] # Adjust dimensions to match mu = maxder['U'] mx = maxder['x'] mt = maxder['t'] for term in fudict: uc = mu - dcount[term]['U'] xc = mx - dcount[term]['x'] tc = mt - dcount[term]['t'] nu = fudict[term].shape[0] nx = fudict[term].shape[1] nt = fudict[term].shape[2] fudict[term] = fudict[term][uc // 2:nu - uc // 2 - uc % 2, xc // 2:nx - xc // 2 - xc % 2, tc // 2:nt - tc // 2 - tc % 2] xx_adj = grid.xx[mx // 2:len(grid.xx) - mx // 2 - mx % 2] uu_adj = grid.uu[mu // 2:len(grid.uu) - mu // 2 - mu % 2] # make labels and feature lists featurenames = [] featurelist = [] # Add feature of ones fudict['1'] = np.ones_like(fudict['t']) ddict.add('1') # Add variable coefficients deg = self.variableCoefOrder + 1 if self.variableCoef: print("Variable coefficient type: " + self.variableCoefBasis) uu_grid, xx_grid = np.meshgrid(uu_adj, xx_adj, indexing='ij') fudict_var = dict.fromkeys([(term, j, k) for term in ddict for j in range(deg) for k in range(deg)]) for term in ddict: for i in range(deg): for j in range(deg): f*x = np.zeros_like(uu_grid) for k, u in enumerate(uu_adj): for l, x in enumerate(xx_adj): if self.variableCoefBasis == 'chebyshev': # too inefficient (find a way to get individual terms) ivec = np.zeros(i + 1) ivec[-1] = 1 jvec = np.zeros(j + 1) jvec[-1] = 1 f*x[k, l] = chebval(u, ivec) * chebval( x, jvec) elif self.variableCoefBasis == 'simple_polynomial': f*x[k, l] = u**i * x**j else: raise Exception( "variableCoefBasis %s doesn't exist". format(self.variableCoefBasis)) fudict_var[(term, i, j)] = f*x # nu*nx for feat, coefarr in fudict_var.items(): # feat = (term, i, j) fux_t = np.tile(coefarr.transpose(), (nt - mt, 1, 1)).transpose() fudict_var[feat] = np.multiply(fudict[feat[0]], fux_t) # Too redundant - fix if self.option == '2ndorder': labels = fudict_var[('tt', 0, 0)] for key, val in fudict_var.items(): if key[0] != 'tt' and key[0] != 't': featurenames.append('fu_' + key[0] + '^{' + str(key[1]) + str(key[2]) + '}') featurelist.append(val) elif self.option == '1storder' or self.option == 'conservative': labels = fudict_var[('t', 0, 0)] for key, val in fudict_var.items(): if key[0] != 't': featurenames.append('fu_' + key[0] + '^{' + str(key[1]) + str(key[2]) + '}') featurelist.append(val) elif self.option == '1storder_close': S = PdfSolver(grid, ICparams=ICparams) print(S.int_kmean) labels = fudict_var[('t', 0, 0)] + S.int_kmean() * fudict_var[ ('x', 0, 0)] for key, val in fudict_var.items(): if key[0] != 't' and key != ('x', 0, 0): featurenames.append('fu_' + key[0] + '^{' + str(key[1]) + str(key[2]) + '}') featurelist.append(val) else: raise Exception("wrong option") else: # Not variable coefficient if self.option == '2ndorder': labels = fudict['tt'] for term, val in fudict.items(): if term != 'tt' and term != 't': featurenames.append('fu_' + term) featurelist.append(val) elif self.option == '1storder': labels = fudict['t'] for term, val in fudict.items(): if term != 't': featurenames.append('fu_' + term) featurelist.append(val) elif self.option == '1storder_close': S = PdfSolver(grid, ICparams=ICparams) labels = fudict['t'] + S.int_kmean() * fudict['x'] 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
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)
def makeFeatures_uxt(self, grid, fu, ICparams): nt = len(grid.tt) nx = len(grid.xx) nu = len(grid.uu) dx = grid.xx[1] - grid.xx[0] dt = grid.tt[1] - grid.tt[0] du = grid.uu[1] - grid.uu[0] if self.option == '2ndorder': ddict = { '', 't', 'tt', 'xt', 'x', 'xx', 'xxx', 'xxxx', 'U', 'UU', 'UUU', 'xU', 'xUU', 'xxU', 'xxUU' } elif self.option == '1storder' or self.option == '1storder_close': ddict = {'', 't', 'x', 'xx', 'xxx', 'U', 'UU', 'xU', 'xUU', 'xxU'} elif self.option == 'conservative': ddict = { '', 't', 'U', 'Ux', 'Uxx', 'Uxxx', 'UU', 'UUx', 'UUxx', 'UUU', 'UUUx' } else: raise Exception('option not valid') # Derivative terms dictionary # Computationally inefficient (fix: use previous derivatives) dimaxis = {'U': 0, 'x': 1, 't': 2} diminc = {'U': du, 'x': dx, 't': dt} maxder = {'U': 0, 'x': 0, 't': 0} fudict = dict.fromkeys(ddict, None) # fu dictionary of derivatives dcount = dict.fromkeys(ddict, None) # Counts of derivatives for each term for term in ddict: dfu = fu.copy() # copy? md = {'U': 0, 'x': 0, 't': 0} if len(term) > 0: for dim in term: dfu = np.diff(dfu, axis=dimaxis[dim]) / diminc[dim] md[dim] += 1 dcount[term] = md fudict[term] = dfu for dim in term: maxder[dim] = md[dim] if md[dim] > maxder[dim] else maxder[dim] # Adjust dimensions to match mu = maxder['U'] mx = maxder['x'] mt = maxder['t'] for term in fudict: uc = mu - dcount[term]['U'] xc = mx - dcount[term]['x'] tc = mt - dcount[term]['t'] nu = fudict[term].shape[0] nx = fudict[term].shape[1] nt = fudict[term].shape[2] fudict[term] = fudict[term][uc // 2:nu - uc // 2 - uc % 2, xc // 2:nx - xc // 2 - xc % 2, tc // 2:nt - tc // 2 - tc % 2] xx_adj = grid.xx[mx // 2:len(grid.xx) - mx // 2 - mx % 2] uu_adj = grid.uu[mu // 2:len(grid.uu) - mu // 2 - mu % 2] # make labels and feature lists featurenames = [] featurelist = [] # Add feature of ones fudict['1'] = np.ones_like(fudict['t']) ddict.add('1') # Add variable coefficients deg = self.variableCoefOrder + 1 if self.variableCoef: print("Variable coefficient type: " + self.variableCoefBasis) uu_grid, xx_grid = np.meshgrid(uu_adj, xx_adj, indexing='ij') fudict_var = dict.fromkeys([(term, j, k) for term in ddict for j in range(deg) for k in range(deg)]) for term in ddict: for i in range(deg): for j in range(deg): f*x = np.zeros_like(uu_grid) for k, u in enumerate(uu_adj): for l, x in enumerate(xx_adj): if self.variableCoefBasis == 'chebyshev': # too inefficient (find a way to get individual terms) ivec = np.zeros(i + 1) ivec[-1] = 1 jvec = np.zeros(j + 1) jvec[-1] = 1 f*x[k, l] = chebval(u, ivec) * chebval( x, jvec) elif self.variableCoefBasis == 'simple_polynomial': f*x[k, l] = u**i * x**j else: raise Exception( "variableCoefBasis %s doesn't exist". format(self.variableCoefBasis)) fudict_var[(term, i, j)] = f*x # nu*nx for feat, coefarr in fudict_var.items(): # feat = (term, i, j) fux_t = np.tile(coefarr.transpose(), (nt - mt, 1, 1)).transpose() fudict_var[feat] = np.multiply(fudict[feat[0]], fux_t) # Too redundant - fix if self.option == '2ndorder': labels = fudict_var[('tt', 0, 0)] for key, val in fudict_var.items(): if key[0] != 'tt' and key[0] != 't': featurenames.append('fu_' + key[0] + '^{' + str(key[1]) + str(key[2]) + '}') featurelist.append(val) elif self.option == '1storder' or self.option == 'conservative': labels = fudict_var[('t', 0, 0)] for key, val in fudict_var.items(): if key[0] != 't': featurenames.append('fu_' + key[0] + '^{' + str(key[1]) + str(key[2]) + '}') featurelist.append(val) elif self.option == '1storder_close': # TODO: Make loadMetadata(filename, directory) into function mcD = DataIO(self.scase, directory=MCDIR) with open(mcD.casedir + 'metadata.txt', 'r') as jsonfile: allmc_metadata = json.load(jsonfile) mc_metadata = allmc_metadata[ICparams['MCfile'].split('.') [0]] if self.scase == 'advection_reaction_randadv_analytical': k_coeffs = mc_metadata['ICparams']['distparams'][0] # TODO: add 'distk' for ICparams and find mean based on it instead if mc_metadata['ICparams']['fu0'] == 'gaussians_k': kmean = k_coeffs[0] print('kmean = ', kmean) if mc_metadata['ICparams']['source'] == 'quadratic': labels = fudict_var[('t', 0, 0)] + kmean * fudict_var[ ('x', 0, 0)] + fudict_var[ ('U', 2, 0)] + 2 * fudict_var[('', 1, 0)] removekeys = {('t', 0, 0), ('x', 0, 0), ('U', 2, 0), ('', 1, 0)} elif mc_metadata['ICparams']['source'] == 'linear': labels = fudict_var[('t', 0, 0)] + kmean * fudict_var[ ('x', 0, 0)] + fudict_var[ ('U', 1, 0)] + fudict_var[('', 0, 0)] removekeys = {('t', 0, 0), ('x', 0, 0), ('U', 1, 0), ('', 0, 0)} elif mc_metadata['ICparams']['source'] == 'logistic': ## TODO: Assumes kr = K = 1.0 labels = fudict_var[('t', 0, 0)] + kmean * fudict_var[('x', 0, 0)] \ + fudict_var[('U', 1, 0)] - fudict_var[('U', 2, 0)] + fudict_var[('', 0, 0)] - 2*fudict_var[('', 1, 0)] removekeys = {('t', 0, 0), ('x', 0, 0), ('U', 2, 0), ('U', 1, 0), ('', 1, 0), ('', 0, 0)} ## TODO: Try removing terms that appear in closure for key, val in fudict_var.items(): if key[0] != 't' and key not in removekeys: featurenames.append('fu_' + key[0] + '^{' + str(key[1]) + str(key[2]) + '}') featurelist.append(val) else: raise Exception("wrong option") else: # Not variable coefficient if self.option == '2ndorder': labels = fudict['tt'] for term, val in fudict.items(): if term != 'tt' and term != 't': featurenames.append('fu_' + term) featurelist.append(val) elif self.option == '1storder': labels = fudict['t'] for term, val in fudict.items(): if term != 't': featurenames.append('fu_' + term) featurelist.append(val) elif self.option == '1storder_close': S = PdfSolver(grid, ICparams=ICparams) labels = fudict['t'] + S.int_kmean() * fudict['x'] 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
for k0, kend in k_range: for u0, uend in u_range: for x0, xend in x_range: for u0typei in u0type: for sigu0i in sigu0: for ai, bi in zip(a, b): for k_disti in k_dist: if k_disti == 'gaussian': kparam1, kparam2 = muk, sigk elif k_disti == 'uniform': kparam1, kparam2 = mink, maxk else: print("wrong k distribution option") for kparam1i, kparam2i in zip(kparam1, kparam2): gridvars = {'u': [u0, uend, du], 'k': [k0, kend, dk], 't': [t_range[0], t_range[1], dt], 'x':[x0, xend, dx]} ICparams = {'u0': u0typei, 'u0param': [ai, bi], 'fu0': 'gaussian', 'fu0param': sigu0i, 'fk': k_disti, 'fkparam': [kparam1i, kparam2i]} grid = PdfGrid(gridvars) S = PdfSolver(grid, ICparams, save=True, case=case) S.solve()
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()
import time import pdb from __init__ import * IC1 = {'u0': 'exp', 'fu0': 'gauss', 'fk': 'uni'} IC2 = {'u0': 'lin', 'fu0': 'gauss', 'fk': 'uni'} IC3 = {'u0': 'lin', 'fu0': 'gauss', 'fk': 'gauss'} IC4 = {'u0': 'exp', 'fu0': 'gauss', 'fk': 'gauss'} #IC = [IC1, IC2, IC3, IC4] IC = [IC2, IC3] # Line IC #IC = [IC1, IC4] # Exponential IC 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
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]))))
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': 'uniform', 'fkparam': [mink, maxk] } grid = PdfGrid(gridvars) S = PdfSolver(grid, ICparams, save=True, case=case) S.solve() # no need to return anything def reaction(): case = 'reaction_linear' dt = 0.01 t0 = 0 tend = 5 du = 0.005 u0 = -7 uend = 7 umean = 0.2
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()
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