esde
machine-learning
MLAir

Repository

import mlair

# just give it a dry run without any modification
mlair.run()
INFO: mlair started
INFO: ExperimentSetup started
INFO: Experiment path is: /home/<usr>/mlair/testrun_network
...
INFO: load data for DEBW001 from JOIN
...
INFO: Training started
...
INFO: mlair finished after 00:00:12 (hh:mm:ss)
import mlair

# our new stations to use
stations = ['DEBW030', 'DEBW037', 'DEBW031', 'DEBW015', 'DEBW107']

# expanded temporal context to 14 (days, because of default sampling="daily")
window_history_size = 14

# restart the experiment with little customisation
mlair.run(stations=stations,
          window_history_size=window_history_size)
INFO: mlair started
INFO: ExperimentSetup started
...
INFO: load data for DEBW030 from JOIN
INFO: load data for DEBW037 from JOIN
...
INFO: Training started
...
INFO: mlair finished after 00:00:24 (hh:mm:ss)
import mlair

# our new stations to use
stations = ['DEBY002', 'DEBY079']

# same setting for window_history_size
window_history_size = 14

# run experiment without training
mlair.run(stations=stations,
          window_history_size=window_history_size,
          create_new_model=False,
          trainable=False)
INFO: mlair started
...
INFO: No training has started, because trainable parameter was false.
...
INFO: mlair finished after 00:00:06 (hh:mm:ss)
import mlair
import logging

class CustomStage(mlair.RunEnvironment):
    """A custom MLAir stage for demonstration."""

    def __init__(self, test_string):
        super().__init__()  # always call super init method
        self._run(test_string)  # call a class method

    def _run(self, test_string):
        logging.info("Just running a custom stage.")
        logging.info("test_string = " + test_string)
        epochs = self.data_store.get("epochs")
        logging.info("epochs = " + str(epochs))


# create your custom MLAir workflow
CustomWorkflow = mlair.Workflow()
# provide stages without initialisation
CustomWorkflow.add(mlair.ExperimentSetup, epochs=128)
# add also keyword arguments for a specific stage
CustomWorkflow.add(CustomStage, test_string="Hello World")
# finally execute custom workflow in order of adding
CustomWorkflow.run()
INFO: mlair started
...
INFO: ExperimentSetup finished after 00:00:12 (hh:mm:ss)
INFO: CustomStage started
INFO: Just running a custom stage.
INFO: test_string = Hello World
INFO: epochs = 128
INFO: CustomStage finished after 00:00:01 (hh:mm:ss)
INFO: mlair finished after 00:00:13 (hh:mm:ss)

import keras
from keras.losses import mean_squared_error as mse
from keras.optimizers import SGD

from mlair.model_modules import AbstractModelClass

class MyLittleModel(AbstractModelClass):
    """
    A customised model with a 1x1 Conv, and 3 Dense layers (32, 16
    window_lead_time). Dropout is used after Conv layer.
    """
    def __init__(self, window_history_size, window_lead_time, channels):
        super().__init__()
        # settings
        self.window_history_size = window_history_size
        self.window_lead_time = window_lead_time
        self.channels = channels
        self.dropout_rate = 0.1
        self.activation = keras.layers.PReLU
        self.lr = 1e-2
        # apply to model
        self.set_model()
        self.set_compile_options()
        self.set_custom_objects(loss=self.compile_options['loss'])

    def set_model(self):
        # add 1 to window_size to include current time step t0
        shape = (self.window_history_size + 1, 1, self.channels)
        x_input = keras.layers.Input(shape=shape)
        x_in = keras.layers.Conv2D(32, (1, 1), padding='same')(x_input)
        x_in = self.activation()(x_in)
        x_in = keras.layers.Flatten()(x_in)
        x_in = keras.layers.Dropout(self.dropout_rate)(x_in)
        x_in = keras.layers.Dense(32)(x_in)
        x_in = self.activation()(x_in)
        x_in = keras.layers.Dense(16)(x_in)
        x_in = self.activation()(x_in)
        x_in = keras.layers.Dense(self.window_lead_time)(x_in)
        out = self.activation()(x_in)
        self.model = keras.Model(inputs=x_input, outputs=[out])

    def set_compile_options(self):
        self.compile_options = {"optimizer": SGD(lr=self.lr),
                                "loss": mse,
                                "metrics": ["mse"]}
transformation = {"scope": <...>,
                  "method": <...>,
                  "mean": <...>,
                  "std": <...>}
ExperimentSetup(..., transformation=transformation, ...)