stuck on working with computeOutput function, getting dim error every

go.mod

@@ -18,7 +18,7 @@ require (
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fasthttp v1.49.0 // indirect
 	github.com/valyala/tcplisten v1.0.0 // indirect
-	golang.org/x/net v0.8.0 // indirect
-	golang.org/x/sys v0.12.0 // indirect
-	gonum.org/v1/gonum v0.9.1 // indirect
+	golang.org/x/net v0.17.0 // indirect
+	golang.org/x/sys v0.13.0 // indirect
+	gonum.org/v1/gonum v0.14.0 // indirect
 )

go.sum

@@ -55,6 +55,7 @@ golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20191002040644-a1355ae1e2c3 h1:n9HxLrNxWWtEb1cA950nuEEj3QnKbtsCJ6KjcgisNUs=
 golang.org/x/exp v0.0.0-20191002040644-a1355ae1e2c3/go.mod h1:NOZ3BPKG0ec/BKJQgnvsSFpcKLM5xXVWnvZS97DWHgE=
+golang.org/x/exp v0.0.0-20230321023759-10a507213a29 h1:ooxPy7fPvB4kwsA2h+iBNHkAbp/4JxTSwCmvdjEYmug=
 golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
@@ -71,6 +72,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/net v0.0.0-20210423184538-5f58ad60dda6/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
 golang.org/x/net v0.8.0 h1:Zrh2ngAOFYneWTAIAPethzeaQLuHwhuBkuV6ZiRnUaQ=
 golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
+golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
+golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -82,6 +85,8 @@ golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
+golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
@@ -95,6 +100,8 @@ gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJ
 gonum.org/v1/gonum v0.8.2/go.mod h1:oe/vMfY3deqTw+1EZJhuvEW2iwGF1bW9wwu7XCu0+v0=
 gonum.org/v1/gonum v0.9.1 h1:HCWmqqNoELL0RAQeKBXWtkp04mGk8koafcB4He6+uhc=
 gonum.org/v1/gonum v0.9.1/go.mod h1:TZumC3NeyVQskjXqmyWt4S3bINhy7B4eYwW69EbyX+0=
+gonum.org/v1/gonum v0.14.0 h1:2NiG67LD1tEH0D7kM+ps2V+fXmsAnpUeec7n8tcr4S0=
+gonum.org/v1/gonum v0.14.0/go.mod h1:AoWeoz0becf9QMWtE8iWXNXc27fK4fNeHNf/oMejGfU=
 gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0 h1:OE9mWmgKkjJyEmDAAtGMPjXu+YNeGvK9VTSHY6+Qihc=
 gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw=
 gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc=

nn/backprop.go

@@ -1,8 +1,99 @@
 package nn
 
+import (
+	"fmt"
+
+	"gonum.org/v1/gonum/mat"
+)
+
 func (nn *NN) Backprop() {
+	var (
+		activation = *nn.ActivationFunc
+		// lossHist   []float64
+	)
 
 	for i := 0; i < nn.Epochs; i++ {
+		// compute output with current w + b
+		// then compute loss & backprop
+		hiddenOutput, err := computeOutput(
+			nn.XTrain,
+			nn.Wh,
+			nn.Bh,
+			activation,
+		)
+		if err != nil {
+			fmt.Printf("error computing hidden output: %v", err)
+		}
+
+		yHat, err := computeOutput(
+			hiddenOutput,
+			nn.Wo,
+			nn.Bo,
+			activation,
+		)
+		if err != nil {
+			fmt.Printf("error computing yHat: %v", err)
+		}
+
+		mse := meanSquaredError(nn.YTrain, yHat)
+		fmt.Println(mse)
+
+	}
+
+}
+
+func computeOutput(arr, w, b *mat.Dense, activationFunc func(float64) float64) (*mat.Dense, error) {
+	// Check if any of the input matrices is nil
+	if arr == nil || w == nil || b == nil {
+		return nil, fmt.Errorf("Input matrices cannot be nil")
+	}
+
+	// Check input dimensions
+	arrRows, arrCols := arr.Dims()
+	wRows, wCols := w.Dims()
+	bRows, bCols := b.Dims()
+
+	if arrCols != wRows || bCols != wCols {
+		return nil, fmt.Errorf("Matrix dimension mismatch: arr[%d, %d], w[%d, %d], b[%d, %d]", arrRows, arrCols, wRows, wCols, bRows, bCols)
 	}
 
+	// Compute the dot product between the input matrix 'arr' and the weight matrix 'w'
+	var product mat.Dense
+	product.Mul(arr, w)
+
+	// Check dimensions of product and bias
+	productRows, productCols := product.Dims()
+	if productCols != bCols {
+		return nil, fmt.Errorf("Matrix dimension mismatch: product[%d, %d], b[%d, %d]", productRows, productCols, bRows, bCols)
+	}
+
+	// Add the bias matrix 'b' to the product
+	var result mat.Dense
+	result.Add(&product, b)
+
+	// Apply the activation function to the result
+	applyActivation(&result, activationFunc)
+
+	return &result, nil
+}
+
+func applyActivation(m *mat.Dense, f func(float64) float64) {
+	r, c := m.Dims()
+	data := m.RawMatrix().Data
+	for i := 0; i < r*c; i++ {
+		data[i] = f(data[i])
+	}
+}
+
+func meanSquaredError(y, yHat *mat.Dense) float64 {
+	var sum float64
+	r, c := y.Dims()
+
+	for row := 0; row < r; row++ {
+		for col := 0; col < c; col++ {
+			diff := y.At(row, col) - yHat.At(row, col)
+			sum += (diff * diff)
+		}
+	}
+	return sum / float64((r * c))
 }

