V1HpChoice

polyaxon.polyflow.matrix.params.V1HpChoice(kind='choice', value=None)

Choice picks a value from a of list values.

params:
  paramTest:
    kind: choice
    value: [1, 2, 3, 4, 5]
from polyaxon.polyflow import V1HpChoice
param_test = V1HpChoice(value=[1, 2, 3, 4, 5])

V1HpPChoice

polyaxon.polyflow.matrix.params.V1HpPChoice(kind='pchoice', value=None)

PChoice picks a value with a probability from a list of [(value, probability), (value, probability), ...].

params:
  paramTest:
    kind: pchoice
    value: [(1, 0.1), (2, 0.1), (3, 0.8)]
from polyaxon.polyflow import V1HpPChoice
param_test = V1HpPChoice(value=[("A", 0.1), ("B", 0.1), ("C", 0.8)])

V1HpRange

polyaxon.polyflow.matrix.params.V1HpRange(kind='range', value=None)

Range picks a value from a generated list of values using [start, stop, step], you can pass values in these forms:

  • [1, 10, 2]
  • {start: 1, stop: 10, step: 2}
  • '1:10:2'
params:
  paramTest:
    kind: range
    value: [1, 10, 2]
from polyaxon.polyflow import V1HpRange
param_test = V1HpRange(value=[1, 10, 2])

V1HpLinSpace

polyaxon.polyflow.matrix.params.V1HpLinSpace(kind='linspace', value=None)

LinSpace picks a value from a generated list of steps from start to stop spaced evenly on a linear scale [start, stop, step], you can pass values in these forms:

  • [1, 10, 20]
  • {start: 1, stop: 10, num: 20}
  • '1:10:20'
params:
  paramTest:
    kind: linspace
    value: [1, 10, 20]
from polyaxon.polyflow import V1HpLinSpace
param_test = V1HpLinSpace(value=[1, 10, 20])

V1HpLogSpace

polyaxon.polyflow.matrix.params.V1HpLogSpace(kind='logspace', value=None)

LogSpace picks a value from a generated list of steps from start to stop spaced evenly on a log scale [start, stop, step], you can pass values in these forms:

  • [1, 10, 20]
  • {start: 1, stop: 10, num: 20}
  • '1:10:20'
params:
  paramTest:
    kind: logspace
    value: [1, 10, 20]
from polyaxon.polyflow import V1HpLogSpace
param_test = V1HpLinSpace(value=[1, 10, 20])

V1HpGeomSpace

polyaxon.polyflow.matrix.params.V1HpGeomSpace(kind='geomspace', value=None)

GeomSpace picks a value from a generated list of steps from start to stop spaced evenly on a geometric progression [start, stop, step], you can pass values in these forms:

  • [1, 10, 20]
  • {start: 1, stop: 10, num: 20}
  • '1:10:20'
params:
  paramTest:
    kind: geomspace
    value: [1, 10, 20]
from polyaxon.polyflow import V1HpGeomSpace
param_test = V1HpGeomSpace(value=[1, 10, 20])

V1HpUniform

polyaxon.polyflow.matrix.params.V1HpUniform(kind='uniform', value=None)

Uniform draws samples from a uniform distribution over the half-open interval [low, high), you can pass values in these forms:

  • 0:1
  • [0, 1]
  • {'low': 0, 'high': 1}
params:
  paramTest:
    kind: uniform
    value: [0, 1]
from polyaxon.polyflow import V1HpUniform
param_test = V1HpUniform(value=[0, 1])

V1HpQUniform

polyaxon.polyflow.matrix.params.V1HpQUniform(kind='quniform', value=None)

QUniform samples from a quantized uniform distribution over [low, high] (round(uniform(low, high) / q) * q), you can pass values in these forms:

  • 0:1:0.1
  • [0, 1, 0.1]
  • {'low': 0, 'high': 1, 'q': 0.1}
params:
  paramTest:
    kind: quniform
    value: [0, 1, 0.1]
from polyaxon.polyflow import V1HpQUniform
param_test = V1HpQUniform(value=[0, 1, 0.1])

V1HpLogUniform

polyaxon.polyflow.matrix.params.V1HpLogUniform(kind='loguniform', value=None)

LogUniform samples from a log uniform distribution over[low, high], you can pass values in these forms:

  • 0:1
  • [0, 1]
  • {'low': 0, 'high': 1}
params:
  paramTest:
    kind: loguniform
    value: [0, 1]
from polyaxon.polyflow import V1HpLogUniform
param_test = V1HpLogUniform(value=[0, 1])

V1HpQLogUniform

polyaxon.polyflow.matrix.params.V1HpQLogUniform(kind='qloguniform', value=None)

LogUniform samples from a log uniform distribution over[low, high], you can pass values in these forms:

  • 0:1:0.1
  • [0, 1, 0.1]
  • {'low': 0, 'high': 1, 'q': 0.1}
params:
  paramTest:
    kind: qloguniform
    value: [0, 1, 0.1]
from polyaxon.polyflow import V1HpQLogUniform
param_test = V1HpQLogUniform(value=[0, 1, 0.1])

V1HpNormal

polyaxon.polyflow.matrix.params.V1HpNormal(kind='normal', value=None)

Normal draws random samples from a normal (Gaussian) distribution defined by [loc, scale], you can pass values in these forms:

  • 0:1
  • [0, 1]
  • {'loc': 0, 'scale': 1}
params:
  paramTest:
    kind: normal
    value: [0, 1]
from polyaxon.polyflow import V1HpNormal
param_test = V1HpNormal(value=[0, 1])

V1HpQNormal

polyaxon.polyflow.matrix.params.V1HpQNormal(kind='qnormal', value=None)

QNormal draws random samples from a quantized normal (Gaussian) distribution defined by [loc, scale], you can pass values in these forms:

  • 0:1:0.1
  • [0, 1, 0.1]
  • {'loc': 0, 'scale': 1, 'q': 0.1}
params:
  paramTest:
    kind: qnormal
    value: [0, 1, 0.1]
from polyaxon.polyflow import V1HpQNormal
param_test = V1HpNormal(value=[0, 1, 0.1])

V1HpLogNormal

polyaxon.polyflow.matrix.params.V1HpLogNormal(kind='lognormal', value=None)

LogNormal draws random samples from a log normal (Gaussian) distribution defined by [loc, scale], you can pass values in these forms:

  • 0:1
  • [0, 1]
  • {'loc': 0, 'scale': 1}
params:
  paramTest:
    kind: lognormal
    value: [0, 1]
from polyaxon.polyflow import V1HpLogNormal
param_test = V1HpLogNormal(value=[0, 1])

V1HpQLogNormal

polyaxon.polyflow.matrix.params.V1HpQLogNormal(kind='qlognormal', value=None)

QLogNormal draws random samples from a log normal (Gaussian) distribution defined by [loc, scale], you can pass values in these forms:

  • 0:1:0.1
  • [0, 1, 0.1]
  • {'loc': 0, 'scale': 1, 'q': 0.1}
params:
  paramTest:
    kind: qlognormal
    value: [0, 1, 0.1]
from polyaxon.polyflow import V1HpQLogNormal
param_test = V1HpQLogNormal(value=[0, 1])