R: Create a description object for a parameter of a machine...

LearnerParam {ParamHelpers} | R Documentation

## Create a description object for a parameter of a machine learning algorithm.

### Description

This specializes `Param()` by adding a few more attributes, like a default value, whether it refers to a training or a predict function, etc. Note that you can set `length` to `NA`

The S3 class is a `Param()` which additionally stores these elements:

when `character(1)`

  See argument of same name.

See the note in `Param()` about being able to pass expressions to certain arguments.

### Usage

    makeNumericLearnerParam(
      id,
      lower = -Inf,
      upper = Inf,
      allow.inf = FALSE,
      default,
      when = "train",
      requires = NULL,
      tunable = TRUE,
      special.vals = list()
    )

    makeNumericVectorLearnerParam(
      id,
      len = as.integer(NA),
      lower = -Inf,
      upper = Inf,
      allow.inf = FALSE,
      default,
      when = "train",
      requires = NULL,
      tunable = TRUE,
      special.vals = list()
    )

    makeIntegerLearnerParam(
      id,
      lower = -Inf,
      upper = Inf,
      default,
      when = "train",
      requires = NULL,
      tunable = TRUE,
      special.vals = list()
    )

    makeIntegerVectorLearnerParam(
      id,
      len = as.integer(NA),
      lower = -Inf,
      upper = Inf,
      default,
      when = "train",
      requires = NULL,
      tunable = TRUE,
      special.vals = list()
    )

    makeDiscreteLearnerParam(
      id,
      values,
      default,
      when = "train",
      requires = NULL,
      tunable = TRUE,
      special.vals = list()
    )

    makeDiscreteVectorLearnerParam(
      id,
      len = as.integer(NA),
      values,
      default,
      when = "train",
      requires = NULL,
      tunable = TRUE,
      special.vals = list()
    )

    makeLogicalLearnerParam(
      id,
      default,
      when = "train",
      requires = NULL,
      tunable = TRUE,
      special.vals = list()
    )

    makeLogicalVectorLearnerParam(
      id,
      len = as.integer(NA),
      default,
      when = "train",
      requires = NULL,
      tunable = TRUE,
      special.vals = list()
    )

    makeUntypedLearnerParam(
      id,
      default,
      when = "train",
      requires = NULL,
      tunable = TRUE,
      special.vals = list()
    )

    makeFunctionLearnerParam(
      id,
      default,
      when = "train",
      requires = NULL,
      tunable = TRUE,
      special.vals = list()
    )

### Arguments

`id` | (`character(1)`) Name of parameter.
`lower` | (`numeric` | `expression`) Lower bounds. A singe value of length 1 is automatically replicated to `len` for vector parameters. If `len = NA` you can only pass length-1 scalars. Default is `-Inf`.
`upper` | (`numeric` | `expression`) Upper bounds. A singe value of length 1 is automatically replicated to `len` for vector parameters. If `len = NA` you can only pass length-1 scalars. Default is `Inf`.
`allow.inf` | (`logical(1)`) Allow infinite values for numeric and numericvector params to be feasible settings. Default is `FALSE`.
`default` | (any concrete value | `expression`) Default value used in learner. Note: When this is a discrete parameter make sure to use a VALUE here, not the NAME of the value. If this argument is missing, it means no default value is available.
`when` | (`character(1)`) Specifies when parameter is used in the learner: “train”, “predict” or “both”. Default is “train”.
`requires` | (`NULL` | `call` | `expression`) States requirements on other parameters' values, so that setting this parameter only makes sense if its requirements are satisfied (dependent parameter). Can be an object created either with `expression` or `quote`, the former type is auto-converted into the later. Only really useful if the parameter is included in a (ParamSet()). Default is `NULL` which means no requirements.
`tunable` | (`logical(1)`) Is this parameter tunable? Defining a parameter to be not-tunable allows to mark arguments like, e.g., “verbose” or other purely technical stuff. Note that this flag is most likely not respected by optimizing procedures unless stated otherwise. Default is `TRUE` (except for `untyped`, `function`, `character` and `characterVector`) which means it is tunable.
`special.vals` | (`list()`) A list of special values the parameter can except which are outside of the defined range. Default is an empty list.
`len` | (`integer(1)`) Length of vector parameter. Can be set to `NA` to define a vector with unspecified length.
`values` | (`vector` | `list` | `expression`) Possible discrete values. Instead of using a vector of atomic values, you are also allowed to pass a list of quite “complex” R objects, which are used as discrete choices. If you do the latter, the elements must be uniquely named, so that the names can be used as internal representations for the choice.

### Value

`LearnerParam()`.

[Package ParamHelpers version 1.14 Index]