using ExprOptimization, Random
const grammar = @grammar begin
R = x
R = R * R
R = R + R
end
1: R = x 2: R = R * R 3: R = R + R
Sample a random derivation tree
Random.seed!(1)
tree = rand(RuleNode, grammar, :R, 4)
display(tree, grammar)
Get the expression encoded by the tree
ex = get_executable(tree, grammar)
:((x * x + (x + x)) + x)
const S = SymbolTable(grammar)
Dict{Symbol,Any} with 2 entries: :+ => + :* => *
Define ground truth expression for symbolic regression and the loss function.
ground_truth(x) = x^3 + x^2 + x
function loss(tree::RuleNode, grammar::Grammar)
ex = get_executable(tree, grammar)
los = 0.0
for x = -5.0:0.5:5.0
S[:x] = x
los += abs2(Core.eval(S,ex) - ground_truth(x))
end
los
end
loss (generic function with 1 method)
Monte Carlo optimization
?MonteCarlo
search: MonteCarlo MonteCarlos
MonteCarlo
Monte Carlo.
num_samples::Int
: number of samplesmax_depth::Int
: maximum depth of derivation treeRandom.seed!(1)
p = MonteCarlo(10000, 5)
results1 = optimize(p, grammar, :R, loss)
(results1.expr, results1.loss)
(:(x * (x + x * x) + x), 0.0)
Genetic Programming optimization
?GeneticProgram
search: GeneticProgram GeneticPrograms
GeneticProgram
Genetic Programming.
pop_size::Int
: population sizeiterations::Int
: number of iterationsmax_depth::Int
: maximum depth of derivation treep_reproduction::Float64
: probability of reproduction operatorp_crossover::Float64
: probability of crossover operatorp_mutation::Float64
: probability of mutation operatorinit_method::InitializationMethod
: initialization methodselect_method::SelectionMethod
: selection methodRandom.seed!(1)
p = GeneticProgram(1000,10,5,0.3,0.3,0.4)
results2 = optimize(p, grammar, :R, loss)
(results2.expr, results2.loss)
(:(x * (x + x * x) + x), 0.0)
?GrammaticalEvolution
search: GrammaticalEvolution GrammaticalEvolutions
GrammaticalEvolution
Grammatical Evolution.
grammar::Grammar
: grammartyp::Symbol
: start symbolpop_size::Int
: population sizeiterations::Int
: number of iterationsinit_gene_length::Int
: initial length of genotype integer arraymax_gene_length::Int
: maximum length of genotype integer arraymax_depth::Int
: maximum depth of derivation treep_reproduction::Float64
: probability of reproduction operatorp_crossover::Float64
: probability of crossover operatorp_mutation::Float64
: probability of mutation operatorselect_method::SelectionMethod
: selection method (default: tournament selection)mutate_method::InitializationMethod
: mutation method (default: multi-mutate)Random.seed!(1)
p = GrammaticalEvolution(grammar,:R,1000,10,10,10,5,0.3,0.3,0.4; select_method=GrammaticalEvolutions.TruncationSelection(250))
results3 = optimize(p, grammar, :R, loss)
(results3.expr, results3.loss)
(:(x + (x + x * x) * x), 0.0)
?CrossEntropy
search: CrossEntropy CrossEntropys
CrossEntropy
Cross Entropy method.
pop_size::Int
: population sizeiterations::Int
: number of iterationsmax_depth::Int
: maximum depth of derivation treetop_k::Int
: top k elite samples used in selectionp_init::Float64
: initial value when fitting MLEinit_method::InitializationMethod
: Initialization methodRandom.seed!(1)
p = CrossEntropy(1000,10,5,500)
results3 = optimize(p, grammar, :R, loss)
(results3.expr, results3.loss)
(:((x + x * (x * x)) + x * x), 0.0)
?PIPE
search: PIPE PIPEs Pipe pipeline PipeBuffer partialsortperm partialsortperm!
PIPE
Probabilistic Incremental Program Evolution. Example parameters from paper are indicated in parentheses)
ppt_params::PPT
: parameters for PPT (e.g., [0.8, 0.2])pop_size::Int
: population sizeiterations::Int
: number of iterationsp_elitist::Float64
: elitist update probability (e.g., 0.2)c::Float64
: learning rate multiplier (e.g., 0.1)α::Float64
: learning rate (e.g., 0.05)ϵ::Float64
: fitness constant (e.g., 1)p_mutation::Float64
: mutation probability (e.g., 0.2)β::Float64
: mutation rate (e.g., 0.6)p_threshold::Float64
: prune threshold (e.g., 0.999)max_depth::Int
: maximum depth of derivation treeRandom.seed!(0)
p = PIPE(PPT(0.8),1000,10,0.2,0.1,0.05,1,0.2,0.6,0.999,10)
results4 = optimize(p, grammar, :R, loss)
(results4.expr, results4.loss)
(:((x + x * x) * x + x), 0.0)