Arby’s documentation

Arby is a fully data-driven Python module to construct surrogate models, reduced bases and empirical interpolants from training data.

This module implements a type of Reduced Order Modeling technique for reducing the computational complexity of mathematical models in numerical simulations.

Contents

• Installation
• Tutorial
  • Simple pendulum: build a surrogate model
    • Solving the pendulum equations
    • Building the surrogate
    • Benchmarks
  • Build a reduced basis
  • Further reading
• Module API
  • Module arby.rom
  • Module arby.basis
  • Module arby.integrals

Quick Usage

Suppose we have a set of real functions parametrized by a real number \(\lambda\). This set, the training set, represents an underlying parametrized model \(f_\lambda(x)\) with continuous dependency in \(\lambda\). Without complete knowledge about \(f_\lambda\), we’d like to produce an accurate approximation only through the access to the training set.

With Arby we can build an accurate surrogate model to represent the training set. For simplicity, suppose a discretization of the parameter domain [par_min, par_max] with Ntrain samples indexing the training set

params = np.linspace(par_min, par_max, Ntrain)

and a discretization of the \(x\) domain \([a,b]\) in Nsamples points

x_samples = np.linspace(a, b, Nsamples)

Next, we build a training set

training_set = [f(par, x_samples) for par in params]

that has shape (Ntrain, Nsamples).

Then we build the surrogate model with Arby by doing:

from arby import ReducedOrderModel as ROM
f_model = ROM(training_space=training_set,
              physical_interval=x_samples,
              parameter_interval=params)

With f_model we can get function samples for any parameter par in the interval [par_min, par_max] simply by calling it:

f_model_at_par = f_model.surrogate(par)
plt.plot(x_samples, model_at_par)
plt.show()