func main() { train_path, _, _, method, params := hector.PrepareParams() global, _ := strconv.ParseInt(params["global"], 10, 64) profile, _ := params["profile"] dataset := core.NewDataSet() dataset.Load(train_path, global) cv, _ := strconv.ParseInt(params["cv"], 10, 32) total := int(cv) if profile != "" { fmt.Println(profile) f, err := os.Create(profile) if err != nil { fmt.Println("%v", err) log.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } average_auc := 0.0 for part := 0; part < total; part++ { train, test := SplitFile(dataset, total, part) classifier := hector.GetClassifier(method) classifier.Init(params) auc, _ := hector.AlgorithmRunOnDataSet(classifier, train, test, "", params) fmt.Println("AUC:") fmt.Println(auc) average_auc += auc classifier = nil } fmt.Println(average_auc / float64(total)) }
func main() { train, test, pred, method, params := hector.PrepareParams() action, _ := params["action"] classifier := hector.GetMutliClassClassifier(method) profile, _ := params["profile"] if profile != "" { fmt.Printf("Profile data => %s\n", profile) f, err := os.Create(profile) if err != nil { log.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } if action == "" { accuracy, _ := hector.MultiClassRun(classifier, train, test, pred, params) fmt.Println("accuracy : ", accuracy) } else if action == "train" { hector.MultiClassTrain(classifier, train, params) } else if action == "test" { accuracy, _ := hector.MultiClassTest(classifier, test, pred, params) fmt.Println("accuracy", accuracy) } }
func main() { train_path, _, _, method, params := hector.PrepareParams() global, _ := strconv.ParseInt(params["global"], 10, 64) profile, _ := params["profile"] dataset := core.NewDataSet() dataset.Load(train_path, global) cv, _ := strconv.ParseInt(params["cv"], 10, 32) total := int(cv) if profile != "" { f, err := os.Create(profile) if err != nil { log.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } average_accuracy := 0.0 for part := 0; part < total; part++ { train, test := SplitFile(dataset, total, part) classifier := hector.GetMutliClassClassifier(method) classifier.Init(params) accuracy := hector.MultiClassRunOnDataSet(classifier, train, test, "", params) fmt.Println("accuracy : ", accuracy) average_accuracy += accuracy classifier = nil train = nil test = nil runtime.GC() } fmt.Println(average_accuracy / float64(total)) }
func main() { train, test, pred, method, params := hector.PrepareParams() classifier := hector.GetClassifier(method) auc, _, _ := hector.AlgorithmRun(classifier, train, test, pred, params) fmt.Println("AUC:") fmt.Println(auc) }
func main() { train_path, _, _, _, _ := hector.PrepareParams() dataset := hector.NewDataSet() dataset.Load(train_path, -1) context := Context{feature_iv: hector.InformationValue(dataset)} fmt.Println(context) handler := ContextHandler{c: context, f: FeatureHandler} http.Handle("/", handler) http.ListenAndServe(":8080", nil) }
func main() { train, test, _, _, params := hector.PrepareParams() action, _ := params["action"] if action == "encodelabel" { fmt.Println("encoded dataset label ..." + train) e := core.NewLabelEncoder() EncodeLabelAction(e, train) fmt.Println("encoded dataset label ..." + test) EncodeLabelAction(e, test) } }
func main() { train, _, _, _, params := hector.PrepareParams() feature_combination := combine.CategoryFeatureCombination{} feature_combination.Init(params) dataset := core.NewRawDataSet() dataset.Load(train) combinations := feature_combination.FindCombination(dataset) output := params["output"] file, _ := os.Create(output) defer file.Close() for _, combination := range combinations { file.WriteString(strings.Join(combination, "\t") + "\n") } }
func main() { train_path, test_path, pred_path, _, params := hector.PrepareParams() total := 5 methods := []string{"ftrl", "fm"} all_methods_predictions := [][]*eval.LabelPrediction{} all_methods_test_predictions := [][]*eval.LabelPrediction{} for _, method := range methods { fmt.Println(method) average_auc := 0.0 all_predictions := []*eval.LabelPrediction{} for part := 0; part < total; part++ { train, test, _ := SplitFile(train_path, total, part) classifier := hector.GetClassifier(method) auc, predictions, _ := hector.AlgorithmRun(classifier, train, test, "", params) fmt.Println("AUC:") fmt.Println(auc) average_auc += auc os.Remove(train) os.Remove(test) classifier = nil for _, pred := range predictions { all_predictions = append(all_predictions, pred) } } all_methods_predictions = append(all_methods_predictions, all_predictions) fmt.Println(average_auc / float64(total)) classifier := hector.GetClassifier(method) fmt.Println(test_path) _, test_predictions, _ := hector.AlgorithmRun(classifier, train_path, test_path, "", params) all_methods_test_predictions = append(all_methods_test_predictions, test_predictions) } var wait sync.WaitGroup wait.Add(2) dataset := core.NewDataSet() go func() { for i, _ := range all_methods_predictions[0] { sample := core.NewSample() sample.Label = all_methods_predictions[0][i].Label for j, _ := range all_methods_predictions { feature := core.Feature{Id: int64(j), Value: all_methods_predictions[j][i].Prediction} sample.AddFeature(feature) } dataset.Samples <- sample } close(dataset.Samples) wait.Done() }() ensembler := lr.LinearRegression{} go func() { ensembler.Init(params) ensembler.Train(dataset) wait.Done() }() wait.Wait() fmt.Println(ensembler.Model) wait.Add(2) test_dataset := hector.NewDataSet() go func() { for i, _ := range all_methods_test_predictions[0] { sample := hector.NewSample() sample.Label = all_methods_test_predictions[0][i].Prediction for j, _ := range all_methods_test_predictions { feature := hector.Feature{Id: int64(j), Value: all_methods_test_predictions[j][i].Prediction} sample.AddFeature(feature) } test_dataset.Samples <- sample } close(test_dataset.Samples) wait.Done() }() go func() { pred_file, _ := os.Create(test_path + ".out") for sample := range test_dataset.Samples { prediction := sample.Label //ensembler.Predict(sample) pred_file.WriteString(strconv.FormatFloat(prediction, 'g', 5, 64) + "\n") } defer pred_file.Close() wait.Done() }() wait.Wait() }