Types

Node{T}

Node defines a symbolic expression stored in a binary tree. A single Node instance is one "node" of this tree, and has references to its children. By tracing through the children nodes, you can evaluate or print a given expression.

Fields

• degree::Int: Degree of the node. 0 for constants, 1 for unary operators, 2 for binary operators.
• constant::Bool: Whether the node is a constant.
• val::T: Value of the node. If degree==0, and constant==true, this is the value of the constant. It has a type specified by the overall type of the Node (e.g., Float64).
• feature::Int (optional): Index of the feature to use in the case of a feature node. Only used if degree==0 and constant==false. Only defined if degree == 0 && constant == false.
• op::Int: If degree==1, this is the index of the operator in operators.unaops. If degree==2, this is the index of the operator in operators.binops. In other words, this is an enum of the operators, and is dependent on the specific OperatorEnum object. Only defined if degree >= 1
• l::Node{T}: Left child of the node. Only defined if degree >= 1. Same type as the parent node.
• r::Node{T}: Right child of the node. Only defined if degree == 2. Same type as the parent node. This is to be passed as the right argument to the binary operator.

Node([::Type{T}]; val=nothing, feature::Int=nothing) where {T}

Create a leaf node: either a constant, or a variable.

Arguments:

• ::Type{T}, optionally specify the type of the node, if not already given by the type of val.
• val, if you are specifying a constant, pass the value of the constant here.
• feature::Integer, if you are specifying a variable, pass the index of the variable here.

Node(op::Int, l::Node)

Apply unary operator op (enumerating over the order given) to Node l

Node(op::Int, l::Node, r::Node)

Apply binary operator op (enumerating over the order given) to Nodes l and r

Node(var_string::String)

Create a variable node, using the format "x1" to mean feature 1

convert(::Type{Node{T1}}, n::Node{T2}) where {T1,T2}

Convert a Node{T2} to a Node{T1}. This will recursively convert all children nodes to Node{T1}, using convert(T1, tree.val) at constant nodes.

Arguments

• ::Type{Node{T1}}: Type to convert to.
• tree::Node{T2}: Node to convert.

set_node!(tree::Node{T}, new_tree::Node{T}) where {T}

Set every field of tree equal to the corresponding field of new_tree.

copy_node(tree::Node; preserve_topology::Bool=false)

Copy a node, recursively copying all children nodes. This is more efficient than the built-in copy. With preserve_topology=true, this will also preserve linkage between a node and multiple parents, whereas without, this would create duplicate child node copies.

Population(pop::Array{PopMember{T}, 1})

Create population from list of PopMembers.

Population(dataset::Dataset{T};
           npop::Int, nlength::Int=3, options::Options,
           nfeatures::Int)

Create random population and score them on the dataset.

Population(X::AbstractMatrix{T}, y::AbstractVector{T};
           npop::Int, nlength::Int=3,
           options::Options, nfeatures::Int)

Create random population and score them on the dataset.

PopMember(t::Node, score::T, loss::T)

Create a population member with a birth date at the current time.

Arguments

• t::Node: The tree for the population member.
• score::T: The score (normalized to a baseline, and offset by a complexity penalty)
• loss::T: The raw loss to assign.

PopMember(dataset::Dataset{T},
          t::Node, options::Options)

Create a population member with a birth date at the current time. Automatically compute the score for this tree.

Arguments

• dataset::Dataset{T}: The dataset to evaluate the tree on.
• t::Node: The tree for the population member.
• options::Options: What options to use.

HallOfFame(options::Options, ::Type{T}) where {T<:Real}

Create empty HallOfFame. The HallOfFame stores a list of PopMember objects in .members, which is enumerated by size (i.e., .members[1] is the constant solution). .exists is used to determine whether the particular member has been instantiated or not.

Arguments:

• options: Options containing specification about deterministic.
• T: Type of Nodes to use in the population. e.g., Float64.

Dataset{T<:Real}

Fields

• X::AbstractMatrix{T}: The input features, with shape (nfeatures, n).
• y::AbstractVector{T}: The desired output values, with shape (n,).
• n::Int: The number of samples.
• nfeatures::Int: The number of features.
• weighted::Bool: Whether the dataset is non-uniformly weighted.
• weights::Union{AbstractVector{T},Nothing}: If the dataset is weighted, these specify the per-sample weight (with shape (n,)).
• avg_y: The average value of y (weighted, if weights are passed).
• baseline_loss: The loss of a constant function which predicts the average value of y. This is loss-dependent and should be updated with update_baseline_loss!.
• varMap::Array{String,1}: The names of the features, with shape (nfeatures,).

Dataset(X::AbstractMatrix{T}, y::AbstractVector{T};
        weights::Union{AbstractVector{T}, Nothing}=nothing,
        varMap::Union{Array{String, 1}, Nothing}=nothing)

Construct a dataset to pass between internal functions.

update_baseline_loss!(dataset::Dataset{T}, options::Options) where {T<:Real}

Update the baseline loss of the dataset using the loss function specified in options.