MaxHalford / xgp / 106

pending completion

Build # 106

Build Type

Pull #3

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/MaxHalford/xgp/commit/<a class=hub.com/MaxHalford/xgp/commit/<a class="double-link" href="https://git"><a class=hub.com/MaxHalford/xgp/commit/<a class="double-link" href="https://git"><a class=hub.com/MaxHalford/xgp/commit/<a class="double-link" href="https://git"><a class=hub.com/MaxHalford/xgp/commit/d3bcbe4eb8753de06bba036ed99c9189d2a877b8">d3bcbe4eb">&lt;a href=&quot;https://github.com/MaxHalford/xgp/commit/</a><a class="double-link" href="https://github.com/MaxHalford/xgp/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/MaxHalford/xgp/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/MaxHalford/xgp/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/MaxHalford/xgp/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/MaxHalford/xgp/commit/d3bcbe4eb8753de06bba036ed99c9189d2a877b8">d3bcbe4eb</a><a href="https://github.com/MaxHalford/xgp/commit/d3bcbe4eb8753de06bba036ed99c9189d2a877b8">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/MaxHalford/xgp/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/MaxHalford/xgp/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/MaxHalford/xgp/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/MaxHalford/xgp/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/MaxHalford/xgp/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/MaxHalford/xgp/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/MaxHalford/xgp/commit/d3bcbe4eb8753de06bba036ed99c9189d2a877b8&quot;&gt;d3bcbe4eb&lt;/a&gt;&lt;a href=&quot;https://github.com/MaxHalford/xgp/commit/d3bcbe4eb8753de06bba036ed99c9189d2a877b8&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/MaxHalford/xgp/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;dou... (continued)

Pull Request Pull Request #3:

Run Details

933 of 933 new or added lines in 25 files covered. (100.0%)

1103 of 2407 relevant lines covered (45.82%)

75.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

62.9

/estimator.go

package xgp

import (
        "errors"
        "fmt"
        "math/rand"
        "time"

        "github.com/MaxHalford/gago"
        "github.com/gosuri/uiprogress"

        "github.com/MaxHalford/xgp/metrics"
        "github.com/MaxHalford/xgp/op"
)

// An Estimator links all the different components together and can be used to
// train Programs on a dataset. You shouldn't instantiate this struct directly;
// instead you should use the Config struct and call it's NewEstimator method.
type Estimator struct {
        Config

        EvalMetric       metrics.Metric
        LossMetric       metrics.Metric
        Functions        []op.Operator
        Initializer      Initializer
        GA               *gago.GA
        PolishGA         *gago.GA
        PointMutation    PointMutation
        SubtreeMutation  SubtreeMutation
        HoistMutation    HoistMutation
        SubtreeCrossover SubtreeCrossover

        fm       map[uint][]op.Operator
        XTrain   [][]float64
        YTrain   []float64
        WTrain   []float64
        XVal     [][]float64
        YVal     []float64
        WVal     []float64
        nClasses int
}

// String representation of an Estimator.
func (est Estimator) String() string {
        return est.Config.String()
}

// BestProgram returns the Estimator's best obtained Program.
func (est Estimator) BestProgram() *Program {
        return est.GA.HallOfFame[0].Genome.(*Program)
}

