// build and run model
func main() {
// get options
var maxSize, maxDepth int
var trailFile string
flag.IntVar(&maxSize, "size", 0, "maximum tree size - zero for none")
flag.IntVar(&maxDepth, "depth", 0, "maximum tree depth - zero for none")
flag.StringVar(&trailFile, "trail", "santafe_trail.txt", "trail definition file")
opts := util.DefaultOptions
util.ParseFlags(&opts)
// create primitive set
config := readTrail(trailFile)
pset := gp.CreatePrimSet(0)
pset.Add(progN{&gp.BaseFunc{"prog2", 2}})
pset.Add(progN{&gp.BaseFunc{"prog3", 3}})
pset.Add(ifFood{&gp.BaseFunc{"if_food", 2}})
pset.Add(Terminal("left", turn(-1)))
pset.Add(Terminal("right", turn(1)))
pset.Add(Terminal("step", step))
// setup model
problem := &gp.Model{
PrimitiveSet: pset,
Generator: gp.GenFull(pset, 1, 2),
PopSize: opts.PopSize,
Fitness: fitnessFunc(config),
Offspring: gp.Tournament(opts.TournSize),
Mutate: gp.MutUniform(gp.GenFull(pset, 0, 2)),
MutateProb: opts.MutateProb,
Crossover: gp.CxOnePoint(),
CrossoverProb: opts.CrossoverProb,
Threads: opts.Threads,
}
if maxDepth > 0 {
problem.AddDecorator(gp.DepthLimit(maxDepth))
}
if maxSize > 0 {
problem.AddDecorator(gp.SizeLimit(maxSize))
}
problem.PrintParams("== Artificial ant ==")
logger := stats.NewLogger(opts.MaxGen, opts.TargetFitness)
if opts.Verbose {
logger.OnDone = func(best *gp.Individual) {
ant := run(config, best.Code)
fmt.Println(ant.grid)
}
}
// run
if opts.Plot {
logger.RegisterSVGPlot("best", createPlot(config, 500, 10))
stats.MainLoop(problem, logger, ":8080", "../web")
} else {
fmt.Println()
logger.PrintStats = true
logger.PrintBest = opts.Verbose
problem.Run(logger)
}
}
func Example_gp() {
// create initial population
gp.SetSeed(1)
pset := gp.CreatePrimSet(1, "x")
pset.Add(num.Add, num.Sub, num.Mul, num.Div, num.Neg, num.V(0), num.V(1))
generator := gp.GenFull(pset, 1, 3)
pop, evals := gp.CreatePopulation(500, generator).Evaluate(eval{}, 1)
best := pop.Best()
fmt.Printf("gen=%d evals=%d fit=%.4f\n", 0, evals, best.Fitness)
// setup genetic variations
tournament := gp.Tournament(3)
mutate := gp.MutUniform(gp.GenGrow(pset, 0, 2))
crossover := gp.CxOnePoint()
// loop till reach target fitness or exceed no. of generations
for gen := 1; gen <= 40 && best.Fitness < 1; gen++ {
offspring := tournament.Select(pop, len(pop))
pop, evals = gp.VarAnd(offspring, crossover, mutate, 0.5, 0.2).Evaluate(eval{}, 1)
best = pop.Best()
fmt.Printf("gen=%d evals=%d fit=%.4f\n", gen, evals, best.Fitness)
}
fmt.Println(best.Code.Format())
// Output:
// set random seed: 1
// gen=0 evals=500 fit=0.1203
// gen=1 evals=299 fit=0.3299
// gen=2 evals=286 fit=0.6633
// gen=3 evals=265 fit=0.6633
// gen=4 evals=280 fit=0.6633
// gen=5 evals=291 fit=0.6633
// gen=6 evals=302 fit=0.6633
// gen=7 evals=294 fit=1.0000
// (x + (((x / 1) - ((x / 1) * -(((x * x) + x)))) * (1 * x)))
}
func TestMutate(t *testing.T) {
// all possible mutations
mutset := map[string]bool{
"(9 + 4)": false,
"((9 + 4) + sqr(y))": false,
"(sqr((9 + 4)) + sqr(y))": false,
"(sqr(x) + (9 + 4))": false,
"(sqr(x) + sqr((9 + 4)))": false,
}
pset := initPset(true)
exprs := testExprs(pset)
before := gp.Individual{Code: exprs[1]}
add := exprs[0]
gen := genProxy{add}
t.Log("mutate: ", before.Code, "plus", gen.Generate().Code)
mut := gp.MutUniform(gen)
gp.SetSeed(1)
for i := 0; i < 10; i++ {
after := mut.Variate(gp.Population{before.Clone()})
t.Log("becomes:", after[0])
text := after[0].Code.Format()
if _, ok := mutset[text]; ok {
mutset[text] = true
} else {
t.Error("unexpected mutation", text)
}
}
for key, ok := range mutset {
if !ok {
t.Error("missing mutation", key)
}
}
}
func ExampleModel() {
gp.SetSeed(1)
pset := gp.CreatePrimSet(1, "x")
pset.Add(num.Add, num.Sub, num.Mul, num.Div, num.Neg, num.V(0), num.V(1))
problem := gp.Model{
PrimitiveSet: pset,
Generator: gp.GenFull(pset, 1, 3),
PopSize: 500,
Fitness: getFitness,
Offspring: gp.Tournament(3),
Mutate: gp.MutUniform(gp.GenGrow(pset, 0, 2)),
MutateProb: 0.2,
Crossover: gp.CxOnePoint(),
CrossoverProb: 0.5,
Threads: 1,
}
logger := &stats.Logger{MaxGen: 20, TargetFitness: 0.99, PrintStats: true}
problem.Run(logger)
// Output:
// set random seed: 1
// Gen Evals FitMax FitAvg FitStd SizeAvg SizeMax DepthAvg DepthMax
// 0 500 0.12 0.025 0.014 6.85 15 1.96 3
// 1 299 0.33 0.0344 0.0204 6.33 27 1.93 6
// 2 286 0.663 0.0469 0.0448 6.26 27 1.9 7
// 3 265 0.663 0.0598 0.0683 6.58 34 2.06 9
// 4 280 0.663 0.0772 0.088 7.51 39 2.39 9
// 5 291 0.663 0.0918 0.1 8.92 32 2.82 8
// 6 302 0.663 0.117 0.133 10.3 35 3.2 10
// 7 294 1 0.152 0.17 11.1 35 3.48 10
// ** SUCCESS **
}
// main GP routine
func main() {
opts := util.DefaultOptions
util.ParseFlags(&opts)
pset := gp.CreatePrimSet(PARITY_FANIN)
pset.Add(boolean.And, boolean.Or, boolean.Xor, boolean.Not, boolean.True, boolean.False)
problem := &gp.Model{
PrimitiveSet: pset,
Generator: gp.GenFull(pset, 3, 5),
PopSize: opts.PopSize,
Fitness: getFitnessFunc(),
Offspring: gp.Tournament(opts.TournSize),
Mutate: gp.MutUniform(gp.GenGrow(pset, 0, 2)),
MutateProb: opts.MutateProb,
Crossover: gp.CxOnePoint(),
CrossoverProb: opts.CrossoverProb,
Threads: opts.Threads,
}
problem.PrintParams("== Even parity problem for", PARITY_FANIN, "inputs ==")
logger := stats.NewLogger(opts.MaxGen, opts.TargetFitness)
if opts.Plot {
stats.MainLoop(problem, logger, ":8080", "../web")
} else {
fmt.Println()
logger.PrintStats = true
logger.PrintBest = opts.Verbose
problem.Run(logger)
}
}
// main GP routine
func main() {
// get options
var maxSize, maxDepth int
var dataFile string
flag.IntVar(&maxSize, "size", 0, "maximum tree size - zero for none")
flag.IntVar(&maxDepth, "depth", 0, "maximum tree depth - zero for none")
flag.StringVar(&dataFile, "trainset", "poly.dat", "file with training function")
opts := util.DefaultOptions
util.ParseFlags(&opts)
// create primitive set
ercMin, ercMax, trainSet := getData(dataFile)
pset := gp.CreatePrimSet(1, "x")
pset.Add(num.Add, num.Sub, num.Mul, num.Div)
pset.Add(num.Ephemeral("ERC", ercGen(ercMin, ercMax)))
// setup model
problem := &gp.Model{
PrimitiveSet: pset,
Generator: gp.GenRamped(pset, 1, 3),
PopSize: opts.PopSize,
Fitness: fitnessFunc(trainSet),
Offspring: gp.Tournament(opts.TournSize),
Mutate: gp.MutUniform(gp.GenGrow(pset, 0, 2)),
MutateProb: opts.MutateProb,
Crossover: gp.CxOnePoint(),
CrossoverProb: opts.CrossoverProb,
Threads: opts.Threads,
}
if maxDepth > 0 {
problem.AddDecorator(gp.DepthLimit(maxDepth))
}
if maxSize > 0 {
problem.AddDecorator(gp.SizeLimit(maxSize))
}
problem.PrintParams("== GP Symbolic Regression for ", dataFile, "==")
// run
logger := stats.NewLogger(opts.MaxGen, opts.TargetFitness)
if opts.Plot {
gp.GraphDPI = "60"
logger.RegisterPlot("graph", plotTarget(trainSet), plotBest(trainSet))
stats.MainLoop(problem, logger, ":8080", "../web")
} else {
fmt.Println()
logger.PrintStats = true
logger.PrintBest = opts.Verbose
problem.Run(logger)
}
}
// build and run model
func main() {
// get options
var maxSize, maxDepth int
var configFile string
flag.IntVar(&maxSize, "size", 0, "maximum tree size - zero for none")
flag.IntVar(&maxDepth, "depth", 0, "maximum tree depth - zero for none")
flag.StringVar(&configFile, "config", "desert.txt", "grid definition file")
opts := util.DefaultOptions
util.ParseFlags(&opts)
// create primitive set
grid := readGrid(configFile)
pset := gp.CreatePrimSet(0)
pset.Add(Terminal("x", func(ant *Ant) int { return ant.col }))
pset.Add(Terminal("y", func(ant *Ant) int { return ant.row }))
pset.Add(Terminal("carrying", func(ant *Ant) int { return ant.carrying }))
pset.Add(Terminal("color", func(ant *Ant) int { return ant.grid.cells[ant.row][ant.col].color }))
pset.Add(Terminal("go-n", move(0)))
pset.Add(Terminal("go-e", move(1)))
pset.Add(Terminal("go-s", move(2)))
pset.Add(Terminal("go-w", move(3)))
pset.Add(Terminal("go-rand", func(ant *Ant) int { return move(ant.grid.rng.Intn(4))(ant) }))
pset.Add(Terminal("pickup", pickUp))
pset.Add(IfElse("iflte", 4, ifLessThanOrEqual))
pset.Add(IfElse("ifltz", 3, ifLessThanZero))
pset.Add(IfElse("ifdrop", 2, ifDrop))
// setup model
problem := &gp.Model{
PrimitiveSet: pset,
Generator: gp.GenFull(pset, 1, 2),
PopSize: opts.PopSize,
Fitness: fitnessFunc(grid),
Offspring: gp.Tournament(opts.TournSize),
Mutate: gp.MutUniform(gp.GenFull(pset, 0, 2)),
MutateProb: opts.MutateProb,
Crossover: gp.CxOnePoint(),
CrossoverProb: opts.CrossoverProb,
Threads: opts.Threads,
}
if maxDepth > 0 {
problem.AddDecorator(gp.DepthLimit(maxDepth))
}
if maxSize > 0 {
problem.AddDecorator(gp.SizeLimit(maxSize))
}
problem.PrintParams("== Artificial ant ==")
logger := stats.NewLogger(opts.MaxGen, opts.TargetFitness)
if opts.Verbose {
logger.OnDone = func(best *gp.Individual) {
g, _ := run(grid, best.Code)
fmt.Println(g)
}
}
// run
if opts.Plot {
logger.RegisterSVGPlot("best", createPlot(grid, 500, 40))
stats.MainLoop(problem, logger, ":8080", "../web")
} else {
fmt.Println()
logger.PrintStats = true
logger.PrintBest = opts.Verbose
problem.Run(logger)
}
}