Use parameters

Note

This tutorial is a part of our Valohai fundamentals series.

This section will show you how to use parameters in Valohai. Defining parameters will allow you to easily rerun your executions and experiment with a different set of values.

In this section you will learn:

  • How to define Valohai parameters

  • How to change parameter values between executions both in the CLI and in the UI

  • Defining Valohai parameters will allow you to easily rerun your executions and experiment with a different set of values.

A short introduction parameters

  • Defining parameters allows you to easily rerun, sort, and keep track of executions based on the parameter values used to run them.

  • You can easily create (or copy) an execution and change the parameters in the UI, without changing your code.

  • Defining parameters allows you to start creating Tasks where you run multiple parallel executions with different parameter combinations.

  • Each step has it’s own parameter configuration in valohai.yaml.

  • A parameter can be type of a string, integer, float, and flag (=boolean).

  • Parameters are passed as command-line arguments to your code.

    • Edit how parameters are passed to your code using pass-as.

    • You can also parse parameter values from YAML and JSON files inside your execution. See file-based configuration.

Let’s start by defining parameters for our train-model step.

Update the valohai.yaml file with two new parameter definitions:

- step:
    name: train-model
    command:
      - pip install -r requirements.txt
      - python train.py {parameters}
    image: tensorflow/tensorflow:2.6.0
    parameters:
      - name: epoch
        type: integer
        default: 5
      - name: learning_rate
        type: float
        default: 0.001

Update train.py to use the parameter epoch in model.fit and use the learning_rate parameter value in the optimizer.

  • Read the parameter value during an execution with valohai.parameters('myparam').value

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import numpy as np
import tensorflow as tf
import valohai


input_path = 'mnist.npz'
with np.load(input_path, allow_pickle=True) as f:
    x_train, y_train = f['x_train'], f['y_train']
    x_test, y_test = f['x_test'], f['y_test']

x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10)
])

optimizer = tf.keras.optimizers.Adam(learning_rate=valohai.parameters('learning_rate').value)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
model.compile(optimizer=optimizer,
            loss=loss_fn,
            metrics=['accuracy'])

model.fit(x_train, y_train, epochs=valohai.parameters('epoch').value)

model.evaluate(x_test,  y_test, verbose=2)

output_path = valohai.outputs().path('model.h5')
model.save(output_path)

Run in Valohai

Finally run a new Valohai execution.

vh exec run train-model --adhoc

Rerun an execution with different parameter values

  • Open your project on app.valohai.com

  • Open the latest execution

  • Click Copy

  • Scroll down to the Parameters section

  • Change the value of epochs

  • Click Create execution

Tip

You can also run a new execution with different parameter values from the command line:

vh exec run train-model --adhoc --epochs=10

See also