// Fit an Estimator to a dataset.
func (est *Estimator) Fit(
        // Required arguments
        XTrain [][]float64,
        YTrain []float64,
        // Optional arguments (can safely be nil)
        WTrain []float64,
        XVal [][]float64,
        YVal []float64,
        WVal []float64,
        verbose bool,
) (prog Program, err error) {

        // Set the training set
        est.XTrain = XTrain
        est.YTrain = YTrain
        est.WTrain = WTrain

        // Set the validation set
        est.XVal = XVal
        est.YVal = YVal
        est.WVal = WVal

        // Count the number of classes if the task is classification
        if est.LossMetric.Classification() {
                // Check that the task to perform is not multi-class classification
                est.nClasses = countDistinct(YTrain)
                if est.nClasses > 2 {
                        return prog, errors.New("Multi-class classification is not supported")
                }
        }

        // Initialize the GA
        err = est.GA.Initialize()
        if err != nil {
                return prog, err
        }

        // Evolve the GA
        var (
                bar      *uiprogress.Bar
                progress *uiprogress.Progress
        )
        if verbose {
                var start = time.Now()
                progress = uiprogress.New()
                progress.Start()
                bar = progress.AddBar(int(est.NGenerations))
                bar.PrependCompleted()
                bar.AppendFunc(func(b *uiprogress.Bar) string {
                        // Add time spent
                        var message = fmtDuration(time.Since(start))
                        // Add training error
                        var (
                                best            = est.BestProgram()
                                yTrainPred, err = best.Predict(est.XTrain, est.EvalMetric.NeedsProbabilities())
                        )
                        if err != nil {
                                return ""
                        }
                        trainScore, err := est.EvalMetric.Apply(est.YTrain, yTrainPred, nil)
                        if err != nil {
                                return ""
                        }
                        message += fmt.Sprintf(", train %s: %.5f", est.EvalMetric.String(), trainScore)
                        // Add validation error
                        if est.XVal != nil && est.YVal != nil {
                                yEvalPred, err := best.Predict(est.XVal, est.EvalMetric.NeedsProbabilities())
                                if err != nil {
                                        return ""
                                }
                                evalScore, err := est.EvalMetric.Apply(est.YVal, yEvalPred, est.WVal)
                                if err != nil {
                                        return ""
                                }
                                message += fmt.Sprintf(", val %s: %.5f", est.EvalMetric.String(), evalScore)
                        }
                        return message
                })
        }

        for i := uint(0); i < est.NGenerations; i++ {
                if verbose {
                        bar.Incr()
                }

                // Make sure each tree has at least a height of 2
                /*for j, pop := range est.GA.Populations {
                        for k, indi := range pop.Individuals {
                                var prog = indi.Genome.(*Program)
                                if prog.Tree.Height() < 2 { // MAGIC
                                        est.SubtreeMutation.Apply(&prog.Tree, pop.RNG)
                                        est.GA.Populations[j].Individuals[k].Evaluate()
                                }
                        }
                }*/

                err = est.GA.Evolve()
                if err != nil {
                        return prog, err
                }
        }

        // Close the progress bar
        if verbose {
                progress.Stop()
        }

        // Return the best program
        var best = est.BestProgram()
        return *best, nil
}

func (est Estimator) newConst(rng *rand.Rand) op.Const {
        return op.Const{
                Value: est.Config.ConstMin + rng.Float64()*(est.Config.ConstMax-est.ConstMin),
        }
}

func (est Estimator) newVar(rng *rand.Rand) op.Var {
        return op.Var{Index: uint(rng.Intn(len(est.XTrain)))}
}

func (est Estimator) newFunction(rng *rand.Rand) op.Operator {
        return est.Functions[rng.Intn(len(est.Functions))]
}

func (est Estimator) newFunctionOfArity(arity uint, rng *rand.Rand) op.Operator {
        return est.fm[arity][rng.Intn(len(est.fm[arity]))]
}

func (est Estimator) newOperator(rng *rand.Rand) op.Operator {
        return est.Initializer.Apply(
                est.MinHeight,
                est.MaxHeight,
                func(leaf bool, rng *rand.Rand) op.Operator {
                        if leaf {
                                if rng.Float64() < est.PConst {
                                        return est.newConst(rng)
                                }
                                return est.newVar(rng)
                        }
                        return est.newFunction(rng)
                },
                rng,
        )
}

func (est Estimator) newProgram(rng *rand.Rand) Program {
        return Program{
                Op:        est.newOperator(rng),
                Estimator: &est,
        }
}

func (est Estimator) mutateOperator(operator op.Operator, rng *rand.Rand) op.Operator {
        switch operator.(type) {
        case op.Const:
                return op.Const{Value: operator.(op.Const).Value * rng.NormFloat64()}
        case op.Var:
                return est.newVar(rng)
        default:
                newOp := est.newFunctionOfArity(operator.Arity(), rng)
                // Don't forget to set the new Operator's operands
                for i := uint(0); i < operator.Arity(); i++ {
                        newOp = newOp.SetOperand(i, operator.Operand(i))
                }
                return newOp
        }
}

