re configured the Alg interface and the NN sttuct, now we have to work

alg/alg.go

@@ -1,5 +1,6 @@
 package alg
 
 type Alg interface {
+	New()
 	Train()
 }

nn/activation.go

@@ -0,0 +1,19 @@
+package nn
+
+var ActivationMap = map[string]func(){
+	"sigmoid": Sigmoid,
+	"tanh":    Tanh,
+	"relu":    Relu,
+}
+
+func Sigmoid() {}
+
+func SigmoidPrime() {}
+
+func Tanh() {}
+
+func TanhPrime() {}
+
+func Relu() {}
+
+func ReluPrime() {}

nn/args.go

@@ -0,0 +1,17 @@
+package nn
+
+type NNArgs struct {
+	epochs         int
+	hiddenSize     int
+	learningRate   float64
+	activationFunc func()
+}
+
+func NewArgs(argsMap map[string]interface{}) *NNArgs {
+	return &NNArgs{
+		epochs:         argsMap["epochs"].(int),
+		hiddenSize:     argsMap["hidden_size"].(int),
+		learningRate:   argsMap["learning_rate"].(float64),
+		activationFunc: argsMap["activation"].(func()),
+	}
+}

nn/main.go

@@ -1,11 +1,66 @@
 package nn
 
-import "github.com/Jensen-holm/ml-from-scratch/alg"
+import (
+	"fmt"
+
+	"github.com/Jensen-holm/ml-from-scratch/alg"
+	"github.com/Jensen-holm/ml-from-scratch/request"
+)
 
 type NN struct {
 	alg.Alg
+	args *NNArgs
 }
 
-func New(rp *RequestPayload) {
+func New(rp *request.Payload) (alg.Alg, error) {
+	// parse the args and make a new NN struct
+	nnArgs := make(map[string]interface{})
+	params := []string{
+		"epochs",
+		"activation",
+		"hidden_size",
+		"learning_rate",
+	}
+
+	for _, param := range params {
+		i, isIn := rp.Args[param]
+		if !isIn {
+			return nil, fmt.Errorf("user must specify %s", param)
+		}
+
+		switch param {
+		case "epochs":
+			if val, ok := i.(int); ok {
+				nnArgs[param] = val
+			} else {
+				return nil, fmt.Errorf("expected %s to be an int", param)
+			}
+		case "activation":
+			if val, ok := i.(string); ok {
+				nnArgs[param] = ActivationMap[val]
+			} else {
+				return nil, fmt.Errorf("expected %s to be a string", param)
+			}
+		case "hidden_size":
+			if val, ok := i.(int); ok {
+				nnArgs[param] = val
+			} else {
+				return nil, fmt.Errorf("expected %s to be an int", param)
+			}
+		case "learning_rate":
+			if val, ok := i.(float64); ok {
+				nnArgs[param] = val
+			} else {
+				return nil, fmt.Errorf("expected %s to be a float64", param)
+			}
+		default:
+			return nil, fmt.Errorf("unsupported parameter: %s", param)
+		}
+	}
+
+	args := NewArgs(nnArgs)
+	return &NN{
+		args: args,
+	}, nil
 
 }

request/request.go

@@ -8,15 +8,13 @@ import (
 )
 
 type Payload struct {
-	CSVData        string   `json:"csv_data"`
-	Features       []string `json:"features"`
-	Target         string   `json:"target"`
-	Epochs         int      `json:"epochs"`
-	HiddenSize     int      `json:"hidden_size"`
-	LearningRate   float64  `json:"learning_rate"`
-	ActivationFunc string   `json:"activation_func"`
+	CSVData   string   `json:"csv_data"`
+	Features  []string `json:"features"`
+	Target    string   `json:"target"`
+	Algorithm string   `json:"algorithm"`
 
-	Df dataframe.DataFrame
+	Args map[string]interface{} `json:"args"`
+	Df   dataframe.DataFrame
 }
 
 func (p *Payload) SetDf(df dataframe.DataFrame) {

server.go

@@ -1,9 +1,10 @@
 package main
 
 import (
-	"fmt"
 	"strings"
 
+	"github.com/Jensen-holm/ml-from-scratch/alg"
+	"github.com/Jensen-holm/ml-from-scratch/nn"
 	"github.com/Jensen-holm/ml-from-scratch/request"
 	"github.com/go-gota/gota/dataframe"
 	"github.com/gofiber/fiber/v2"
@@ -12,6 +13,10 @@ import (
 func main() {
 	app := fiber.New()
 
+	algMap := map[string]alg.Alg{
+		"neural_network": nn.NN,
+	}
+
 	app.Post("/", func(c *fiber.Ctx) error {
 		r := new(request.Payload)
 
@@ -25,7 +30,8 @@ func main() {
 		df := dataframe.ReadCSV(strings.NewReader(r.CSVData))
 		r.SetDf(df)
 
-		fmt.Println(r.Df)
+		a := algMap[r.Algorithm]
+		a.New(r)
 
 		return c.SendString("No error")
 	})