convert WITH clause to xgboost params (#780)

* with clause to xgboost params

* with clause to xgboost parameters

* remove unused code

* update by comment

Author: Yancey0623

sql/codegen.go

@@ -51,27 +51,33 @@ type modelConfig struct {
 	IsKerasModel        bool
 }
 
-type featureMeta struct {
+// FeatureMeta describes feature column meta data
+type FeatureMeta struct {
 	FeatureName string
 	Dtype       string
 	Delimiter   string
 	InputShape  string
 	IsSparse    bool
 }
 
-type filler struct {
+// Estimator describes estimator meta data
+type Estimator struct {
 	IsTrain              bool
 	TrainingDatasetSQL   string // IsTrain == true
 	ValidationDatasetSQL string // IsTrain == true
 	PredictionDatasetSQL string // IsTrain != true
-	X                    []*featureMeta
-	FeatureColumnsCode   map[string][]string
-	Y                    *featureMeta
+	X                    []*FeatureMeta
+	Y                    *FeatureMeta
 	TableName            string
-	modelConfig
 	*connectionConfig
 }
 
+type tfFiller struct {
+	Estimator
+	modelConfig
+	FeatureColumnsCode map[string][]string
+}
+
 // parseModelURI returns isKerasModel, modelClassString
 func parseModelURI(modelString string) (bool, string) {
 	if strings.HasPrefix(modelString, "sqlflow_models.") {
@@ -87,14 +93,16 @@ func trainingAndValidationDataset(pr *extendedSelect, ds *trainAndValDataset) (s
 	return pr.standardSelect.String(), pr.standardSelect.String()
 }
 
-func newFiller(pr *extendedSelect, ds *trainAndValDataset, fts fieldTypes, db *DB) (*filler, error) {
+func newFiller(pr *extendedSelect, ds *trainAndValDataset, fts fieldTypes, db *DB) (*tfFiller, error) {
 	isKerasModel, modelClassString := parseModelURI(pr.estimator)
 	training, validation := trainingAndValidationDataset(pr, ds)
-	r := &filler{
-		IsTrain:              pr.train,
-		TrainingDatasetSQL:   training,
-		ValidationDatasetSQL: validation,
-		PredictionDatasetSQL: pr.standardSelect.String(),
+	r := &tfFiller{
+		Estimator: Estimator{
+			IsTrain:              pr.train,
+			TrainingDatasetSQL:   training,
+			ValidationDatasetSQL: validation,
+			PredictionDatasetSQL: pr.standardSelect.String(),
+		},
 		modelConfig: modelConfig{
 			EstimatorCode: modelClassString,
 			BatchSize:     1,
@@ -148,7 +156,7 @@ func newFiller(pr *extendedSelect, ds *trainAndValDataset, fts fieldTypes, db *D
 					isSparse = true
 				}
 			}
-			fm := &featureMeta{
+			fm := &FeatureMeta{
 				FeatureName: col.GetKey(),
 				Dtype:       col.GetDtype(),
 				Delimiter:   col.GetDelimiter(),
@@ -202,7 +210,7 @@ func newFiller(pr *extendedSelect, ds *trainAndValDataset, fts fieldTypes, db *D
 			log.Fatalf("Unsupported label data type: %s", v)
 		}
 	}
-	r.Y = &featureMeta{
+	r.Y = &FeatureMeta{
 		FeatureName: pr.label,
 		Dtype:       labelDtype,
 		Delimiter:   ",",

sql/codegen_analyze.go

@@ -21,13 +21,13 @@ import (
 
 type analyzeFiller struct {
 	*connectionConfig
-	X                 []*featureMeta
+	X                 []*FeatureMeta
 	Label             string
 	AnalyzeDatasetSQL string
 	ModelFile         string // path/to/model_file
 }
 
-func newAnalyzeFiller(pr *extendedSelect, db *DB, fms []*featureMeta, label, modelPath string) (*analyzeFiller, error) {
+func newAnalyzeFiller(pr *extendedSelect, db *DB, fms []*FeatureMeta, label, modelPath string) (*analyzeFiller, error) {
 	conn, err := newConnectionConfig(db)
 	if err != nil {
 		return nil, err
@@ -43,22 +43,22 @@ func newAnalyzeFiller(pr *extendedSelect, db *DB, fms []*featureMeta, label, mod
 	}, nil
 }
 
-func readAntXGBFeatures(pr *extendedSelect, db *DB) ([]*featureMeta, string, error) {
+func readAntXGBFeatures(pr *extendedSelect, db *DB) ([]*FeatureMeta, string, error) {
 	// TODO(weiguo): It's a quick way to read column and label names from
 	// xgboost.*, but too heavy.
 	fr, err := newAntXGBoostFiller(pr, nil, db)
 	if err != nil {
 		return nil, "", err
 	}
 
-	xs := make([]*featureMeta, len(fr.X))
+	xs := make([]*FeatureMeta, len(fr.X))
 	for i := 0; i < len(fr.X); i++ {
 		// FIXME(weiguo): we convert xgboost.X to normal(tf).X to reuse
 		// DB access API, but I don't think it is a good practice,
 		// Think about the AI engines increased, such as ALPS, (EDL?)
 		// we should write as many as such converters.
 		// How about we unify all featureMetas?
-		xs[i] = &featureMeta{
+		xs[i] = &FeatureMeta{
 			FeatureName: fr.X[i].FeatureName,
 			Dtype:       fr.X[i].Dtype,
 			Delimiter:   fr.X[i].Delimiter,

sql/codegen_xgboost.go

@@ -14,41 +14,110 @@
 package sql
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
+	"strconv"
+	"strings"
 	"text/template"
+
+	"github.com/asaskevich/govalidator"
 )
 
 type xgbTrainConfig struct {
-	NumBoostRound int  `json:"num_boost_round,omitempty"`
-	Maximize      bool `json:"maximize,omitempty"`
+	NumBoostRound       int
+	Maximize            bool
+	EarlyStoppingRounds int
 }
 
 type xgbFiller struct {
-	IsTrain              bool
-	TrainingDatasetSQL   string
-	ValidationDatasetSQL string
-	TrainCfg             *xgbTrainConfig
-	Features             []*featureMeta
-	Label                *featureMeta
-	Save                 string
-	ParamsCfgJSON        string
-	TrainCfgJSON         string
-	*connectionConfig
+	Estimator
+	xgbTrainConfig
+	Save          string
+	ParamsCfgJSON string
+}
+
+func resolveTrainCfg(attrs map[string]*attribute) *xgbTrainConfig {
+	return &xgbTrainConfig{
+		NumBoostRound:       getIntAttr(attrs, "train.num_boost_round", 10),
+		Maximize:            getBoolAttr(attrs, "train.maximize", false, false),
+		EarlyStoppingRounds: getIntAttr(attrs, "train.early_stopping_rounds", -1),
+	}
 }
 
-func newXGBFiller(pr *extendedSelect, ds *trainAndValDataset, fts fieldTypes, db *DB) (*xgbFiller, error) {
+func resolveParamsCfg(attrs map[string]*attribute) (map[string]interface{}, error) {
+	// extract the attributes without any prefix as the XGBoost Parmaeters
+	params := make(map[string]interface{})
 	var err error
+	for k, v := range attrs {
+		if !strings.Contains(k, ".") {
+			var vStr string
+			var ok bool
+			if vStr, ok = v.Value.(string); !ok {
+				return nil, fmt.Errorf("convert params %s to string failed, %v", vStr, err)
+			}
+			if govalidator.IsFloat(vStr) {
+				floatVal, err := strconv.ParseFloat(vStr, 16)
+				if err != nil {
+					return nil, fmt.Errorf("convert params %s to float32 failed, %v", vStr, err)
+				}
+				params[k] = floatVal
+			} else if govalidator.IsInt(vStr) {
+				if params[k], err = strconv.ParseInt(vStr, 0, 32); err != nil {
+					return nil, fmt.Errorf("convert params %s to int32 failed, %v", vStr, err)
+				}
+			} else if govalidator.IsASCII(vStr) {
+				params[k] = vStr
+			} else {
+				return nil, fmt.Errorf("unsupported params type: %s", vStr)
+			}
+		}
+	}
+	return params, nil
+}
+
+func resolveObjective(pr *extendedSelect) (string, error) {
+	estimatorParts := strings.Split(pr.estimator, ".")
+	if len(estimatorParts) != 3 {
+		return "", fmt.Errorf("XGBoost Estimator should be xgboost.first_part.second_part")
+	}
+	return strings.Join(estimatorParts[1:], ":"), nil
+}
+
+func newXGBFiller(pr *extendedSelect, ds *trainAndValDataset, db *DB) (*xgbFiller, error) {
+	attrs, err := resolveAttribute(&pr.trainAttrs)
+	if err != nil {
+		return nil, err
+	}
 	training, validation := trainingAndValidationDataset(pr, ds)
 	r := &xgbFiller{
-		IsTrain:              pr.train,
-		TrainingDatasetSQL:   training,
-		ValidationDatasetSQL: validation,
-		Save:                 pr.save,
+		Estimator: Estimator{
+			IsTrain:              pr.train,
+			TrainingDatasetSQL:   training,
+			ValidationDatasetSQL: validation,
+		},
+		xgbTrainConfig: *resolveTrainCfg(attrs),
+		Save:           pr.save,
+	}
+
+	// resolve the attribute keys without any prefix as the XGBoost Paremeters
+	params, err := resolveParamsCfg(attrs)
+	if err != nil {
+		return nil, err
+	}
+
+	// fill learning target
+	objective, err := resolveObjective(pr)
+	if err != nil {
+		return nil, err
+	}
+	params["objective"] = objective
+
+	paramsJSON, err := json.Marshal(params)
+	if err != nil {
+		return nil, err
 	}
-	// TODO(Yancey1989): fill the train_args and parameters by WITH statment
-	r.TrainCfgJSON = ""
-	r.ParamsCfgJSON = ""
+	r.ParamsCfgJSON = string(paramsJSON)
 
 	if r.connectionConfig, err = newConnectionConfig(db); err != nil {
 		return nil, err
@@ -63,17 +132,17 @@ func newXGBFiller(pr *extendedSelect, ds *trainAndValDataset, fts fieldTypes, db
 			return nil, fmt.Errorf("newXGBoostFiller doesn't support DENSE/SPARSE")
 		}
 		for _, col := range feaCols {
-			fm := &featureMeta{
+			fm := &FeatureMeta{
 				FeatureName: col.GetKey(),
 				Dtype:       col.GetDtype(),
 				Delimiter:   col.GetDelimiter(),
 				InputShape:  col.GetInputShape(),
 				IsSparse:    false,
 			}
-			r.Features = append(r.Features, fm)
+			r.X = append(r.X, fm)
 		}
 	}
-	r.Label = &featureMeta{
+	r.Y = &FeatureMeta{
 		FeatureName: pr.label,
 		Dtype:       "int32",
 		Delimiter:   ",",
@@ -85,7 +154,7 @@ func newXGBFiller(pr *extendedSelect, ds *trainAndValDataset, fts fieldTypes, db
 }
 
 func genXGBoost(w io.Writer, pr *extendedSelect, ds *trainAndValDataset, fts fieldTypes, db *DB) error {
-	r, e := newXGBFiller(pr, ds, fts, db)
+	r, e := newXGBFiller(pr, ds, db)
 	if e != nil {
 		return e
 	}

sql/codegen_xgboost_test.go

@@ -13,13 +13,41 @@
 
 package sql
 
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
 const testXGBoostTrainSelectIris = ` 
 SELECT *
 FROM iris.train
 TRAIN xgb.multi.softprob
 WITH
-	train.num_boost_round = 30
+	train.num_boost_round = 30,
+	eta = 3.1,
+	num_class = 3
 COLUMN sepal_length, sepal_width, petal_length, petal_width
 LABEL class 
 INTO sqlflow_models.my_xgboost_model;
 `
+
+func TestXGBFiller(t *testing.T) {
+	a := assert.New(t)
+	parser := newParser()
+	r, e := parser.Parse(testXGBoostTrainSelectIris)
+	a.NoError(e)
+	filler, e := newXGBFiller(r, nil, testDB)
+	a.NoError(e)
+	a.True(filler.IsTrain)
+	a.Equal(filler.NumBoostRound, 30)
+	expectedParams := map[string]interface{}{
+		"eta":       3.1,
+		"num_class": 3,
+		"objective": "multi:softprob",
+	}
+	paramsJSON, err := json.Marshal(expectedParams)
+	a.NoError(err)
+	a.Equal(filler.ParamsCfgJSON, string(paramsJSON))
+}

sql/executor_test.go

@@ -110,7 +110,6 @@ func TestExecutorTrainXGBoost(t *testing.T) {
 	a.NotPanics(func() {
 		stream := runExtendedSQL(testXGBoostTrainSelectIris, testDB, modelDir, nil)
 		a.True(goodStream(stream.ReadAll()))
-
 	})
 }