1	package xgp
2
3	import (
4	"errors"
5	"fmt"
6	"math/rand"
7	"time"
8
9	"github.com/MaxHalford/gago"
10	"github.com/gosuri/uiprogress"
11
12	"github.com/MaxHalford/xgp/metrics"
13	"github.com/MaxHalford/xgp/op"
14	)
15
16	// An Estimator links all the different components together and can be used to
17	// train Programs on a dataset. You shouldn't instantiate this struct directly;
18	// instead you should use the Config struct and call it's NewEstimator method.
19	type Estimator struct {
20	Config
21
22	EvalMetric metrics.Metric
23	LossMetric metrics.Metric
24	Functions []op.Operator
25	Initializer Initializer
26	GA *gago.GA
27	PolishGA *gago.GA
28	PointMutation PointMutation
29	SubtreeMutation SubtreeMutation
30	HoistMutation HoistMutation
31	SubtreeCrossover SubtreeCrossover
32
33	fm map[uint][]op.Operator
34	XTrain [][]float64
35	YTrain []float64
36	WTrain []float64
37	XVal [][]float64
38	YVal []float64
39	WVal []float64
40	nClasses int
41	}
42
43	// String representation of an Estimator.
44	func (est Estimator) String() string {	2✔
45	return est.Config.String()	2✔
46	}	2✔
47
48	// BestProgram returns the Estimator's best obtained Program.
49	func (est Estimator) BestProgram() *Program {	4✔
50	return est.GA.HallOfFame[0].Genome.(*Program)	4✔
51	}	4✔
52
53	// Fit an Estimator to a dataset.
54	func (est *Estimator) Fit(
55	// Required arguments
56	XTrain [][]float64,
57	YTrain []float64,
58	// Optional arguments (can safely be nil)
59	WTrain []float64,
60	XVal [][]float64,
61	YVal []float64,
62	WVal []float64,
63	verbose bool,
64	) (prog Program, err error) {	2✔
65		2✔
66	// Set the training set	2✔
67	est.XTrain = XTrain	2✔
68	est.YTrain = YTrain	2✔
69	est.WTrain = WTrain	2✔
70		2✔
71	// Set the validation set	2✔
72	est.XVal = XVal	2✔
73	est.YVal = YVal	2✔
74	est.WVal = WVal	2✔
75		2✔
76	// Count the number of classes if the task is classification	2✔
77	if est.LossMetric.Classification() {	2✔
78	// Check that the task to perform is not multi-class classification	×
79	est.nClasses = countDistinct(YTrain)	×
80	if est.nClasses > 2 {	×
81	return prog, errors.New("Multi-class classification is not supported")	×
82	}	×
83	}
84
85	// Initialize the GA
86	err = est.GA.Initialize()	2✔
87	if err != nil {	2✔
88	return prog, err	×
89	}	×
90
91	// Evolve the GA
92	var (	2✔
93	bar *uiprogress.Bar	2✔
94	progress *uiprogress.Progress	2✔
95	)	2✔
96	if verbose {	2✔
97	var start = time.Now()	×
98	progress = uiprogress.New()	×
99	progress.Start()	×
100	bar = progress.AddBar(int(est.NGenerations))	×
101	bar.PrependCompleted()	×
102	bar.AppendFunc(func(b *uiprogress.Bar) string {	×
103	// Add time spent	×
104	var message = fmtDuration(time.Since(start))	×
105	// Add training error	×
106	var (	×
107	best = est.BestProgram()	×
108	yTrainPred, err = best.Predict(est.XTrain, est.EvalMetric.NeedsProbabilities())	×
109	)	×
110	if err != nil {	×
111	return ""	×
112	}	×
113	trainScore, err := est.EvalMetric.Apply(est.YTrain, yTrainPred, nil)	×
114	if err != nil {	×
115	return ""	×
116	}	×
117	message += fmt.Sprintf(", train %s: %.5f", est.EvalMetric.String(), trainScore)	×
118	// Add validation error	×
119	if est.XVal != nil && est.YVal != nil {	×
120	yEvalPred, err := best.Predict(est.XVal, est.EvalMetric.NeedsProbabilities())	×
121	if err != nil {	×
122	return ""	×
123	}	×
124	evalScore, err := est.EvalMetric.Apply(est.YVal, yEvalPred, est.WVal)	×
125	if err != nil {	×
126	return ""	×
127	}	×
128	message += fmt.Sprintf(", val %s: %.5f", est.EvalMetric.String(), evalScore)	×
129	}
130	return message	×
131	})
132	}
133
134	for i := uint(0); i < est.NGenerations; i++ {	62✔
135	if verbose {	60✔
136	bar.Incr()	×
137	}	×
138
139	// Make sure each tree has at least a height of 2
140	/*for j, pop := range est.GA.Populations {
141	for k, indi := range pop.Individuals {
142	var prog = indi.Genome.(*Program)
143	if prog.Tree.Height() < 2 { // MAGIC
144	est.SubtreeMutation.Apply(&prog.Tree, pop.RNG)
145	est.GA.Populations[j].Individuals[k].Evaluate()
146	}
147	}
148	}*/
149
150	err = est.GA.Evolve()	60✔
151	if err != nil {	60✔
152	return prog, err	×
153	}	×
154	}
155
156	// Close the progress bar
157	if verbose {	2✔
158	progress.Stop()	×
159	}	×
160
161	// Return the best program
162	var best = est.BestProgram()	2✔
163	return *best, nil	2✔
164	}
165
166	func (est Estimator) newConst(rng *rand.Rand) op.Const {	374✔
167	return op.Const{	374✔
168	Value: est.Config.ConstMin + rng.Float64()*(est.Config.ConstMax-est.ConstMin),	374✔
169	}	374✔
170	}	374✔
171
172	func (est Estimator) newVar(rng *rand.Rand) op.Var {	508✔
173	return op.Var{Index: uint(rng.Intn(len(est.XTrain)))}	508✔
174	}	508✔
175
176	func (est Estimator) newFunction(rng *rand.Rand) op.Operator {	662✔
177	return est.Functions[rng.Intn(len(est.Functions))]	662✔
178	}	662✔
179
180	func (est Estimator) newFunctionOfArity(arity uint, rng *rand.Rand) op.Operator {	166✔
181	return est.fm[arity][rng.Intn(len(est.fm[arity]))]	166✔
182	}	166✔
183
184	func (est Estimator) newOperator(rng *rand.Rand) op.Operator {	132✔
185	return est.Initializer.Apply(	132✔
186	est.MinHeight,	132✔
187	est.MaxHeight,	132✔
188	func(leaf bool, rng *rand.Rand) op.Operator {	1,588✔
189	if leaf {	2,250✔
190	if rng.Float64() < est.PConst {	1,168✔
191	return est.newConst(rng)	374✔
192	}	374✔
193	return est.newVar(rng)	420✔
194	}
195	return est.newFunction(rng)	662✔
196	},
197	rng,
198	)
199	}
200
201	func (est Estimator) newProgram(rng *rand.Rand) Program {	40✔
202	return Program{	40✔
203	Op: est.newOperator(rng),	40✔
204	Estimator: &est,	40✔
205	}	40✔
206	}	40✔
207
208	func (est Estimator) mutateOperator(operator op.Operator, rng *rand.Rand) op.Operator {	366✔
209	switch operator.(type) {	366✔
210	case op.Const:	112✔
211	return op.Const{Value: operator.(op.Const).Value * rng.NormFloat64()}	112✔
212	case op.Var:	88✔
213	return est.newVar(rng)	88✔
214	default:	166✔
215	newOp := est.newFunctionOfArity(operator.Arity(), rng)	166✔
216	// Don't forget to set the new Operator's operands	166✔
217	for i := uint(0); i < operator.Arity(); i++ {	498✔
218	newOp = newOp.SetOperand(i, operator.Operand(i))	332✔
219	}	332✔
220	return newOp	166✔
221	}
222	}

MaxHalford / xgp / 106

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous