CLI

Table of Contents

Overview

Neptune Command Line Interface (CLI) allows you to manage Neptune jobs and experiments.

It lets you:

To install it, please follow the instructions.

Available Commands

To list all available commands, run neptune --help.

To get detailed information about a specific command, run neptune <COMMAND_NAME> --help in a console window. You will see information about the purpose of the command and a description of the command’s parameters.

neptune run

This command creates a new experiment and executes it on the local machine. The experiment gets registered on Neptune Server. You can watch it and manage it using Neptune Web UI.

You can configure the behaviour of the neptune run using configuration file or command line flags.

To run an experiment, you need to write the main Python script using the Python Client Library.

Simple Example

Let’s assume you have created single Python source code file main.py in a directory example.

from deepsense import neptune

ctx = neptune.Context()

print('Hello, World!')

Now, from the directory containing main.py, you can execute neptune run.

Neptune executes main.py. You should see Hello, World! printed out.

Neptune executes your code in directory called storage. By default, storage is located on your local machine under ~/neptune-storage (%USERPROFILE%\neptune-storage on Windows).

See configuration file reference to see how:

neptune enqueue

Creates a new experiment in queued state. Jobs in the queued experiment are also in queued state and can be run later with neptune exec on the local machine or on a remote host. This is useful in remote execution setup.

The command is similar to neptune run – it accepts the same set of parameters. However, it does not run any jobs after experiment is created.

Just as neptune run, you can configure neptune enqueue using configuration file or command line flags.

neptune exec

Executes queued experiments or jobs on the local machine. You can override parameter values that were passed in neptune enqueue command.

neptune exec 78b7ba83-9bb8-4405-b0b7-793fae2b566b
# executes job with id `78b7ba83-9bb8-4405-b0b7-793fae2b566b`

neptune exec 78b7ba83-9bb8-4405-b0b7-793fae2b566b -- --x 456 --y newvalue
# executes this job with overridden parameter's values

neptune exec --exp d0ef7173-0556-4d81-80c8-2cbaf2ce18c4
# executes consecutive jobs from experiment with id `d0ef7173-0556-4d81-80c8-2cbaf2ce18c4` until there are no queued jobs left.

neptune exec --from-exp d0ef7173-0556-4d81-80c8-2cbaf2ce18c4
# executes a single job from an experiment with id `d0ef7173-0556-4d81-80c8-2cbaf2ce18c4`
neptune exec --resources gpu tensorflow

will execute a single job whose all requirements are fulfilled by specified resources. The command shown above can run jobs that have one of the following requirements:

neptune reserve

You can reserve a single job for execution for fixed period of time using neptune reserve. A reserved job cannot be executed using neptune exec --resources. While doing a reservation, you may provide a list of available resources. Only a job which requirements are a subset of specified resources can be reserved.

neptune reserve --resources gpu

should result in output like:

>
> Job reserved, id: 39fc68c5-3b2e-4789-b511-7102093f150f
> Reservation is valid until: 2017-01-25 09:36:41
>
> To browse the job, follow:
> http://10.255.255.4:8080/#dashboard/job/39fc68c5-3b2e-4789-b511-7102093f150f
>

neptune ls

Lists all experiments or jobs meeting criteria specified in command parameters.

You can adjust the amount of displayed information by passing --fields FIELD_NAME ... parameter.

See neptune ls exps --help for details.

Listing Experiments

Run neptune ls --fields No. id name owner state to print the list of all experiments that are not archived. The --fields parameter was used to limit output. For example:

 No. | id                                   | name                    | owner        | state
-----+--------------------------------------+-------------------------+--------------+--------
 1   | d0ef7173-0556-4d81-80c8-2cbaf2ce18c4 | Example experiment name | Neptune User | queued
 2   | c196caeb-312d-4c41-8c08-b3869eb6b8fc | Example experiment name | Neptune User | queued
 3   | 0c2328ba-4bc3-4348-a770-06c5675a06a0 | Example experiment name | Neptune User | queued

Note that neptune ls is a shortcut for neptune ls exps call.

Listing Experiments with Filters

You can filter experiments by multiple criteria. For example, you can print only experiments that:

To filter out experiments that are in queued state and tagged with tag3, use:

neptune ls --fields No. id tags --tags tag3 --states queued

Queued experiments with tag tag3 should be printed:

 No. | id                                   | tags
