Experiments are attempts to reach a specific objective based on a hypothesis by using a pipeline. They are used to test your pipelines and train machine learning models before deploying them.

An experiment belongs to the pipeline it tests. Open a pipeline and you will find its Experiments alongside its Deployments, Production Logs and Production Plots — what you tried, and what is running, in the same place.

Running a pipeline

Using the Pipeline UI, open your pipeline from AI Lab ▸ Pipelines. Choose a twin unit in the header — a run needs to know which asset it is for, and Run will point you back here until you have picked one — then click Run.

Execute a Pipeline within an Experiment opens:

Execution — what the run should do.

• Train: train the pipeline's machine learning model(s). On by default.
• Plot: run the plot step(s). On by default.
• Write: write results back to the time-series database. Off by default — an experiment does not touch your data unless you ask it to, which is the main thing separating it from a production run.

Variables — the pipeline's own variables, plus Now: the reference datetime the run treats as the present. Override it to replay a past moment, for instance to see what the pipeline would have concluded during an incident last week.

Runtime — the Python Version to run on. Left alone, the platform default applies.

Advanced properties — a JSON dictionary merged into the execution properties, for anything the pipeline reads with @variable.

Click Execute to run.

Using the Python Toolkit, run a pipeline in experiment mode as follows:

execution = wizata_dsapi.api().experiment(
    experiment='my_experiment',
    pipeline='my_pipeline',
    twin='my_twin'
)

To link your execution to a named experiment for tracking purposes, create or update the experiment first:

wizata_dsapi.api().upsert_experiment(
    key='my_experiment_key',
    name='My Experiment Display Name',
    pipeline='my_pipeline_key'
)

📘

Naming experiments is a toolkit feature

The interface no longer has an Experiments section of its own: a run belongs to
the pipeline it tests, and that is where you start it and read it. Named
experiments still exist in the API and the Python Toolkit, where they group
several runs under one key — useful when you are comparing attempts
programmatically. Runs started from the interface do not need one.

Twin

The Twin must be referenced using its hardware ID as registered on the template used by the pipeline.

Properties

Properties parametrise a run. A step or a script refers to one with the @var_name notation — a Query step whose range is @start_q to @end_q, a threshold a script compares against — and the value is supplied when the pipeline runs, so the same pipeline can be tried twenty different ways without being edited.

Declaring a variable on the pipeline is what puts it in the dialog. A declared variable becomes its own field, labelled and typed, under Variables:

Here Tolerance Outliers Detect and Fuel Low Threshold are floats and Query Start From is a relative expression such as now-7d, so the dialog can tell you what it expects. Now is always present.

A variable that is not declared still works — a script can read anything you send — but nothing in the interface knows to ask for it. Those go in Advanced properties, the JSON dictionary at the bottom of the same dialog, which is merged with the fields above into one set of execution properties.

So: declare the ones people will want to change, and use advanced properties for the rest.

The same dictionary can be passed programmatically:

execution = wizata_dsapi.api().experiment(
    experiment='my_experiment',
    pipeline='my_pipeline',
    twin='my_twin',
    properties={
        'start_q': 'now-7d',
        'end_q': 'now'
    }
)

Options

In experiment mode, by default ML model are trained and scored, plots steps are executed, but no data are written back to the platform. You can override this behavior using execution_options:

execution = wizata_dsapi.api().experiment(
    experiment='my_experiment',
    pipeline='my_pipeline',
    twin='my_twin',
    properties={
        'start_q': 'now-7d',
        'end_q': 'now'
    },
    train=False,
    plot=False,
    write=True
)

{
   "properties" : {
      "execution_options" : {
        "train" : false,
        "plot" : false,
        "write" : true
      }
   }
}

Pipeline Images

You can also pass a pipeline image key when running an experiment, which will use the packaged version of the pipeline instead of the live definition:

wizata_dsapi.api().experiment(
    experiment='my_experiment_key',
    pipeline='my_pipeline_key',
    twin='my_twin_name',
    image='my_pipeline_image_key'
)

For more details on building and managing pipeline images, refer to the Pipeline Images article.

Python version

When running from the interface, the Python environment is chosen under Runtime in the Run dialog shown above. Left alone, the platform default applies.

When using the experiment() method from Python, your local version is automatically sent to the platform as the desired version. You can also set it manually:

execution = wizata_dsapi.api().experiment(
    experiment='my_experiment',
    pipeline='my_pipeline',
    twin='my_twin',
    version='3.12'
)

To check which versions are available in your platform, navigate to AI Lab ▸ Overview

For more information, you can take a look at the dedicated article on Upgrading your solution Python version

Viewing Experiment Results

Once an experiment has been executed, you can review the results in the Experiments tab of your pipeline. Click the eye icon next to a completed execution to open the detail panel, where all generated plots and output tables are displayed.

📘

The tab only looks back seven days

The date range above the list defaults to the last seven days, so a pipeline you
have not experimented with recently opens empty — the runs are not gone, they are
outside the window. Set the range to cover the period you are looking for.

Each run appears twice, once when it starts and once when it finishes, with the twin it ran against and how long it took. The counters above the list summarise the range.

Experiment runs also appear in AI Lab ▸ Execution Logs, but you have to ask for them. That page opens on production runs, and the small two-icon switch to the left of the date range chooses which it shows — Production Only or Experiment Only:

It is easy to miss, and while it is set to Production Only an experiment you have just started is genuinely absent from the list rather than merely hard to find.

Use Execution Logs when you want experiments across every pipeline, or the columns it adds — level, message, wait time, edge device. Use the pipeline's own Experiments tab when you are working on one pipeline.

Deleting an experiment

To delete an experiment from Python, use the .get() method to retrieve it and then pass it to .delete():

experiment_object = wizata_dsapi.api().get(experiment_key="pipeline_dev5352")
wizata_dsapi.api().delete(experiment_object)

From the UI, open the pipeline's Experiments tab and use the delete option on the run you want to remove. Experiments are no longer listed in a section of their own — they belong to the pipeline they test.