def reduce_greedy(fom, reductor, snapshots_per_block, extension_alg_name, max_extensions, use_estimator, pool): from pymor.algorithms.greedy import rb_greedy # run greedy training_set = fom.parameter_space.sample_uniformly(snapshots_per_block) greedy_data = rb_greedy(fom, reductor, training_set, use_estimator=use_estimator, error_norm=fom.h1_0_semi_norm, extension_params={'method': extension_alg_name}, max_extensions=max_extensions, pool=pool) rom = greedy_data['rom'] # generate summary real_rb_size = rom.solution_space.dim training_set_size = len(training_set) summary = f'''Greedy basis generation: size of training set: {training_set_size} error estimator used: {use_estimator} extension method: {extension_alg_name} prescribed basis size: {max_extensions} actual basis size: {real_rb_size} elapsed time: {greedy_data["time"]} ''' return rom, summary
def _first(self): product = self.m.h1_0_semi_product if self.product == 'h1' else None reductor = CoerciveRBReductor(self.m, product=product) greedy_data = rb_greedy(self.m, reductor, self.problem.parameter_space.sample_uniformly( self.snapshots), use_error_estimator=True, error_norm=self.m.h1_0_semi_norm, max_extensions=self.rbsize) self.rom, self.reductor = greedy_data['rom'], reductor self.first = False
def _first(self): args = self.args product = self.m.h1_0_semi_product if args[ '--product'] == 'h1' else None reductor = CoerciveRBReductor(self.m, product=product) greedy_data = rb_greedy(self.m, reductor, self.m.parameter_space.sample_uniformly( args['SNAPSHOTS']), use_estimator=True, error_norm=self.m.h1_0_semi_norm, max_extensions=args['RBSIZE']) self.rom, self.reductor = greedy_data['rom'], reductor self.first = False
def main( exp_min: float = Argument(..., help='Minimal exponent'), exp_max: float = Argument(..., help='Maximal exponent'), ei_snapshots: int = Argument( ..., help='Number of snapshots for empirical interpolation.'), ei_size: int = Argument(..., help='Number of interpolation DOFs.'), snapshots: int = Argument( ..., help='Number of snapshots for basis generation.'), rb_size: int = Argument(..., help='Size of the reduced basis.'), cache_region: Choices('none memory disk persistent') = Option( 'disk', help='Name of cache region to use for caching solution snapshots.' ), ei_alg: Choices('ei_greedy deim') = Option( 'ei_greedy', help='Interpolation algorithm to use.'), grid: int = Option(60, help='Use grid with (2*NI)*NI elements.'), grid_type: Choices('rect tria') = Option('rect', help='Type of grid to use.'), initial_data: Choices('sin bump') = Option( 'sin', help='Select the initial data (sin, bump).'), ipython_engines: int = Option( 0, help= 'If positive, the number of IPython cluster engines to use for parallel greedy search. ' 'If zero, no parallelization is performed.'), ipython_profile: str = Option( None, help='IPython profile to use for parallelization.'), lxf_lambda: float = Option( 1., help='Parameter lambda in Lax-Friedrichs flux.'), periodic: bool = Option( True, help ='If not, solve with dirichlet boundary conditions on left and bottom boundary.' ), nt: int = Option(100, help='Number of time steps.'), num_flux: Choices('lax_friedrichs engquist_osher') = Option( 'engquist_osher', help='Numerical flux to use.'), plot_err: bool = Option(False, help='Plot error.'), plot_ei_err: bool = Option(False, help='Plot empirical interpolation error.'), plot_error_landscape: bool = Option( False, help='Calculate and show plot of reduction error vs. basis sizes.' ), plot_error_landscape_M: int = Option( 10, help='Number of collateral basis sizes to test.'), plot_error_landscape_N: int = Option( 10, help='Number of basis sizes to test.'), plot_solutions: bool = Option(False, help='Plot some example solutions.'), test: int = Option( 10, help='Number of snapshots to use for stochastic error estimation.' ), vx: float = Option(1., help='Speed in x-direction.'), vy: float = Option(1., help='Speed in y-direction.'), ): """Model order reduction of a two-dimensional Burgers-type equation (see pymor.analyticalproblems.burgers) using the reduced basis method with empirical operator interpolation. """ print('Setup Problem ...') problem = burgers_problem_2d(vx=vx, vy=vy, initial_data_type=initial_data.value, parameter_range=(exp_min, exp_max), torus=periodic) print('Discretize ...') if grid_type == 'rect': grid *= 1. / math.sqrt(2) fom, _ = discretize_instationary_fv( problem, diameter=1. / grid, grid_type=RectGrid if grid_type == 'rect' else TriaGrid, num_flux=num_flux.value, lxf_lambda=lxf_lambda, nt=nt) if cache_region != 'none': # building a cache_id is only needed for persistent CacheRegions cache_id = ( f"pymordemos.burgers_ei {vx} {vy} {initial_data}" f"{periodic} {grid} {grid_type} {num_flux} {lxf_lambda} {nt}") fom.enable_caching(cache_region.value, cache_id) print(fom.operator.grid) print(f'The parameters are {fom.parameters}') if plot_solutions: print('Showing some solutions') Us = () legend = () for mu in problem.parameter_space.sample_uniformly(4): print(f"Solving for exponent = {mu['exponent']} ... ") sys.stdout.flush() Us = Us + (fom.solve(mu), ) legend = legend + (f"exponent: {mu['exponent']}", ) fom.visualize(Us, legend=legend, title='Detailed Solutions', block=True) pool = new_parallel_pool(ipython_num_engines=ipython_engines, ipython_profile=ipython_profile) eim, ei_data = interpolate_operators( fom, ['operator'], problem.parameter_space.sample_uniformly(ei_snapshots), error_norm=fom.l2_norm, product=fom.l2_product, max_interpolation_dofs=ei_size, alg=ei_alg.value, pool=pool) if plot_ei_err: print('Showing some EI errors') ERRs = () legend = () for mu in problem.parameter_space.sample_randomly(2): print(f"Solving for exponent = \n{mu['exponent']} ... ") sys.stdout.flush() U = fom.solve(mu) U_EI = eim.solve(mu) ERR = U - U_EI ERRs = ERRs + (ERR, ) legend = legend + (f"exponent: {mu['exponent']}", ) print(f'Error: {np.max(fom.l2_norm(ERR))}') fom.visualize(ERRs, legend=legend, title='EI Errors', separate_colorbars=True) print('Showing interpolation DOFs ...') U = np.zeros(U.dim) dofs = eim.operator.interpolation_dofs U[dofs] = np.arange(1, len(dofs) + 1) U[eim.operator.source_dofs] += int(len(dofs) / 2) fom.visualize(fom.solution_space.make_array(U), title='Interpolation DOFs') print('RB generation ...') reductor = InstationaryRBReductor(eim) greedy_data = rb_greedy( fom, reductor, problem.parameter_space.sample_uniformly(snapshots), use_error_estimator=False, error_norm=lambda U: np.max(fom.l2_norm(U)), extension_params={'method': 'pod'}, max_extensions=rb_size, pool=pool) rom = greedy_data['rom'] print('\nSearching for maximum error on random snapshots ...') tic = time.perf_counter() mus = problem.parameter_space.sample_randomly(test) def error_analysis(N, M): print(f'N = {N}, M = {M}: ', end='') rom = reductor.reduce(N) rom = rom.with_(operator=rom.operator.with_cb_dim(M)) l2_err_max = -1 mumax = None for mu in mus: print('.', end='') sys.stdout.flush() u = rom.solve(mu) URB = reductor.reconstruct(u) U = fom.solve(mu) l2_err = np.max(fom.l2_norm(U - URB)) l2_err = np.inf if not np.isfinite(l2_err) else l2_err if l2_err > l2_err_max: l2_err_max = l2_err mumax = mu print() return l2_err_max, mumax error_analysis = np.frompyfunc(error_analysis, 2, 2) real_rb_size = len(reductor.bases['RB']) real_cb_size = len(ei_data['basis']) if plot_error_landscape: N_count = min(real_rb_size - 1, plot_error_landscape_N) M_count = min(real_cb_size - 1, plot_error_landscape_M) Ns = np.linspace(1, real_rb_size, N_count).astype(np.int) Ms = np.linspace(1, real_cb_size, M_count).astype(np.int) else: Ns = np.array([real_rb_size]) Ms = np.array([real_cb_size]) N_grid, M_grid = np.meshgrid(Ns, Ms) errs, err_mus = error_analysis(N_grid, M_grid) errs = errs.astype(np.float) l2_err_max = errs[-1, -1] mumax = err_mus[-1, -1] toc = time.perf_counter() t_est = toc - tic print(''' *** RESULTS *** Problem: parameter range: ({exp_min}, {exp_max}) h: sqrt(2)/{grid} grid-type: {grid_type} initial-data: {initial_data} lxf-lambda: {lxf_lambda} nt: {nt} not-periodic: {periodic} num-flux: {num_flux} (vx, vy): ({vx}, {vy}) Greedy basis generation: number of ei-snapshots: {ei_snapshots} prescribed collateral basis size: {ei_size} actual collateral basis size: {real_cb_size} number of snapshots: {snapshots} prescribed basis size: {rb_size} actual basis size: {real_rb_size} elapsed time: {greedy_data[time]} Stochastic error estimation: number of samples: {test} maximal L2-error: {l2_err_max} (mu = {mumax}) elapsed time: {t_est} '''.format(**locals())) sys.stdout.flush() if plot_error_landscape: import matplotlib.pyplot as plt import mpl_toolkits.mplot3d # NOQA fig = plt.figure() ax = fig.add_subplot(111, projection='3d') # rescale the errors since matplotlib does not support logarithmic scales on 3d plots # https://github.com/matplotlib/matplotlib/issues/209 surf = ax.plot_surface(M_grid, N_grid, np.log(np.minimum(errs, 1)) / np.log(10), rstride=1, cstride=1, cmap='jet') plt.show() if plot_err: U = fom.solve(mumax) URB = reductor.reconstruct(rom.solve(mumax)) fom.visualize( (U, URB, U - URB), legend=('Detailed Solution', 'Reduced Solution', 'Error'), title='Maximum Error Solution', separate_colorbars=True) global test_results test_results = (ei_data, greedy_data)
def main(grid_intervals: int = Argument(..., help='Grid interval count.'), training_samples: int = Argument( ..., help='Number of samples used for training the reduced basis.')): """Example script for solving linear PDE-constrained parameter optimization problems""" fom, mu_bar = create_fom(grid_intervals) parameter_space = fom.parameters.space(0, np.pi) ranges = parameter_space.ranges['diffusion'] initial_guess = fom.parameters.parse([0.25, 0.5]) def fom_objective_functional(mu): return fom.output(mu) def fom_gradient_of_functional(mu): return fom.output_d_mu(fom.parameters.parse(mu), return_array=True, use_adjoint=True) from functools import partial from scipy.optimize import minimize from time import perf_counter opt_fom_minimization_data = { 'num_evals': 0, 'evaluations': [], 'evaluation_points': [], 'time': np.inf } tic = perf_counter() opt_fom_result = minimize(partial(record_results, fom_objective_functional, fom.parameters.parse, opt_fom_minimization_data), initial_guess.to_numpy(), method='L-BFGS-B', jac=fom_gradient_of_functional, bounds=(ranges, ranges), options={'ftol': 1e-15}) opt_fom_minimization_data['time'] = perf_counter() - tic reference_mu = opt_fom_result.x from pymor.algorithms.greedy import rb_greedy from pymor.reductors.coercive import CoerciveRBReductor from pymor.parameters.functionals import MinThetaParameterFunctional coercivity_estimator = MinThetaParameterFunctional( fom.operator.coefficients, mu_bar) training_set = parameter_space.sample_uniformly(training_samples) training_set_simple = [mu['diffusion'] for mu in training_set] RB_reductor = CoerciveRBReductor(fom, product=fom.energy_product, coercivity_estimator=coercivity_estimator) RB_greedy_data = rb_greedy(fom, RB_reductor, training_set, atol=1e-2) rom = RB_greedy_data['rom'] def rom_objective_functional(mu): return rom.output(mu) def rom_gradient_of_functional(mu): return rom.output_d_mu(fom.parameters.parse(mu), return_array=True, use_adjoint=True) opt_rom_minimization_data = { 'num_evals': 0, 'evaluations': [], 'evaluation_points': [], 'time': np.inf, 'offline_time': RB_greedy_data['time'] } tic = perf_counter() opt_rom_result = minimize(partial(record_results, rom_objective_functional, fom.parameters.parse, opt_rom_minimization_data), initial_guess.to_numpy(), method='L-BFGS-B', jac=rom_gradient_of_functional, bounds=(ranges, ranges), options={'ftol': 1e-15}) opt_rom_minimization_data['time'] = perf_counter() - tic print("\nResult of optimization with FOM model and adjoint gradient") report(opt_fom_result, fom.parameters.parse, opt_fom_minimization_data, reference_mu) print("Result of optimization with ROM model and adjoint gradient") report(opt_rom_result, fom.parameters.parse, opt_rom_minimization_data, reference_mu)
def main(args): args = docopt(__doc__, args) args['--cache-region'] = args['--cache-region'].lower() args['--ei-alg'] = args['--ei-alg'].lower() assert args['--ei-alg'] in ('ei_greedy', 'deim') args['--grid'] = int(args['--grid']) args['--grid-type'] = args['--grid-type'].lower() assert args['--grid-type'] in ('rect', 'tria') args['--initial-data'] = args['--initial-data'].lower() assert args['--initial-data'] in ('sin', 'bump') args['--lxf-lambda'] = float(args['--lxf-lambda']) args['--nt'] = int(args['--nt']) args['--not-periodic'] = bool(args['--not-periodic']) args['--num-flux'] = args['--num-flux'].lower() assert args['--num-flux'] in ('lax_friedrichs', 'engquist_osher') args['--plot-error-landscape-N'] = int(args['--plot-error-landscape-N']) args['--plot-error-landscape-M'] = int(args['--plot-error-landscape-M']) args['--test'] = int(args['--test']) args['--vx'] = float(args['--vx']) args['--vy'] = float(args['--vy']) args['--ipython-engines'] = int(args['--ipython-engines']) args['EXP_MIN'] = int(args['EXP_MIN']) args['EXP_MAX'] = int(args['EXP_MAX']) args['EI_SNAPSHOTS'] = int(args['EI_SNAPSHOTS']) args['EISIZE'] = int(args['EISIZE']) args['SNAPSHOTS'] = int(args['SNAPSHOTS']) args['RBSIZE'] = int(args['RBSIZE']) print('Setup Problem ...') problem = burgers_problem_2d(vx=args['--vx'], vy=args['--vy'], initial_data_type=args['--initial-data'], parameter_range=(args['EXP_MIN'], args['EXP_MAX']), torus=not args['--not-periodic']) print('Discretize ...') if args['--grid-type'] == 'rect': args['--grid'] *= 1. / math.sqrt(2) fom, _ = discretize_instationary_fv( problem, diameter=1. / args['--grid'], grid_type=RectGrid if args['--grid-type'] == 'rect' else TriaGrid, num_flux=args['--num-flux'], lxf_lambda=args['--lxf-lambda'], nt=args['--nt']) if args['--cache-region'] != 'none': fom.enable_caching(args['--cache-region']) print(fom.operator.grid) print(f'The parameter type is {fom.parameter_type}') if args['--plot-solutions']: print('Showing some solutions') Us = () legend = () for mu in fom.parameter_space.sample_uniformly(4): print(f"Solving for exponent = {mu['exponent']} ... ") sys.stdout.flush() Us = Us + (fom.solve(mu), ) legend = legend + (f"exponent: {mu['exponent']}", ) fom.visualize(Us, legend=legend, title='Detailed Solutions', block=True) pool = new_parallel_pool(ipython_num_engines=args['--ipython-engines'], ipython_profile=args['--ipython-profile']) eim, ei_data = interpolate_operators( fom, ['operator'], fom.parameter_space.sample_uniformly(args['EI_SNAPSHOTS']), # NOQA error_norm=fom.l2_norm, product=fom.l2_product, max_interpolation_dofs=args['EISIZE'], alg=args['--ei-alg'], pool=pool) if args['--plot-ei-err']: print('Showing some EI errors') ERRs = () legend = () for mu in fom.parameter_space.sample_randomly(2): print(f"Solving for exponent = \n{mu['exponent']} ... ") sys.stdout.flush() U = fom.solve(mu) U_EI = eim.solve(mu) ERR = U - U_EI ERRs = ERRs + (ERR, ) legend = legend + (f"exponent: {mu['exponent']}", ) print(f'Error: {np.max(fom.l2_norm(ERR))}') fom.visualize(ERRs, legend=legend, title='EI Errors', separate_colorbars=True) print('Showing interpolation DOFs ...') U = np.zeros(U.dim) dofs = eim.operator.interpolation_dofs U[dofs] = np.arange(1, len(dofs) + 1) U[eim.operator.source_dofs] += int(len(dofs) / 2) fom.visualize(fom.solution_space.make_array(U), title='Interpolation DOFs') print('RB generation ...') reductor = InstationaryRBReductor(eim) greedy_data = rb_greedy(fom, reductor, fom.parameter_space.sample_uniformly( args['SNAPSHOTS']), use_estimator=False, error_norm=lambda U: np.max(fom.l2_norm(U)), extension_params={'method': 'pod'}, max_extensions=args['RBSIZE'], pool=pool) rom = greedy_data['rom'] print('\nSearching for maximum error on random snapshots ...') tic = time.time() mus = fom.parameter_space.sample_randomly(args['--test']) def error_analysis(N, M): print(f'N = {N}, M = {M}: ', end='') rom = reductor.reduce(N) rom = rom.with_(operator=rom.operator.with_cb_dim(M)) l2_err_max = -1 mumax = None for mu in mus: print('.', end='') sys.stdout.flush() u = rom.solve(mu) URB = reductor.reconstruct(u) U = fom.solve(mu) l2_err = np.max(fom.l2_norm(U - URB)) l2_err = np.inf if not np.isfinite(l2_err) else l2_err if l2_err > l2_err_max: l2_err_max = l2_err mumax = mu print() return l2_err_max, mumax error_analysis = np.frompyfunc(error_analysis, 2, 2) real_rb_size = len(reductor.bases['RB']) real_cb_size = len(ei_data['basis']) if args['--plot-error-landscape']: N_count = min(real_rb_size - 1, args['--plot-error-landscape-N']) M_count = min(real_cb_size - 1, args['--plot-error-landscape-M']) Ns = np.linspace(1, real_rb_size, N_count).astype(np.int) Ms = np.linspace(1, real_cb_size, M_count).astype(np.int) else: Ns = np.array([real_rb_size]) Ms = np.array([real_cb_size]) N_grid, M_grid = np.meshgrid(Ns, Ms) errs, err_mus = error_analysis(N_grid, M_grid) errs = errs.astype(np.float) l2_err_max = errs[-1, -1] mumax = err_mus[-1, -1] toc = time.time() t_est = toc - tic print(''' *** RESULTS *** Problem: parameter range: ({args[EXP_MIN]}, {args[EXP_MAX]}) h: sqrt(2)/{args[--grid]} grid-type: {args[--grid-type]} initial-data: {args[--initial-data]} lxf-lambda: {args[--lxf-lambda]} nt: {args[--nt]} not-periodic: {args[--not-periodic]} num-flux: {args[--num-flux]} (vx, vy): ({args[--vx]}, {args[--vy]}) Greedy basis generation: number of ei-snapshots: {args[EI_SNAPSHOTS]} prescribed collateral basis size: {args[EISIZE]} actual collateral basis size: {real_cb_size} number of snapshots: {args[SNAPSHOTS]} prescribed basis size: {args[RBSIZE]} actual basis size: {real_rb_size} elapsed time: {greedy_data[time]} Stochastic error estimation: number of samples: {args[--test]} maximal L2-error: {l2_err_max} (mu = {mumax}) elapsed time: {t_est} '''.format(**locals())) sys.stdout.flush() if args['--plot-error-landscape']: import matplotlib.pyplot as plt import mpl_toolkits.mplot3d # NOQA fig = plt.figure() ax = fig.add_subplot(111, projection='3d') # we have to rescale the errors since matplotlib does not support logarithmic scales on 3d plots # https://github.com/matplotlib/matplotlib/issues/209 surf = ax.plot_surface(M_grid, N_grid, np.log(np.minimum(errs, 1)) / np.log(10), rstride=1, cstride=1, cmap='jet') plt.show() if args['--plot-err']: U = fom.solve(mumax) URB = reductor.reconstruct(rom.solve(mumax)) fom.visualize( (U, URB, U - URB), legend=('Detailed Solution', 'Reduced Solution', 'Error'), title='Maximum Error Solution', separate_colorbars=True) return ei_data, greedy_data