-----+--------------------------------------+-----------
 1   | af2fa73b-4be8-4173-a8a1-0eb543eb15d0 | tag2 tag3
 2   | 878aad84-42d3-4710-afc2-5b2647410b85 | tag3 tag4
Listing Jobs

It is possible to list all jobs for a given experiment.

Let’s list jobs from the experiment No. 1 from the previous example.

neptune ls jobs af2fa73b-4be8-4173-a8a1-0eb543eb15d0

Example result:

 No. | id                                   | name                    | owner        | state  | tags
-----+--------------------------------------+-------------------------+--------------+--------+-----------
 1   | 99d9cfed-5044-4f0c-a6b1-e157b86e183c | Example experiment name | Neptune User | queued | tag2 tag3

As you can see, this experiment has only one job.

While listing jobs, you can use the --fields argument to choose custom columns in the output.

neptune show

Displays detailed information about an experiment or a job with the given id.

Show Details of an Experiment
neptune show exps d0ef7173-0556-4d81-80c8-2cbaf2ce18c4

Output:

 Name:                  | Value:
------------------------+--------------------------------------------------------------------------------
 id                     | d0ef7173-0556-4d81-80c8-2cbaf2ce18c4
 name                   | Example experiment name
 description            | Example description
 project                | Example Project
 owner                  | Neptune User
 time_of_creation       | 2017-01-23 13:17
 time_of_completion     |
 state                  | queued
 storage_location       | /home/ubuntu/work/output/experiment
 storage_root           |
 tags                   |
 requirements           |
 enqueue_command        | neptune enqueue example/main.py --config cfg.yaml --storage output
 archived               | False
 trashed                | False
 size                   | 0.0B
 best_job               | 1cf8b114-38df-4878-95a0-6de857eea070
 grid_search_parameters |
 job_states             | not_responding=0 succeeded=0 failed=0 running=0 aborted=0 queued=1
 metric                 |
Show Details of a Job
neptune show jobs 8333743a-38ce-4f72-bb09-48c8bacb37be

Output:

 Name:                         | Value:
-------------------------------+---------------------------------------------------------------------------
 id                            | 8333743a-38ce-4f72-bb09-48c8bacb37be
 experiment_id                 | a0b27ec8-d527-470b-860f-7b331c0dfe67
 name                          | Sine-Cosine Generator
 description                   |
 project                       | Trigonometry
 owner                         | Neptune User
 time_of_creation              | 2017-01-25 09:22
 time_of_completion            |
 time_of_entered_running_state |
 state                         | queued
 tags                          |
 requirements                  |
 properties                    |
 channels                      |
 parameters                    | amplitude=1.0 sampling_rate=2.0
 actions                       |
 traceback                     |
 storage_root                  |
 storage_location              | /tmp/storage-dir/experiment
 source_code_location          | /tmp/storage-dir/experiment/src/main.py
 stdout_log_location           |
 stderr_log_location           |
 enqueue_command               | neptune enqueue getting-started/main.py --config getting-started/config.yaml
                                 --storage /tmp/storage-dir
 run_command                   |
 size                          | 0.0B
 docker_image                  |

neptune abort

Aborts a specified sequence of experiments or jobs.

Abort Experiments

Let’s assume you have a few experiments running.

neptune ls --fields No. id state --states running

outputs a list of experiments in state running:

 No. | id                                   | state
-----+--------------------------------------+-----------
 1   | 85e0af98-7c7f-452f-8c98-90ad8049f905 | running
 2   | aba547fb-c105-4d78-8ce7-50e42330ccf2 | running
 3   | 5ca32b8d-8848-4a24-b604-c1f4757c787c | running

Let’s abort two of them:

neptune abort exps 85e0af98-7c7f-452f-8c98-90ad8049f905 aba547fb-c105-4d78-8ce7-50e42330ccf2

You should get the following result:

Aborting:
85e0af98-7c7f-452f-8c98-90ad8049f905    OK
aba547fb-c105-4d78-8ce7-50e42330ccf2    OK
Aborted 2 experiments.

NOTE: All running and queued jobs of an aborted experiment will be aborted as well.

Abort Jobs

You can abort jobs. The only difference is changing exps to jobs in abort command.

This time, let’s assume you have one experiment in running state, so executing:

neptune ls --fields No. id state best_job

gives us following output:

 No. | id                                   | state     | best_job
