Linear regression on iris dataset with Gorgonia and gota

iris.csv

main.go

package main

import (
	"fmt"
	"log"
	"math"
	"os"

	"github.com/go-gota/gota/dataframe"
	"github.com/go-gota/gota/series"
	"gonum.org/v1/gonum/mat"
	"gorgonia.org/gorgonia"
	"gorgonia.org/tensor"
)

// https://www.kaggle.com/amarpandey/implementing-linear-regression-on-iris-dataset/notebook
//
func main() {
	xT, yT := getXY()
	g := gorgonia.NewGraph()
	x := gorgonia.NodeFromAny(g, xT, gorgonia.WithName("x"))
	y := gorgonia.NodeFromAny(g, yT, gorgonia.WithName("y"))
	theta := gorgonia.NewVector(
		g,
		gorgonia.Float64,
		gorgonia.WithName("theta"),
		gorgonia.WithShape(xT.Shape()[1]),
		gorgonia.WithInit(gorgonia.Uniform(0, 1)))

	pred := must(gorgonia.Mul(x, theta))

	// Gorgonia might delete values from nodes so we are going to save it
	// and print it out later
	var predicted gorgonia.Value
	gorgonia.Read(pred, &predicted)

	squaredError := must(gorgonia.Square(must(gorgonia.Sub(pred, y))))
	cost := must(gorgonia.Mean(squaredError))

	if _, err := gorgonia.Grad(cost, theta); err != nil {
		log.Fatalf("Failed to backpropagate: %v", err)
	}

	machine := gorgonia.NewTapeMachine(g, gorgonia.BindDualValues(theta))
	defer machine.Close()

	model := []gorgonia.ValueGrad{theta}
	solver := gorgonia.NewVanillaSolver(gorgonia.WithLearnRate(0.001))

	iter := 100000
	var err error
	for i := 0; i < iter; i++ {
		if err = machine.RunAll(); err != nil {
			fmt.Printf("Error during iteration: %v: %v\n", i, err)
			break
		}

		if err = solver.Step(model); err != nil {
			log.Fatal(err)
		}
		fmt.Printf("theta: %2.2f  Iter: %v Cost: %2.3f Accuracy: %2.2f \r",
			theta.Value(),
			i,
			cost.Value(),
			accuracy(predicted.Data().([]float64), y.Value().Data().([]float64)))

		machine.Reset() // Reset is necessary in a loop like this
	}
	fmt.Println("")

}

func accuracy(prediction, y []float64) float64 {
	var ok float64
	for i := 0; i < len(prediction); i++ {
		if math.Round(prediction[i]-y[i]) == 0 {
			ok += 1.0
		}
	}
	return ok / float64(len(y))
}

func getXY() (*tensor.Dense, *tensor.Dense) {
	f, err := os.Open("iris.csv")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	df := dataframe.ReadCSV(f)
	xDF := df.Drop("species")

	toValue := func(s series.Series) series.Series {
		records := s.Records()
		floats := make([]float64, len(records))
		for i, r := range records {
			switch r {
			case "setosa":
				floats[i] = 1
			case "virginica":
				floats[i] = 2
			case "versicolor":
				floats[i] = 3
			default:
				log.Fatalf("unknown iris: %v\n", r)
			}
		}
		return series.Floats(floats)
	}

	yDF := df.Select("species").Capply(toValue)
	numRows, _ := xDF.Dims()
	xDF = xDF.Mutate(series.New(one(numRows), series.Float, "bias"))
	fmt.Println(xDF.Describe())
	fmt.Println(yDF.Describe())

	xT := tensor.FromMat64(mat.DenseCopyOf(&matrix{xDF}))
	yT := tensor.FromMat64(mat.DenseCopyOf(&matrix{yDF}))
	// Get rid of the last dimension to create a vector
	yT.Reshape(numRows)
	return xT, yT
}

type matrix struct {
	dataframe.DataFrame
}

func (m matrix) At(i, j int) float64 {
	return m.Elem(i, j).Float()
}

func (m matrix) T() mat.Matrix {
	return mat.Transpose{Matrix: m}
}

func must(n *gorgonia.Node, err error) *gorgonia.Node {
	if err != nil {
		panic(err)
	}
	return n
}

func one(size int) []float64 {
	one := make([]float64, size)
	for i := 0; i < size; i++ {
		one[i] = 1.0
	}
	return one
}

normal.go

package main

