460 lines
11 KiB
Go
460 lines
11 KiB
Go
package models
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
|
|
model_classes "git.andr3h3nriqu3s.com/andr3/fyp/logic/models/classes"
|
|
. "git.andr3h3nriqu3s.com/andr3/fyp/logic/models/utils"
|
|
"git.andr3h3nriqu3s.com/andr3/fyp/logic/utils"
|
|
. "git.andr3h3nriqu3s.com/andr3/fyp/logic/utils"
|
|
)
|
|
|
|
func handleJson(w http.ResponseWriter, r *http.Request, c *Context) *Error {
|
|
if !CheckAuthLevel(1, w, r, c) {
|
|
return nil
|
|
}
|
|
|
|
id, err := GetIdFromUrl(r, "id")
|
|
if err != nil {
|
|
return c.JsonBadRequest("Model not found")
|
|
}
|
|
|
|
type rowmodel struct {
|
|
Name string `json:"name"`
|
|
Status int `json:"status"`
|
|
Id string `json:"id"`
|
|
Width *int `json:"width"`
|
|
Height *int `json:"height"`
|
|
Color_mode *string `json:"color_mode"`
|
|
Format string `json:"format"`
|
|
Model_type int `json:"model_type"`
|
|
}
|
|
|
|
var model rowmodel = rowmodel{}
|
|
err = utils.GetDBOnce(c, &model, "models where id=$1 and user_id=$2", id, c.User.Id)
|
|
if err == NotFoundError {
|
|
return c.SendJSONStatus(404, "Model not found")
|
|
} else if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
|
|
return c.SendJSON(model)
|
|
|
|
/*
|
|
|
|
switch model.Status {
|
|
case TRAINING:
|
|
}
|
|
*/
|
|
}
|
|
|
|
func handleEdit(handle *Handle) {
|
|
handle.Get("/models/edit/classes", func(w http.ResponseWriter, r *http.Request, c *Context) *Error {
|
|
if !CheckAuthLevel(1, w, r, c) {
|
|
return nil
|
|
}
|
|
if c.Mode != JSON {
|
|
return c.ErrorCode(nil, 400, AnyMap{})
|
|
}
|
|
|
|
id, err := GetIdFromUrl(r, "id")
|
|
if err != nil {
|
|
return c.SendJSONStatus(http.StatusNotFound, "Model not found")
|
|
}
|
|
|
|
model, err := GetBaseModel(c.Db, id)
|
|
if err == ModelNotFoundError {
|
|
return c.SendJSONStatus(http.StatusNotFound, "Model not found")
|
|
} else if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
|
|
wrong_number, err := model_classes.GetNumberOfWrongDataPoints(c.Db, model.Id)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
|
|
cls, err := model_classes.ListClasses(c, id)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
|
|
has_data, err := model_classes.ModelHasDataPoints(handle.Db, id)
|
|
if err != nil {
|
|
return Error500(err)
|
|
}
|
|
|
|
type ReturnType struct {
|
|
Classes []*model_classes.ModelClass `json:"classes"`
|
|
HasData bool `json:"has_data"`
|
|
NumberOfInvalidImages int `json:"number_of_invalid_images"`
|
|
}
|
|
|
|
return c.SendJSON(ReturnType{
|
|
Classes: cls,
|
|
HasData: has_data,
|
|
NumberOfInvalidImages: wrong_number,
|
|
})
|
|
})
|
|
|
|
handle.Get("/models/edit/definitions", func(w http.ResponseWriter, r *http.Request, c *Context) *Error {
|
|
if !CheckAuthLevel(1, w, r, c) {
|
|
return nil
|
|
}
|
|
if c.Mode != JSON {
|
|
return c.ErrorCode(nil, 400, AnyMap{})
|
|
}
|
|
|
|
id, err := GetIdFromUrl(r, "id")
|
|
if err != nil {
|
|
return c.SendJSONStatus(http.StatusNotFound, "Model not found")
|
|
}
|
|
|
|
model, err := GetBaseModel(c.Db, id)
|
|
if err == ModelNotFoundError {
|
|
return c.SendJSONStatus(http.StatusNotFound, "Model not found")
|
|
} else if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
|
|
type defrow struct {
|
|
Id string
|
|
Status int
|
|
EpochProgress int
|
|
Epoch int
|
|
Accuracy float64
|
|
}
|
|
|
|
defs := []defrow{}
|
|
|
|
if model.ModelType == 2 {
|
|
def_rows, err := c.Db.Query("select md.id, md.status, md.epoch, h.epoch_progress, h.accuracy from model_definition as md inner join exp_model_head as h on h.def_id = md.id where md.model_id=$1 order by md.created_on asc", model.Id)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
defer def_rows.Close()
|
|
|
|
for def_rows.Next() {
|
|
var def defrow
|
|
err = def_rows.Scan(&def.Id, &def.Status, &def.Epoch, &def.EpochProgress, &def.Accuracy)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
defs = append(defs, def)
|
|
}
|
|
} else {
|
|
def_rows, err := c.Db.Query("select id, status, epoch, epoch_progress, accuracy from model_definition where model_id=$1 order by created_on asc", model.Id)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
defer def_rows.Close()
|
|
|
|
for def_rows.Next() {
|
|
var def defrow
|
|
err = def_rows.Scan(&def.Id, &def.Status, &def.Epoch, &def.EpochProgress, &def.Accuracy)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
defs = append(defs, def)
|
|
}
|
|
}
|
|
|
|
type layerdef struct {
|
|
id string
|
|
LayerType int `json:"layer_type"`
|
|
Shape string `json:"shape"`
|
|
}
|
|
|
|
layers := []layerdef{}
|
|
|
|
for _, def := range defs {
|
|
if def.Status == MODEL_DEFINITION_STATUS_TRAINING {
|
|
rows, err := c.Db.Query("select id, layer_type, shape from model_definition_layer where def_id=$1 order by layer_order asc;", def.Id)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var layerdef layerdef
|
|
err = rows.Scan(&layerdef.id, &layerdef.LayerType, &layerdef.Shape)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
layers = append(layers, layerdef)
|
|
}
|
|
|
|
if model.ModelType == 2 {
|
|
|
|
type lastLayerType struct {
|
|
Id string
|
|
Range_start int
|
|
Range_end int
|
|
}
|
|
|
|
var lastLayer lastLayerType
|
|
|
|
err := GetDBOnce(c, &lastLayer, "exp_model_head where def_id=$1 and status=3;", def.Id)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
|
|
layers = append(layers, layerdef{
|
|
id: lastLayer.Id,
|
|
LayerType: LAYER_DENSE,
|
|
Shape: fmt.Sprintf("%d, 1", lastLayer.Range_end-lastLayer.Range_start+1),
|
|
})
|
|
}
|
|
|
|
break
|
|
}
|
|
}
|
|
|
|
type Definitions struct {
|
|
Id string `json:"id"`
|
|
Status int `json:"status"`
|
|
EpochProgress int `json:"epoch_progress"`
|
|
Epoch int `json:"epoch"`
|
|
Accuracy float64 `json:"accuracy"`
|
|
Layers *[]layerdef `json:"layers"`
|
|
}
|
|
|
|
defsToReturn := make([]Definitions, len(defs), len(defs))
|
|
|
|
setLayers := false
|
|
|
|
for i, def := range defs {
|
|
var lay *[]layerdef = nil
|
|
if def.Status == MODEL_DEFINITION_STATUS_TRAINING && !setLayers {
|
|
lay = &layers
|
|
setLayers = true
|
|
}
|
|
defsToReturn[i] = Definitions{
|
|
Id: def.Id,
|
|
Status: def.Status,
|
|
EpochProgress: def.EpochProgress,
|
|
Epoch: def.Epoch,
|
|
Accuracy: def.Accuracy,
|
|
Layers: lay,
|
|
}
|
|
}
|
|
|
|
return c.SendJSON(defsToReturn)
|
|
})
|
|
|
|
handle.Get("/models/edit", func(w http.ResponseWriter, r *http.Request, c *Context) *Error {
|
|
if !CheckAuthLevel(1, w, r, c) {
|
|
return nil
|
|
}
|
|
|
|
if c.Mode == JSON {
|
|
return handleJson(w, r, c)
|
|
}
|
|
|
|
id, err := GetIdFromUrl(r, "id")
|
|
if err != nil {
|
|
return ErrorCode(nil, http.StatusNotFound, AnyMap{
|
|
"NotFoundMessage": "Model not found",
|
|
"GoBackLink": "/models",
|
|
})
|
|
}
|
|
|
|
// TODO handle admin users
|
|
rows, err := handle.Db.Query("select name, status, width, height, color_mode, format, model_type from models where id=$1 and user_id=$2;", id, c.User.Id)
|
|
if err != nil {
|
|
return Error500(err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
if !rows.Next() {
|
|
return ErrorCode(nil, http.StatusNotFound, AnyMap{
|
|
"NotFoundMessage": "Model not found",
|
|
"GoBackLink": "/models",
|
|
})
|
|
}
|
|
|
|
type rowmodel struct {
|
|
Name string
|
|
Status int
|
|
Id string
|
|
Width *int
|
|
Height *int
|
|
Color_mode *string
|
|
Format string
|
|
Type int
|
|
}
|
|
|
|
var model rowmodel = rowmodel{}
|
|
model.Id = id
|
|
|
|
err = rows.Scan(&model.Name, &model.Status, &model.Width, &model.Height, &model.Color_mode, &model.Format, &model.Type)
|
|
if err != nil {
|
|
return Error500(err)
|
|
}
|
|
|
|
// Handle errors
|
|
// All errors will be negative
|
|
if model.Status < 0 {
|
|
LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
|
|
"Model": model,
|
|
}))
|
|
return nil
|
|
}
|
|
|
|
switch model.Status {
|
|
case PREPARING:
|
|
LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
|
|
"Model": model,
|
|
}))
|
|
case CONFIRM_PRE_TRAINING:
|
|
|
|
wrong_number, err := model_classes.GetNumberOfWrongDataPoints(c.Db, model.Id)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
|
|
cls, err := model_classes.ListClasses(c, id)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
|
|
has_data, err := model_classes.ModelHasDataPoints(handle.Db, id)
|
|
if err != nil {
|
|
return Error500(err)
|
|
}
|
|
|
|
LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
|
|
"Model": model,
|
|
"Classes": cls,
|
|
"HasData": has_data,
|
|
"NumberOfInvalidImages": wrong_number,
|
|
}))
|
|
case READY:
|
|
LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
|
|
"Model": model,
|
|
}))
|
|
case TRAINING:
|
|
|
|
type defrow struct {
|
|
Id string
|
|
Status int
|
|
EpochProgress int
|
|
Epoch int
|
|
Accuracy float64
|
|
}
|
|
|
|
defs := []defrow{}
|
|
|
|
if model.Type == 2 {
|
|
def_rows, err := c.Db.Query("select md.id, md.status, md.epoch, h.epoch_progress, h.accuracy from model_definition as md inner join exp_model_head as h on h.def_id = md.id where md.model_id=$1 order by md.created_on asc", model.Id)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
defer def_rows.Close()
|
|
|
|
for def_rows.Next() {
|
|
var def defrow
|
|
err = def_rows.Scan(&def.Id, &def.Status, &def.Epoch, &def.EpochProgress, &def.Accuracy)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
defs = append(defs, def)
|
|
}
|
|
} else {
|
|
def_rows, err := c.Db.Query("select id, status, epoch, epoch_progress, accuracy from model_definition where model_id=$1 order by created_on asc", model.Id)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
defer def_rows.Close()
|
|
|
|
for def_rows.Next() {
|
|
var def defrow
|
|
err = def_rows.Scan(&def.Id, &def.Status, &def.Epoch, &def.EpochProgress, &def.Accuracy)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
defs = append(defs, def)
|
|
}
|
|
}
|
|
|
|
type layerdef struct {
|
|
id string
|
|
LayerType int
|
|
Shape string
|
|
}
|
|
|
|
layers := []layerdef{}
|
|
|
|
for _, def := range defs {
|
|
if def.Status == MODEL_DEFINITION_STATUS_TRAINING {
|
|
rows, err := c.Db.Query("select id, layer_type, shape from model_definition_layer where def_id=$1 order by layer_order asc;", def.Id)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var layerdef layerdef
|
|
err = rows.Scan(&layerdef.id, &layerdef.LayerType, &layerdef.Shape)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
layers = append(layers, layerdef)
|
|
}
|
|
|
|
if model.Type == 2 {
|
|
|
|
type lastLayerType struct {
|
|
Id string
|
|
Range_start int
|
|
Range_end int
|
|
}
|
|
|
|
var lastLayer lastLayerType
|
|
|
|
err := GetDBOnce(c, &lastLayer, "exp_model_head where def_id=$1 and status=3;", def.Id)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
|
|
layers = append(layers, layerdef{
|
|
id: lastLayer.Id,
|
|
LayerType: LAYER_DENSE,
|
|
Shape: fmt.Sprintf("%d, 1", lastLayer.Range_end-lastLayer.Range_start+1),
|
|
})
|
|
}
|
|
|
|
break
|
|
}
|
|
}
|
|
|
|
sep_mod := 100
|
|
if len(layers) > 8 {
|
|
sep_mod = 100 - (len(layers)-8)*10
|
|
}
|
|
|
|
if sep_mod < 10 {
|
|
sep_mod = 10
|
|
}
|
|
|
|
LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
|
|
"Model": model,
|
|
"Defs": defs,
|
|
"Layers": layers,
|
|
"SepMod": sep_mod,
|
|
}))
|
|
case PREPARING_ZIP_FILE:
|
|
LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
|
|
"Model": model,
|
|
}))
|
|
default:
|
|
fmt.Printf("Unkown Status: %d\n", model.Status)
|
|
return Error500(nil)
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
}
|