-----+--------------------------------------+-----------+--------------------------------------
 1   | 5ca32b8d-8848-4a24-b604-c1f4757c787c | running | 07b5b8ea-56b5-44d0-aecb-17bb8b4eaebf

Going further, let’s list the jobs present in this experiment:

To achieve that, run:

neptune ls jobs 5ca32b8d-8848-4a24-b604-c1f4757c787c

If this experiment has four jobs, output should look like following:

 No. | id                                   | name | owner        | time_of_creation | state
-----+--------------------------------------+------+--------------+------------------+-----------
 1   | 07b5b8ea-56b5-44d0-aecb-17bb8b4eaebf | 2    | Neptune User | 2017-01-26 11:38 | running
 2   | 3b90fb6a-f253-4e05-9b93-262aa8ace722 | 4    | Neptune User | 2017-01-26 11:38 | running
 3   | 62090cec-6b23-4081-adc4-88521b2ecae7 | 1    | Neptune User | 2017-01-26 11:38 | running
 4   | efea2135-eb2c-462f-80a8-be7b453aed21 | 3    | Neptune User | 2017-01-26 11:38 | queued

For example, you can abort jobs No. 3 and No. 4:

neptune abort jobs 62090cec-6b23-4081-adc4-88521b2ecae7 3b90fb6a-f253-4e05-9b93-262aa8ace722

You should see:

Aborting:
62090cec-6b23-4081-adc4-88521b2ecae7    OK
3b90fb6a-f253-4e05-9b93-262aa8ace722    OK
Aborted 2 jobs.

neptune archive

Archives a specified sequence of experiments.

neptune archive ca944721-030b-47d1-8302-8c7c4ede6dae fb7d9091-ed90-499d-bd20-cb77f1fd202e

Output:

Archiving:
ca944721-030b-47d1-8302-8c7c4ede6dae    OK
fb7d9091-ed90-499d-bd20-cb77f1fd202e    OK
Archived 2 experiments.

Archived experiments won’t be listed by default in neptune ls. To list archived experiments, pass the --archived-only or --archived-included option to neptune ls.

neptune unarchive

Removes a specified sequence of experiments from archives.

neptune unarchive ca944721-030b-47d1-8302-8c7c4ede6dae fb7d9091-ed90-499d-bd20-cb77f1fd202e

Output:

Unarchiving:
ca944721-030b-47d1-8302-8c7c4ede6dae    OK
fb7d9091-ed90-499d-bd20-cb77f1fd202e    OK
Unarchived 2 experiments.

neptune trash

Moves given experiments to trash.

neptune trash ca944721-030b-47d1-8302-8c7c4ede6dae fb7d9091-ed90-499d-bd20-cb77f1fd202e

Output:

Trashing:
ca944721-030b-47d1-8302-8c7c4ede6dae    OK
fb7d9091-ed90-499d-bd20-cb77f1fd202e    OK
Trashed 2 experiments.

Trashed experiments can be either restored or deleted forever. You can only trash a completed experiment. Trashed experiments are hidden on most experiment views. You can browse them by passing --trashed-only or --trashed-included to neptune ls or in Web UI in Trash view.

neptune restore

Restores given experiments from trash.

neptune restore ca944721-030b-47d1-8302-8c7c4ede6dae fb7d9091-ed90-499d-bd20-cb77f1fd202e

Output:

Restoring:
ca944721-030b-47d1-8302-8c7c4ede6dae    OK
fb7d9091-ed90-499d-bd20-cb77f1fd202e    OK
Restored 2 experiments.

neptune delete

Deletes given experiments from trash.

neptune delete ca944721-030b-47d1-8302-8c7c4ede6dae fb7d9091-ed90-499d-bd20-cb77f1fd202e

Output:

Deleting:
ca944721-030b-47d1-8302-8c7c4ede6dae    OK
fb7d9091-ed90-499d-bd20-cb77f1fd202e    OK
Deleted 2 experiments.

Deleted experiments can no longer be seen or accessed. It is an irreversible operation.

Deleting experiment removes all it’s data (like channel images) from Neptune Server and releases disk space for further experiments. This command doesn’t remove snapshots of your source code nor logs from your storage.

neptune quota

Displays the available storage space for images.

neptune quota

Output:

38.4GiB of 160.2GiB used.

neptune action-invoke

Invokes a job’s action. To invoke an action, you have to pass the following arguments to the command:

neptune action-invoke 55f4d3d7-c9f2-4137-a219-df4200871f5c "first action" arg

