func TestPruning(testEnv *testing.T) { inst, err := base.ParseCSVToInstances("../examples/datasets/iris_headers.csv", true) if err != nil { panic(err) } trainData, testData := base.InstancesTrainTestSplit(inst, 0.6) filt := filters.NewChiMergeFilter(inst, 0.90) filt.AddAllNumericAttributes() filt.Build() fmt.Println(testData) filt.Run(testData) filt.Run(trainData) root := NewRandomTree(2) fittrainData, fittestData := base.InstancesTrainTestSplit(trainData, 0.6) root.Fit(fittrainData) root.Prune(fittestData) fmt.Println(root) predictions := root.Predict(testData) fmt.Println(predictions) confusionMat := eval.GetConfusionMatrix(testData, predictions) fmt.Println(confusionMat) fmt.Println(eval.GetMacroPrecision(confusionMat)) fmt.Println(eval.GetMacroRecall(confusionMat)) fmt.Println(eval.GetSummary(confusionMat)) }
func main() { // Load in a dataset, with headers. Header attributes will be stored. // Think of instances as a Data Frame structure in R or Pandas. // You can also create instances from scratch. rawData, err := base.ParseCSVToInstances("datasets/iris.csv", false) if err != nil { panic(err) } // Print a pleasant summary of your data. fmt.Println(rawData) //Initialises a new KNN classifier cls := knn.NewKnnClassifier("euclidean", 2) //Do a training-test split trainData, testData := base.InstancesTrainTestSplit(rawData, 0.50) cls.Fit(trainData) //Calculates the Euclidean distance and returns the most popular label predictions := cls.Predict(testData) fmt.Println(predictions) // Prints precision/recall metrics confusionMat, err := evaluation.GetConfusionMatrix(testData, predictions) if err != nil { panic(fmt.Sprintf("Unable to get confusion matrix: %s", err.Error())) } fmt.Println(evaluation.GetSummary(confusionMat)) }
func TestRandomForest1(testEnv *testing.T) { inst, err := base.ParseCSVToInstances("../examples/datasets/iris_headers.csv", true) if err != nil { panic(err) } rand.Seed(time.Now().UnixNano()) trainData, testData := base.InstancesTrainTestSplit(inst, 0.6) filt := filters.NewChiMergeFilter(inst, 0.90) for _, a := range base.NonClassFloatAttributes(inst) { filt.AddAttribute(a) } filt.Train() trainDataf := base.NewLazilyFilteredInstances(trainData, filt) testDataf := base.NewLazilyFilteredInstances(testData, filt) rf := new(BaggedModel) for i := 0; i < 10; i++ { rf.AddModel(trees.NewRandomTree(2)) } rf.Fit(trainDataf) fmt.Println(rf) predictions := rf.Predict(testDataf) fmt.Println(predictions) confusionMat := eval.GetConfusionMatrix(testDataf, predictions) fmt.Println(confusionMat) fmt.Println(eval.GetMacroPrecision(confusionMat)) fmt.Println(eval.GetMacroRecall(confusionMat)) fmt.Println(eval.GetSummary(confusionMat)) }
func main() { var tree base.Classifier rand.Seed(time.Now().UTC().UnixNano()) // Load in the iris dataset iris, err := base.ParseCSVToInstances("../datasets/iris_headers.csv", true) if err != nil { panic(err) } // Discretise the iris dataset with Chi-Merge filt := filters.NewChiMergeFilter(iris, 0.99) filt.AddAllNumericAttributes() filt.Build() filt.Run(iris) // Create a 60-40 training-test split insts := base.InstancesTrainTestSplit(iris, 0.60) // // First up, use ID3 // tree = trees.NewID3DecisionTree(0.6) // (Parameter controls train-prune split.) // Train the ID3 tree tree.Fit(insts[0]) // Generate predictions predictions := tree.Predict(insts[1]) // Evaluate fmt.Println("ID3 Performance") cf := eval.GetConfusionMatrix(insts[1], predictions) fmt.Println(eval.GetSummary(cf)) // // Next up, Random Trees // // Consider two randomly-chosen attributes tree = trees.NewRandomTree(2) tree.Fit(insts[0]) predictions = tree.Predict(insts[1]) fmt.Println("RandomTree Performance") cf = eval.GetConfusionMatrix(insts[1], predictions) fmt.Println(eval.GetSummary(cf)) // // Finally, Random Forests // tree = ensemble.NewRandomForest(100, 3) tree.Fit(insts[0]) predictions = tree.Predict(insts[1]) fmt.Println("RandomForest Performance") cf = eval.GetConfusionMatrix(insts[1], predictions) fmt.Println(eval.GetSummary(cf)) }
func TestPredict(t *testing.T) { a := NewAveragePerceptron(10, 1.2, 0.5, 0.3) if a == nil { t.Errorf("Unable to create average perceptron") } absPath, _ := filepath.Abs("../examples/datasets/house-votes-84.csv") rawData, err := base.ParseCSVToInstances(absPath, true) if err != nil { t.Fail() } trainData, testData := base.InstancesTrainTestSplit(rawData, 0.5) a.Fit(trainData) if a.trained == false { t.Errorf("Perceptron was not trained") } predictions := a.Predict(testData) cf, err := evaluation.GetConfusionMatrix(testData, predictions) if err != nil { t.Errorf("Couldn't get confusion matrix: %s", err) t.Fail() } fmt.Println(evaluation.GetSummary(cf)) fmt.Println(trainData) fmt.Println(testData) if evaluation.GetAccuracy(cf) < 0.65 { t.Errorf("Perceptron not trained correctly") } }
func main() { var tree base.Classifier rand.Seed(44111342) // Load in the iris dataset iris, err := base.ParseCSVToInstances("/home/kralli/go/src/github.com/sjwhitworth/golearn/examples/datasets/iris_headers.csv", true) if err != nil { panic(err) } // Discretise the iris dataset with Chi-Merge filt := filters.NewChiMergeFilter(iris, 0.999) for _, a := range base.NonClassFloatAttributes(iris) { filt.AddAttribute(a) } filt.Train() irisf := base.NewLazilyFilteredInstances(iris, filt) // Create a 60-40 training-test split //testData trainData, _ := base.InstancesTrainTestSplit(iris, 0.60) findBestSplit(trainData) //fmt.Println(trainData) //fmt.Println(testData) fmt.Println(tree) fmt.Println(irisf) }
func TestRandomForest1(testEnv *testing.T) { inst, err := base.ParseCSVToInstances("../examples/datasets/iris_headers.csv", true) if err != nil { panic(err) } rand.Seed(time.Now().UnixNano()) insts := base.InstancesTrainTestSplit(inst, 0.6) filt := filters.NewChiMergeFilter(inst, 0.90) filt.AddAllNumericAttributes() filt.Build() filt.Run(insts[1]) filt.Run(insts[0]) rf := new(BaggedModel) for i := 0; i < 10; i++ { rf.AddModel(trees.NewRandomTree(2)) } rf.Fit(insts[0]) fmt.Println(rf) predictions := rf.Predict(insts[1]) fmt.Println(predictions) confusionMat := eval.GetConfusionMatrix(insts[1], predictions) fmt.Println(confusionMat) fmt.Println(eval.GetMacroPrecision(confusionMat)) fmt.Println(eval.GetMacroRecall(confusionMat)) fmt.Println(eval.GetSummary(confusionMat)) }
func TestLinearRegression(t *testing.T) { lr := NewLinearRegression() rawData, err := base.ParseCSVToInstances("../examples/datasets/exams.csv", true) if err != nil { t.Fatal(err) } trainData, testData := base.InstancesTrainTestSplit(rawData, 0.1) err = lr.Fit(trainData) if err != nil { t.Fatal(err) } predictions, err := lr.Predict(testData) if err != nil { t.Fatal(err) } _, rows := predictions.Size() for i := 0; i < rows; i++ { fmt.Printf("Expected: %s || Predicted: %s\n", base.GetClass(testData, i), base.GetClass(predictions, i)) } }
func TestLinearRegression(t *testing.T) { Convey("Doing a linear regression", t, func() { lr := NewLinearRegression() Convey("With no training data", func() { Convey("Predicting", func() { testData, err := base.ParseCSVToInstances("../examples/datasets/exams.csv", true) So(err, ShouldBeNil) _, err = lr.Predict(testData) Convey("Should result in a NoTrainingDataError", func() { So(err, ShouldEqual, NoTrainingDataError) }) }) }) Convey("With not enough training data", func() { trainingDatum, err := base.ParseCSVToInstances("../examples/datasets/exam.csv", true) So(err, ShouldBeNil) Convey("Fitting", func() { err = lr.Fit(trainingDatum) Convey("Should result in a NotEnoughDataError", func() { So(err, ShouldEqual, NotEnoughDataError) }) }) }) Convey("With sufficient training data", func() { instances, err := base.ParseCSVToInstances("../examples/datasets/exams.csv", true) So(err, ShouldBeNil) trainData, testData := base.InstancesTrainTestSplit(instances, 0.1) Convey("Fitting and Predicting", func() { err := lr.Fit(trainData) So(err, ShouldBeNil) predictions, err := lr.Predict(testData) So(err, ShouldBeNil) Convey("It makes reasonable predictions", func() { _, rows := predictions.Size() for i := 0; i < rows; i++ { actualValue, _ := strconv.ParseFloat(base.GetClass(testData, i), 64) expectedValue, _ := strconv.ParseFloat(base.GetClass(predictions, i), 64) So(actualValue, ShouldAlmostEqual, expectedValue, actualValue*0.05) } }) }) }) }) }
// Fit builds the ID3 decision tree func (t *ID3DecisionTree) Fit(on base.FixedDataGrid) error { if t.PruneSplit > 0.001 { trainData, testData := base.InstancesTrainTestSplit(on, t.PruneSplit) t.Root = InferID3Tree(trainData, t.Rule) t.Root.Prune(testData) } else { t.Root = InferID3Tree(on, t.Rule) } return nil }
func TestRandomTreeClassificationWithoutDiscretisation(t *testing.T) { Convey("Predictions on filtered data with a Random Tree", t, func() { instances, err := base.ParseCSVToInstances("../examples/datasets/iris_headers.csv", true) So(err, ShouldBeNil) trainData, testData := base.InstancesTrainTestSplit(instances, 0.6) verifyTreeClassification(trainData, testData) }) }
// Fit builds the ID3 decision tree func (t *ID3DecisionTree) Fit(on *base.Instances) { rule := new(InformationGainRuleGenerator) if t.PruneSplit > 0.001 { insts := base.InstancesTrainTestSplit(on, t.PruneSplit) t.Root = InferID3Tree(insts[0], rule) t.Root.Prune(insts[1]) } else { t.Root = InferID3Tree(on, rule) } }
// Fit builds the ID3 decision tree func (t *ID3DecisionTree) Fit(on base.FixedDataGrid) { rule := new(InformationGainRuleGenerator) if t.PruneSplit > 0.001 { trainData, testData := base.InstancesTrainTestSplit(on, t.PruneSplit) t.Root = InferID3Tree(trainData, rule) t.Root.Prune(testData) } else { t.Root = InferID3Tree(on, rule) } }
func BenchmarkFit(b *testing.B) { a := NewAveragePerceptron(10, 1.2, 0.5, 0.3) absPath, _ := filepath.Abs("../examples/datasets/house-votes-84.csv") rawData, _ := base.ParseCSVToInstances(absPath, true) trainData, _ := base.InstancesTrainTestSplit(rawData, 0.5) b.ResetTimer() for i := 0; i < b.N; i++ { a.Fit(trainData) } }
func main() { data, err := base.ParseCSVToInstances("iris_headers.csv", true) if err != nil { panic(err) } cls := knn.NewKnnClassifier("euclidean", 2) trainData, testData := base.InstancesTrainTestSplit(data, 0.8) cls.Fit(trainData) predictions := cls.Predict(testData) fmt.Println(predictions) confusionMat := evaluation.GetConfusionMatrix(testData, predictions) fmt.Println(evaluation.GetSummary(confusionMat)) }
func TestRandomTreeClassificationAfterDiscretisation(t *testing.T) { Convey("Predictions on filtered data with a Random Tree", t, func() { instances, err := base.ParseCSVToInstances("../examples/datasets/iris_headers.csv", true) So(err, ShouldBeNil) trainData, testData := base.InstancesTrainTestSplit(instances, 0.6) filter := filters.NewChiMergeFilter(instances, 0.9) for _, a := range base.NonClassFloatAttributes(instances) { filter.AddAttribute(a) } filter.Train() filteredTrainData := base.NewLazilyFilteredInstances(trainData, filter) filteredTestData := base.NewLazilyFilteredInstances(testData, filter) verifyTreeClassification(filteredTrainData, filteredTestData) }) }
func TestMultiSVMUnweighted(t *testing.T) { Convey("Loading data...", t, func() { inst, err := base.ParseCSVToInstances("../examples/datasets/articles.csv", false) So(err, ShouldBeNil) X, Y := base.InstancesTrainTestSplit(inst, 0.4) m := NewMultiLinearSVC("l1", "l2", true, 1.0, 1e-4, nil) m.Fit(X) Convey("Predictions should work...", func() { predictions, err := m.Predict(Y) cf, err := evaluation.GetConfusionMatrix(Y, predictions) So(err, ShouldEqual, nil) So(evaluation.GetAccuracy(cf), ShouldBeGreaterThan, 0.70) }) }) }
func NewTestTrial(filename string, split float64) bool { cls := knn.NewKnnClassifier("euclidean", 2) data := CSVtoKNNData(filename) train, test := base.InstancesTrainTestSplit(data, split) cls.Fit(train) //Calculates the Euclidean distance and returns the most popular label predictions := cls.Predict(test) fmt.Println(predictions) confusionMat, err := evaluation.GetConfusionMatrix(test, predictions) if err != nil { panic(fmt.Sprintf("Unable to get confusion matrix: %s", err.Error())) } fmt.Println(evaluation.GetSummary(confusionMat)) return true }
func TestRandomForest(t *testing.T) { Convey("Given a valid CSV file", t, func() { inst, err := base.ParseCSVToInstances("../examples/datasets/iris_headers.csv", true) So(err, ShouldBeNil) Convey("When Chi-Merge filtering the data", func() { filt := filters.NewChiMergeFilter(inst, 0.90) for _, a := range base.NonClassFloatAttributes(inst) { filt.AddAttribute(a) } filt.Train() instf := base.NewLazilyFilteredInstances(inst, filt) Convey("Splitting the data into test and training sets", func() { trainData, testData := base.InstancesTrainTestSplit(instf, 0.60) Convey("Fitting and predicting with a Random Forest", func() { rf := NewRandomForest(10, 3) err = rf.Fit(trainData) So(err, ShouldBeNil) predictions, err := rf.Predict(testData) So(err, ShouldBeNil) confusionMat, err := evaluation.GetConfusionMatrix(testData, predictions) So(err, ShouldBeNil) Convey("Predictions should be somewhat accurate", func() { So(evaluation.GetAccuracy(confusionMat), ShouldBeGreaterThan, 0.35) }) }) }) }) Convey("Fitting with a Random Forest with too many features compared to the data", func() { rf := NewRandomForest(10, len(base.NonClassAttributes(inst))+1) err = rf.Fit(inst) Convey("Should return an error", func() { So(err, ShouldNotBeNil) }) }) }) }
func TestRandomForest1(testEnv *testing.T) { inst, err := base.ParseCSVToInstances("../examples/datasets/iris_headers.csv", true) if err != nil { panic(err) } trainData, testData := base.InstancesTrainTestSplit(inst, 0.60) filt := filters.NewChiMergeFilter(trainData, 0.90) filt.AddAllNumericAttributes() filt.Build() filt.Run(testData) filt.Run(trainData) rf := NewRandomForest(10, 3) rf.Fit(trainData) predictions := rf.Predict(testData) fmt.Println(predictions) confusionMat := eval.GetConfusionMatrix(testData, predictions) fmt.Println(confusionMat) fmt.Println(eval.GetSummary(confusionMat)) }
func TestProcessData(t *testing.T) { absPath, _ := filepath.Abs("../examples/datasets/house-votes-84.csv") rawData, err := base.ParseCSVToInstances(absPath, true) trainData, _ := base.InstancesTrainTestSplit(rawData, 0.5) if err != nil { t.Fatal("Could not test processData. Could not load CSV") } if rawData == nil { t.Fatal("Could not test processData. Could not load CSV") } result := processData(trainData) _, size := trainData.Size() if len(result) != size { t.Errorf("Expected %d, Got %d", size, len(result)) } }
func main() { rawData, err := base.ParseCSVToInstances("../datasets/iris_headers.csv", true) if err != nil { panic(err) } //Initialises a new KNN classifier cls := knn.NewKnnClassifier("euclidean", 2) //Do a training-test split trainData, testData := base.InstancesTrainTestSplit(rawData, 0.50) cls.Fit(trainData) //Calculates the Euclidean distance and returns the most popular label predictions := cls.Predict(testData) fmt.Println(predictions) // Prints precision/recall metrics confusionMat := evaluation.GetConfusionMatrix(testData, predictions) fmt.Println(evaluation.GetSummary(confusionMat)) }
func TestMultiSVMWeighted(t *testing.T) { Convey("Loading data...", t, func() { weights := make(map[string]float64) weights["Finance"] = 0.1739 weights["Tech"] = 0.0750 weights["Politics"] = 0.4928 inst, err := base.ParseCSVToInstances("../examples/datasets/articles.csv", false) So(err, ShouldBeNil) X, Y := base.InstancesTrainTestSplit(inst, 0.4) m := NewMultiLinearSVC("l1", "l2", true, 0.62, 1e-4, weights) m.Fit(X) Convey("Predictions should work...", func() { predictions, err := m.Predict(Y) cf, err := evaluation.GetConfusionMatrix(Y, predictions) So(err, ShouldEqual, nil) So(evaluation.GetAccuracy(cf), ShouldBeGreaterThan, 0.70) }) }) }
func TestOneVsAllModel(t *testing.T) { classifierFunc := func(c string) base.Classifier { m, err := linear_models.NewLinearSVC("l1", "l2", true, 1.0, 1e-4) if err != nil { panic(err) } return m } Convey("Given data", t, func() { inst, err := base.ParseCSVToInstances("../examples/datasets/iris_headers.csv", true) So(err, ShouldBeNil) X, Y := base.InstancesTrainTestSplit(inst, 0.4) m := NewOneVsAllModel(classifierFunc) m.Fit(X) Convey("The maximum class index should be 2", func() { So(m.maxClassVal, ShouldEqual, 2) }) Convey("There should be three of everything...", func() { So(len(m.filters), ShouldEqual, 3) So(len(m.classifiers), ShouldEqual, 3) }) Convey("Predictions should work...", func() { predictions, err := m.Predict(Y) So(err, ShouldEqual, nil) cf, err := evaluation.GetConfusionMatrix(Y, predictions) So(err, ShouldEqual, nil) fmt.Println(evaluation.GetAccuracy(cf)) fmt.Println(evaluation.GetSummary(cf)) }) }) }
func TestBaggedModelRandomForest(t *testing.T) { Convey("Given data", t, func() { inst, err := base.ParseCSVToInstances("../examples/datasets/iris_headers.csv", true) So(err, ShouldBeNil) Convey("Splitting the data into training and test data", func() { trainData, testData := base.InstancesTrainTestSplit(inst, 0.6) Convey("Filtering the split datasets", func() { rand.Seed(time.Now().UnixNano()) filt := filters.NewChiMergeFilter(inst, 0.90) for _, a := range base.NonClassFloatAttributes(inst) { filt.AddAttribute(a) } filt.Train() trainDataf := base.NewLazilyFilteredInstances(trainData, filt) testDataf := base.NewLazilyFilteredInstances(testData, filt) Convey("Fitting and Predicting with a Bagged Model of 10 Random Trees", func() { rf := new(BaggedModel) for i := 0; i < 10; i++ { rf.AddModel(trees.NewRandomTree(2)) } rf.Fit(trainDataf) predictions := rf.Predict(testDataf) confusionMat, err := evaluation.GetConfusionMatrix(testDataf, predictions) So(err, ShouldBeNil) Convey("Predictions are somewhat accurate", func() { So(evaluation.GetAccuracy(confusionMat), ShouldBeGreaterThan, 0.5) }) }) }) }) }) }
func TestLinearRegression(t *testing.T) { lr := NewLinearRegression() rawData, err := base.ParseCSVToInstances("../examples/datasets/exams.csv", true) if err != nil { t.Fatal(err) } trainData, testData := base.InstancesTrainTestSplit(rawData, 0.1) err = lr.Fit(trainData) if err != nil { t.Fatal(err) } predictions, err := lr.Predict(testData) if err != nil { t.Fatal(err) } for i := 0; i < predictions.Rows; i++ { fmt.Printf("Expected: %f || Predicted: %f\n", testData.Get(i, testData.ClassIndex), predictions.Get(i, predictions.ClassIndex)) } }
func TestFit(t *testing.T) { a := NewAveragePerceptron(10, 1.2, 0.5, 0.3) if a == nil { t.Errorf("Unable to create average perceptron") } absPath, _ := filepath.Abs("../examples/datasets/house-votes-84.csv") rawData, err := base.ParseCSVToInstances(absPath, true) if err != nil { t.Fail() } trainData, _ := base.InstancesTrainTestSplit(rawData, 0.7) a.Fit(trainData) if a.trained == false { t.Errorf("Perceptron was not trained") } }
func TestRandomTreeClassification2(testEnv *testing.T) { inst, err := base.ParseCSVToInstances("../examples/datasets/iris_headers.csv", true) if err != nil { panic(err) } insts := base.InstancesTrainTestSplit(inst, 0.4) filt := filters.NewChiMergeFilter(inst, 0.90) filt.AddAllNumericAttributes() filt.Build() fmt.Println(insts[1]) filt.Run(insts[1]) filt.Run(insts[0]) root := NewRandomTree(2) root.Fit(insts[0]) fmt.Println(root) predictions := root.Predict(insts[1]) fmt.Println(predictions) confusionMat := eval.GetConfusionMatrix(insts[1], predictions) fmt.Println(confusionMat) fmt.Println(eval.GetMacroPrecision(confusionMat)) fmt.Println(eval.GetMacroRecall(confusionMat)) fmt.Println(eval.GetSummary(confusionMat)) }
func TestRandomForest1(testEnv *testing.T) { inst, err := base.ParseCSVToInstances("../examples/datasets/iris_headers.csv", true) if err != nil { panic(err) } filt := filters.NewChiMergeFilter(inst, 0.90) for _, a := range base.NonClassFloatAttributes(inst) { filt.AddAttribute(a) } filt.Train() instf := base.NewLazilyFilteredInstances(inst, filt) trainData, testData := base.InstancesTrainTestSplit(instf, 0.60) rf := NewRandomForest(10, 3) rf.Fit(trainData) predictions := rf.Predict(testData) fmt.Println(predictions) confusionMat := eval.GetConfusionMatrix(testData, predictions) fmt.Println(confusionMat) fmt.Println(eval.GetSummary(confusionMat)) }
func TestID3Classification(testEnv *testing.T) { inst, err := base.ParseCSVToInstances("../examples/datasets/iris_headers.csv", true) if err != nil { panic(err) } filt := filters.NewBinningFilter(inst, 10) filt.AddAllNumericAttributes() filt.Build() filt.Run(inst) fmt.Println(inst) trainData, testData := base.InstancesTrainTestSplit(inst, 0.70) // Build the decision tree rule := new(InformationGainRuleGenerator) root := InferID3Tree(trainData, rule) fmt.Println(root) predictions := root.Predict(testData) fmt.Println(predictions) confusionMat := eval.GetConfusionMatrix(testData, predictions) fmt.Println(confusionMat) fmt.Println(eval.GetMacroPrecision(confusionMat)) fmt.Println(eval.GetMacroRecall(confusionMat)) fmt.Println(eval.GetSummary(confusionMat)) }