nn/main.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/go-gota/gota/dataframe"
 	"github.com/gofiber/fiber/v2"
+	"gonum.org/v1/gonum/mat"
 )
 
 type NN struct {
@@ -23,14 +24,14 @@ type NN struct {
 	// attributes set after args above are parsed
 	ActivationFunc *func(float64) float64
 	Df             *dataframe.DataFrame
-	XTrain         *dataframe.DataFrame
-	YTrain         *dataframe.DataFrame
-	XTest          *dataframe.DataFrame
-	YTest          *dataframe.DataFrame
-	Wh             *[][]float64
-	Bh             *[]float64
-	Wo             *[][]float64
-	Bo             *[]float64
+	XTrain         *mat.Dense
+	YTrain         *mat.Dense
+	XTest          *mat.Dense
+	YTest          *mat.Dense
+	Wh             *mat.Dense
+	Bh             *mat.Dense
+	Wo             *mat.Dense
+	Bo             *mat.Dense
 }
 
 func NewNN(c *fiber.Ctx) (*NN, error) {
@@ -53,36 +54,31 @@ func (nn *NN) InitWnB() {
 	hiddenSize := nn.HiddenSize
 	outputSize := 1 // only predicting one thing
 
-	// input hidden layer weights
-	wh := make([][]float64, inputSize)
-	for i := range wh {
-		wh[i] = make([]float64, hiddenSize)
-		for j := range wh[i] {
-			wh[i][j] = rand.Float64() - 0.5
-		}
-	}
+	// Initialize input hidden layer weights as a Gonum matrix
+	wh := mat.NewDense(inputSize, hiddenSize, nil)
+	wh.Apply(func(i, j int, v float64) float64 {
+		return rand.Float64() - 0.5
+	}, wh)
 
-	bh := make([]float64, hiddenSize)
-	for i := range bh {
-		bh[i] = rand.Float64() - 0.5
-	}
+	// Initialize hidden layer bias as a Gonum matrix
+	bh := mat.NewDense(1, hiddenSize, nil)
+	bh.Apply(func(i, j int, v float64) float64 {
+		return rand.Float64() - 0.5
+	}, bh)
 
-	// initialize weights and biases for hidden -> output layer
-	wo := make([][]float64, hiddenSize)
-	for i := range wo {
-		wo[i] = make([]float64, outputSize)
-		for j := range wo[i] {
-			wo[i][j] = rand.Float64() - 0.5
-		}
-	}
+	// Initialize weights and biases for hidden -> output layer as Gonum matrices
+	wo := mat.NewDense(hiddenSize, outputSize, nil)
+	wo.Apply(func(i, j int, v float64) float64 {
+		return rand.Float64() - 0.5
+	}, wo)
 
-	bo := make([]float64, outputSize)
-	for i := range bo {
-		bo[i] = rand.Float64() - 0.5
-	}
+	bo := mat.NewDense(1, outputSize, nil)
+	bo.Apply(func(i, j int, v float64) float64 {
+		return rand.Float64() - 0.5
+	}, bo)
 
-	nn.Wh = &wh
-	nn.Bh = &bh
-	nn.Wo = &wo
-	nn.Bo = &bo
+	nn.Wh = wh
+	nn.Bh = bh
+	nn.Wo = wo
+	nn.Bo = bo
 }

nn/split.go

@@ -3,6 +3,9 @@ package nn
 import (
 	"math"
 	"math/rand"
+
+	"github.com/go-gota/gota/dataframe"
+	"gonum.org/v1/gonum/mat"
 )
 
 func (nn *NN) TrainTestSplit() {
@@ -34,9 +37,24 @@ func (nn *NN) TrainTestSplit() {
 	XTest := test.Select(nn.Features)
 	YTest := test.Select(nn.Target)
 
-	nn.XTrain = &XTrain
-	nn.YTrain = &YTrain
-	nn.XTest = &XTest
-	nn.YTest = &YTest
+	// to make linear algebra easier & faster,
+	// we convert these dataframes that we are
+	// performing potentially expensive computations
+	// on into gonum matrices since we no longer need the
+	// column names.
+	nn.XTrain = df2mat(&XTrain)
+	nn.YTrain = df2mat(&YTrain)
+	nn.XTest = df2mat(&XTest)
+	nn.YTest = df2mat(&YTest)
+}
 
+// df2mat -> converts gota dataframe into gonum matrix
+func df2mat(df *dataframe.DataFrame) *mat.Dense {
+	m := mat.NewDense(df.Nrow(), df.Ncol(), nil)
+	for i := 0; i < df.Nrow(); i++ {
+		for j := 0; j < df.Ncol(); j++ {
+			m.Set(i, j, df.Elem(i, j).Float())
+		}
+	}
+	return m
 }

nn/train.go

@@ -3,11 +3,5 @@ package nn
 func (nn *NN) Train() {
 	nn.InitWnB()
 	nn.TrainTestSplit()
-
-	// iterate n times where n = nn.Epochs
-	// use backprop algorithm on each iteration
-	// to fit the model to the data
-	for i := 0; i < nn.Epochs; i++ {
-	}
-
+	nn.Backprop()
 }

server.go

@@ -19,7 +19,6 @@ func main() {
 		}
 
 		nn.Train()
-
 		return c.SendString("No error")
 	})