Output:

Action was successfully invoked! The identifier of invocation is: 9e53f12e-92cc-41f7-8a6e-f8ea05da0f28

neptune action-events

Shows the list of action events for a job with the given ID. The following columns will be displayed:

neptune action-events 55f4d3d7-c9f2-4137-a219-df4200871f5c

Output:

 No. | action_invocation_id | timestamp        | action_id     | name          | event_type      | data
-----+----------------------+------------------+---------------+---------------+-----------------+----------------
 1   | 9e53f12e...a05da0f28 | 2016-10-18 15:12 | 5939a2...8392 | first action  | actionInvoked   | argument1
 2   | 9e53f12e...a05da0f28 | 2016-10-18 15:12 | 5939a2...8392 | first action  | actionSucceeded | returnedValue1
 3   | 0499d239...71f4f2f6b | 2016-10-18 15:14 | a7cf4e...20e1 | second action | actionInvoked   | argument2
 4   | 0499d239...71f4f2f6b | 2016-10-18 15:14 | a7cf4e...20e1 | second action | actionSucceeded | returnedValue2

neptune action-invocations

Shows the list of action invocations for a job with the given ID. The following columns will be displayed:

neptune action-invocations 55f4d3d7-c9f2-4137-a219-df4200871f5c

Output:

No. | action_name | action_invocation_id | action_invocation_state | argument | started          | finished         | result
-----+------------+----------------------+-------------------------+----------+------------------+------------------+---------
1   | first name  | 9e53f12e...a05da0f28 | actionSucceeded         | arg1     | 2016-10-18 15:12 | 2016-10-18 15:12 | retVal1
2   | second name | 9e53f12e...a05da0f28 | actionSucceeded         | arg2     | 2016-10-18 15:12 | 2016-10-18 15:12 | retVal2

Configuration Files

A configuration file lets Neptune CLI communicate with Neptune Server. Additionally, it describes a Neptune experiment.

You can keep all the common configuration in a ~/.neptune.yaml file (%USERPROFILE%\.neptune.yaml on Windows). You can also put local neptune.yaml file in a place where you run neptune commands to override global settings. Additionally, you can override most of the settings using command line arguments.

The format of the configuration files is YAML.

Experiment Description

There are number of settings that serve to describe your experiment. They are read by run and enqueue commands, when the experiment is created. You can override most of those settings via command line flags.

executable

By default, neptune run and neptune enqueue look for main.py file (or main.R or main.jar). If you want to use different file as entry point to your program, use executable setting.

In neptune.yaml:

executable: other_python_script.py

Via command line, you can pass it as executable argument after neptune run or neptune enqueue:

neptune run --executable other_python_script.py

or even easier as a positional argument:

neptune run other_python_script.py
name

The experiment’s name displayed in the experiment list on Neptune Web UI. By default it is set to the name of the directory you are in.

In neptune.yaml:

name: Name for my experiment

Via command line:

neptune run --name "Name for my experiment"
description

The experiment’s description displayed in detailed experiment view on Neptune Web UI. By default it is empty.

In neptune.yaml:

description: Description for my experiment

Via command line:

neptune run --description "Description of an experiment"
project

A string that can be used to group experiments focused on a specific task. By default it is set to the name of the directory you are in.

In neptune.yaml:

project: Project name

Via command line:

neptune run --project "Project name"
tags

Tags are single words added to experiment. All jobs inherit tags from its experiment. Additionally they can be tagged from the source code. Tags should contain only lowercase letters, digits, underscores and dashes.

In neptune.yaml:

tags: [tag1, tag2, tag3, tag4]

Via command line:

neptune run --tags tag1 tag2 tag3 tag4

If you pass tags via config and via command line, all the tags are added.

properties

You can declare a set of key-value pairs (a.k.a. properties) for an experiment in configuration file. Keys and values are of string type. Properties are displayed on the experiment’s dashboard.

In neptune.yaml:

properties:
  - key: property1
    value: value1
  - key: property2
    value: value2

Via command line:

neptune run --properties property1:value1 property2:value2

If you pass properties via config and via command line, all the properties are added. If you use the same key in config and in command line, the command line value is used.

requirements

Requirements can be declared for an experiment in configuration file and in the enqueue command.

All jobs inherit requirements from its experiment. Requirements should contain only lowercase letters, digits, underscores and dashes. Requirements are displayed on the dashboard. Requirements are useful when dealing with remote execution.