import (
	"fmt"
	"log"
	"os"

	"github.com/go-gota/gota/dataframe"
	"github.com/go-gota/gota/series"
	"gonum.org/v1/gonum/mat"
)

func main() {
	fa := mat.Formatted(getThetaNormal(), mat.Prefix("   "), mat.Squeeze())
	fmt.Printf("ϴ: %v\n", fa)
}

func getXYMat() (*mat.Dense, *mat.Dense) {
	f, err := os.Open("iris.csv")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	df := dataframe.ReadCSV(f)
	xDF := df.Drop("species")

	toValue := func(s series.Series) series.Series {
		records := s.Records()
		floats := make([]float64, len(records))
		for i, r := range records {
			switch r {
			case "setosa":
				floats[i] = 1
			case "virginica":
				floats[i] = 2
			case "versicolor":
				floats[i] = 3
			default:
				log.Fatalf("unknown iris: %v\n", r)
			}
		}
		return series.Floats(floats)
	}

	yDF := df.Select("species").Capply(toValue)
	numRows, _ := xDF.Dims()
	xDF = xDF.Mutate(series.New(one(numRows), series.Float, "bias"))
	fmt.Println(xDF.Describe())
	fmt.Println(yDF.Describe())

	return mat.DenseCopyOf(&matrix{xDF}), mat.DenseCopyOf(&matrix{yDF})
}
func one(size int) []float64 {
	one := make([]float64, size)
	for i := 0; i < size; i++ {
		one[i] = 1.0
	}
	return one
}

func getThetaNormal() *mat.Dense {
	x, y := getXYMat()
	xt := mat.DenseCopyOf(x).T()
	var xtx mat.Dense
	xtx.Mul(xt, x)
	var invxtx mat.Dense
	invxtx.Inverse(&xtx)
	var xty mat.Dense
	xty.Mul(xt, y)
	var output mat.Dense
	output.Mul(&invxtx, &xty)

	return &output
}

type matrix struct {
	dataframe.DataFrame
}

func (m matrix) At(i, j int) float64 {
	return m.Elem(i, j).Float()
}

func (m matrix) T() mat.Matrix {
	return mat.Transpose{Matrix: m}
}

result.txt

[7x6] DataFrame

    column   sepal_length sepal_width petal_length petal_width bias
 0: mean     5.843333     3.054000    3.758667     1.198667    1.000000
 1: stddev   0.828066     0.433594    1.764420     0.763161    0.000000
 2: min      4.300000     2.000000    1.000000     0.100000    1.000000
 3: 25%      5.100000     2.800000    1.600000     0.300000    1.000000
 4: 50%      5.800000     3.000000    4.300000     1.300000    1.000000
 5: 75%      6.400000     3.300000    5.100000     1.800000    1.000000
 6: max      7.900000     4.400000    6.900000     2.500000    1.000000
    <string> <float>      <float>     <float>      <float>     <float>

[7x2] DataFrame

    column   species
 0: mean     2.000000
 1: stddev   0.819232
 2: min      1.000000
 3: 25%      1.000000
 4: 50%      2.000000
 5: 75%      3.000000
 6: max      3.000000
    <string> <float>

ϴ: ⎡-0.08718768910924979⎤
   ⎢ -0.6831785613306529⎥
   ⎢ 0.44128274494996056⎥
   ⎢-0.41983988087491575⎥
   ⎣  3.4405073828555714⎦

sample_output.txt

[7x6] DataFrame

    column   sepal_length sepal_width petal_length petal_width bias
 0: mean     5.843333     3.054000    3.758667     1.198667    1.000000
 1: stddev   0.828066     0.433594    1.764420     0.763161    0.000000
 2: min      4.300000     2.000000    1.000000     0.100000    1.000000
 3: 25%      5.100000     2.800000    1.600000     0.300000    1.000000
 4: 50%      5.800000     3.000000    4.300000     1.300000    1.000000
 5: 75%      6.400000     3.300000    5.100000     1.800000    1.000000
 6: max      7.900000     4.400000    6.900000     2.500000    1.000000
    <string> <float>      <float>     <float>      <float>     <float>

[7x2] DataFrame

    column   species
 0: mean     2.000000
 1: stddev   0.819232
 2: min      1.000000
 3: 25%      1.000000
 4: 50%      2.000000
 5: 75%      3.000000
 6: max      3.000000
    <string> <float>

theta: [-0.00  -0.63   0.43  -0.45   2.86]  Iter: 99999 Cost: 0.289 Accuracy: 0.58