Tuning a process

Once you have built a model of your process, a common problem you might face is tuning its parameters. Plugboard includes a built-in optimisation utility based on Ray Tune and Optuna. Using this tool you can do things like:

Calibrate the parameters of a process model to match observed results; and
Optimise a process model to maximise or minimise its output.

These capabilities are particularly useful when working with digital twins: for example given a model of a production line, you could use the tuner to work out how to maximise its output.

Tip

By using Ray Tune, Plugboard allows you to run optimisations in parallel within a Ray cluster, allowing you to explore the parameter space quickly even when working with long simulations.

Define a model to optimise

As a simple example, we'll create a simple 3-component model to calculate the maximum height of a projectile launched at a given angle and velocity.

 flowchart LR
   horizontal@{ shape: rounded, label: Iterator<br>**horizontal** } --> trajectory@{ shape: rounded, label: Trajectory<br>**trajectory** }
   trajectory@{ shape: rounded, label: Trajectory<br>**trajectory** } --> max-height@{ shape: rounded, label: MaxHeight<br>**max-height** }

Running the model with different values of the angle and velocity parameters configured on the Trajectory component will result in different heights being found on the MaxHeight component at the end of the simulation. We will use the Tuner class to explore this parameter space and maximise the projectile height.

Setting up the components

We'll need the following components to implement the model above:

class Iterator(Component):
    """Creates a sequence of x values."""

    io = IO(outputs=["x"])

    def __init__(self, iters: int, **kwargs: _t.Unpack[ComponentArgsDict]) -> None:
        super().__init__(**kwargs)
        self._iters = iters

    async def init(self) -> None:
        self._seq = iter(range(self._iters))

    async def step(self) -> None:
        try:
            self.x = next(self._seq)
        except StopIteration:
            await self.io.close()


class Trajectory(Component):
    """Computes the height of a projectile."""

    io = IO(inputs=["x"], outputs=["y"])

    def __init__(
        self, angle: float = 30, velocity: float = 20, **kwargs: _t.Unpack[ComponentArgsDict]
    ) -> None:
        super().__init__(**kwargs)
        self._angle_radians = math.radians(angle)
        self._v0 = velocity

    async def step(self) -> None:
        self._logger.info("Calculating trajectory", x=self.x)
        self.y = self.x * math.tan(self._angle_radians) - (9.81 * self.x**2) / (
            2 * self._v0**2 * math.cos(self._angle_radians) ** 2
        )


class MaxHeight(Component):
    """Record the maximum height achieved."""

    io = IO(inputs=["y"], outputs=["max_y"])

    def __init__(self, **kwargs: _t.Unpack[ComponentArgsDict]) -> None:
        super().__init__(**kwargs)
        self.max_y: float = 0

    async def step(self) -> None:
        self.max_y = max(self.y, self.max_y)

Instead of building a

Tuning a process

Define a model to optimise

Setting up the components

Setting up the Tuner

Using YAML config