In neptune.yaml:

requirements: [gpu, ssd]

Via command line:

neptune enqueue --requirements gpu ssd

If you pass requirements via config and via command line, all the requirements are added.

Experiment Parameters Definitions

If you want your experiment to have parameters, you need to include a parameters section in your configuration file. The parameters are read by run and enqueue commands. You can override the default values of the parameters via command line arguments for run, enqueue and exec commands. Next, you can access the values of the parameters in your code (see how).

Note that you cannot define parameters using command line – you can only change their values.

Section parameters is a list of dictionaries (one dictionary describes one parameter).

Each dictionary describing a parameter contains the following attributes:

name (string, required)

Parameter’s name, it can contain only letters, digits and underscores.

description (string, optional)

Parameter’s description displayed in the parameters tab of the detailed experiment view on Neptune Web UI.

type (string, required)

Parameter type, one of: string, int, double, boolean.

default (optional)

The default value of the parameter.

required (boolean, required)

Whether a value must be given for the parameter.

Example of simple parameter values:

parameters:
  - name: x
    description: Example string parameter.
    type: string
    default: default x
    required: true
  - name: y
    description: Example int parameter.
    type: int
    required: false
  - name: z
    description: Example double parameter.
    type: double
    default: 3.14
    required: true
  - name: u
    description: Example boolean parameter.
    type: boolean
    required: true

The values of the parameters can be set via command line in run, enqueue and exec commands, like this:

neptune run -- --x "new x value" --y 2 --z 3.15 --u false

In order to run an experiment with grid search parameters you need to pass ranges or lists instead of a specific value of a parameter.

For example, assuming you may want to perform a grid search for y equal to three values: 1, 10, and 100, and z between 0 and 10 with step equal to 0.1:

parameters:
  - name: y
    description: Example int parameter.
    type: int
    default:
      values: [1, 10, 100]
    required: true
  - name: z
    description: Example double parameter.
    type: double
    default:
      ranges:
        -
          min: 0
          max: 10
          step: 0.1
    required: true

Gridable parameters ranges can be overridden via command line in run, enqueue and exec commands, like this:

neptune run -- --y "[1, 10, 100]" --z "(0, 10, 0.1)"

This command results in enqueueing an experiment with 300 jobs with all combinations of parameters y and z.

Note the double quotes around brackets and parentheses in this syntax. If you don’t quote them, ranges will not be correctly passed to Neptune.

You can pass more complicated expressions containing many mixed ranges and lists. They will be concatenated internally by Neptune.

For example, assuming x is declared as a floating point number, you can type:

neptune run -- --x "(0, 1, 0.1) [2] (5, 6, 0.1) [9, 10, 11]"

metric:

If you use grid search, you have to define a metric. This will let Neptune track the best job within your experiment.

A metric consists of:

In neptune.yaml:

metric:
  channel: acc_ch
  direction: maximize

Experiment Storage

Neptune executes your experiments in a directory called storage.

When you invoke neptune run or neptune enqueue, the content of the current directory is copied to:

<neptune-storage-dir>/<project_name>/<user_name>/<experiment_name>/<timestamp>/<serial_id>

The <serial_id> is needed to separate the experiments that started within the same minute. Each of them gets its own subdirectory.

After the end of experiment’s execution, this directory contains two subdirectories:

storage

By default, <neptune-storage> is set to ~/neptune-storage (%USERPROFILE%\neptune-storage on Windows). You can change this using storage setting.

In neptune.yaml:

storage: /mnt/shared-storage/neptune

Via command line:

neptune enqueue --storage /mnt/shared-storage/neptune
overwrite-storage-path

If you do not want Neptune to automatically generate directory structure to store your experiment, you can explicitly set the storage directory for an experiment yourself. In order to do so, use overwrite-storage-path flag. With this flag enabled, the path specified as storage will be used directly as the storage directory for the experiment. Neptune won’t create any subdirectories for it.

For example: In neptune.yaml:

storage: /mnt/shared-storage/neptune/custom/dir/for/my/exp
overwrite-storage-path: true

or via command line:

neptune enqueue --storage /mnt/shared-storage/neptune/custom/dir/for/my/exp --overwrite-storage-path
storage-base-path

This setting is useful if you use local machine to enqueue experiments and a remote machine to execute them. In this case, you have to use a shared storage as Neptune Storage. Frequently, the shared storage is mounted under different directories on the local machine and on the remote one. You can set storage-base-path on both of the machines to appropriate paths, for example /local-machine-storage on local machine and /remote-machine-storage on remote machine.

