significantly decreased the complexity of the API by deciding to make

seperate endpoints for each kind of model moving forward, and also
skipping the requet struct we had made and going straight to the
algorithm.

example/main.go

@@ -9,13 +9,11 @@ import (
 )
 
 type RequestPayload 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"`
+	Args      map[string]interface{}
 }
 
 func main() {
@@ -30,19 +28,18 @@ func main() {
 	csvString := string(csvBytes)
 	features := []string{"petal length", "sepal length", "sepal width", "petal width"}
 	target := "species"
-	epochs := 100
-	hiddenSize := 8
-	learningRate := 0.1
-	activationFunc := "tanh"
+	args := map[string]interface{}{
+		"epochs":        100,
+		"hidden_size":   8,
+		"learning_rate": 0.1,
+		"activation":    "tanh",
+	}
 
 	payload := RequestPayload{
-		CSVData:        csvString,
-		Features:       features,
-		Target:         target,
-		Epochs:         epochs,
-		HiddenSize:     hiddenSize,
-		LearningRate:   learningRate,
-		ActivationFunc: activationFunc,
+		CSVData:  csvString,
+		Features: features,
+		Target:   target,
+		Args:     args,
 	}
 
 	jsonPayload, err := json.Marshal(payload)

nn/main.go

@@ -2,65 +2,29 @@ package nn
 
 import (
 	"fmt"
+	"strings"
 
-	"github.com/Jensen-holm/ml-from-scratch/alg"
-	"github.com/Jensen-holm/ml-from-scratch/request"
+	"github.com/go-gota/gota/dataframe"
+	"github.com/gofiber/fiber/v2"
 )
 
 type NN struct {
-	alg.Alg
-	args *NNArgs
+	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"`
+	Df             dataframe.DataFrame
 }
 
-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",
+func NewNN(c *fiber.Ctx) (*NN, error) {
+	newNN := new(NN)
+	err := c.BodyParser(newNN)
+	if err != nil {
+		return nil, fmt.Errorf("invalid JSON data: %v", err)
 	}
-
-	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
-
+	newNN.Df = dataframe.ReadCSV(strings.NewReader(newNN.CSVData))
+	return newNN, nil
 }

request/request.go

@@ -1,29 +0,0 @@
-package request
-
-import (
-	"fmt"
-
-	"github.com/go-gota/gota/dataframe"
-	"github.com/gofiber/fiber/v2"
-)
-
-type Payload struct {
-	CSVData   string   `json:"csv_data"`
-	Features  []string `json:"features"`
-	Target    string   `json:"target"`
-	Algorithm string   `json:"algorithm"`
-
-	Args map[string]interface{} `json:"args"`
-	Df   dataframe.DataFrame
-}
-
-func (p *Payload) SetDf(df dataframe.DataFrame) {
-	p.Df = df
-}
-
-func NewPayload(dest *Payload, c *fiber.Ctx) error {
-	if err := c.BodyParser(dest); err != nil {
-		return fmt.Errorf("invalid JSON data")
-	}
-	return nil
-}

server.go

@@ -1,41 +1,26 @@
 package main
 
 import (
-	"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"
 )
 
 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)
+	// eventually we might want to add a key to this endpoint
+	// that we will be able to validate.
+	app.Post("/neural-network", func(c *fiber.Ctx) error {
 
-		err := request.NewPayload(r, c)
+		nn, err := nn.NewNN(c)
 		if err != nil {
 			return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
-				"error": "Invalid JSON data",
+				"error": err,
 			})
 		}
 
-		df := dataframe.ReadCSV(strings.NewReader(r.CSVData))
-		r.SetDf(df)
-
-		a := algMap[r.Algorithm]
-		a.New(r)
-
 		return c.SendString("No error")
 	})
 
 	app.Listen(":3000")
-
 }