In neptune.yaml of the local machine:

storage: /local-machine-storage/my-neptune-storage
storage-base-path: /local-machine-storage

On remote machine:

storage-base-path: /remote-machine-storage

This lets Neptune CLI on remote machine infer that the experiment is stored in /remote-machine-storage/my-neptune-storage.

You can also specify this setting via command line:

neptune enqueue --storage /local-machine-storage/my-neptune-storage --storage-base-path /local-machine-storage
paths-to-copy

When you use neptune run or neptune enqueue, the directory you are in is copied to the experiment’s storage. This setting lets you specify additional files and directories that should be copied.

In neptune.yaml:

paths-to-copy:
    - src: /some/path/to/third_party_library
      dst: example
    - src: /some/path/to/another_one  # dst is optional

Via command line:

neptune run --paths-to-copy /some/path/to/third_party_library:example /some/path/to/another_one

In both above scenarios, your output directory will look similar to this:

<job_storage_directory>
├── logs
│   ├── stderr
│   └── stdout
└── src
    ├── main.py
    ├── example
    │   └── <third_party_library_content>
    └── another_one
        └── <another_one_content>

If you pass paths-to-copy via config and via command line, all the paths are copied.

exclude

If you do not want some files or directories to be copied to storage, use exclude.

In config file:

paths-to-copy:
    - src: /some/path/to/third_party_library
      dst: example
exclude:
    - /some/path/to/third_party_library/unwanted_file
    - /some/path/to/third_party_library/unwanted_dir

Via command line:

neptune run \
    --paths-to-copy /some/path/to/third_party_library:example
    --exclude /some/path/to/third_party_library/unwanted_file /some/path/to/third_party_library/unwanted_dir

Experiment Execution in Docker

docker-image

You can specify the docker image in which the experiment should be executed. This image needs to be available on the machine you will execute your experiment on. The container has to be able to execute Neptune commands (i. e. have Neptune CLI installed).

Docker image for an experiment can be set in configuration file and in run, enqueue and exec command.

docker-image: my_image:latest

or

neptune run --docker-image my_image:latest
docker-command

By default, if docker-image is specified, Neptune will try to run your experiment using command docker. If you want to change this command, you can set docker-command config option, for example:

docker-image: my-image:latest
docker-command: nvidia-docker

or

neptune run --docker-image my-image:latest --docker-command nvidia-docker
docker-run-args

By default, if docker-image is specified, Neptune will try to run your experiment using command docker run. If you want to add any custom flags for docker run, you can specify them using docker-run-args option to config file or --docker-run-args command line flag.

Neptune Server

There are number of settings that Neptune CLI uses to communicate with Neptune Server. Usually you want to define them in global neptune.yaml in your home directory, but you can also define them in local config or via command line flags.

Configuration File Example

The following example of a complete experiment configuration file contains all sections described above.

host: go.neptune.deepsense.io
port: 443
username: yourusername
password: secret
open-webbrowser: false

executable: my_script.py
name: Example experiment name
description: Example experiment description with more details.
project: Example experiment project
tags: [tag1, tag2, tag3, tag4]
requirements: [gpu]

storage: neptune-storage
storage-base-path: /local-machine-storage
overwrite-storage-path: false

docker-image: my-image:latest
docker-command: nvidia-docker
docker-run-args: --cpus 2

paths-to-copy:
    - src: /some/path/to/third_party_library
      dst: example
exclude:
    - /some/path/to/third_party_library/unwanted_file
    - /some/path/to/third_party_library/unwanted_dir

properties:
  - key: property1
    value: value1
  - key: property2
    value: value2

parameters:
  - name: x
    description: Example string parameter.
    type: string
    default: default_x
    required: true
  - name: y
    description: Example int parameter.
    type: int
    required: false
  - name: z
    description: Example double parameter.
    type: double
    default: 3.14
    required: true
  - name: u
    description: Example boolean parameter.
    type: boolean
    required: true
  - name: g
    description: Example gridable double parameter.
    type: double
    default:
      values: [-1.5, 1.5]
      ranges:
        -
          min: -1.0
          max: -0.5
          step: 0.1
        -
          min: 0.5
          max: 1.0
          step: 0.1
    required: true

metric:
  channel: acc_ch
  direction: maximize