func SaveLibSVMDataset(path string, set data.Dataset) { log.Print("保存数据集到libsvm格式文件", path) f, err := os.Create(path) defer f.Close() if err != nil { log.Fatalf("无法打开文件\"%v\",错误提示:%v\n", path, err) } w := bufio.NewWriter(f) defer w.Flush() iter := set.CreateIterator() iter.Start() for !iter.End() { instance := iter.GetInstance() if instance.Output.LabelString == "" { fmt.Fprintf(w, "%d ", instance.Output.Label) } else { fmt.Fprintf(w, "%s ", instance.Output.LabelString) } for _, k := range instance.Features.Keys() { // 跳过第0个特征,因为它始终是1 if k == 0 { continue } if instance.Features.Get(k) != 0 { // libsvm格式的特征从1开始 fmt.Fprintf(w, "%d:%s ", k, strconv.FormatFloat(instance.Features.Get(k), 'f', -1, 64)) } } fmt.Fprint(w, "\n") iter.Next() } }
func (rbm *RBM) feeder(set data.Dataset, ch chan *data.Instance) { iter := set.CreateIterator() iter.Start() for it := 0; it < set.NumInstances(); it++ { instance := iter.GetInstance() ch <- instance iter.Next() } }
// 输出的度量名字为 "confusion:M/N" 其中M为真实标注,N为预测标注 func (e *ConfusionMatrixEvaluator) Evaluate(m supervised.Model, set data.Dataset) (result Evaluation) { result.Metrics = make(map[string]float64) iter := set.CreateIterator() iter.Start() for !iter.End() { instance := iter.GetInstance() out := m.Predict(instance) name := fmt.Sprintf("confusion:%d/%d", instance.Output.Label, out.Label) result.Metrics[name]++ iter.Next() } return }
func (e *PREvaluator) Evaluate(m supervised.Model, set data.Dataset) (result Evaluation) { tp := 0 // true-positive tn := 0 // true-negative fp := 0 // false-positive fn := 0 // false-negative iter := set.CreateIterator() iter.Start() for !iter.End() { instance := iter.GetInstance() if instance.Output.Label > 2 { log.Fatal("调用PREvaluator但不是二分类问题") } out := m.Predict(instance) if out.Label == 0 { if instance.Output.Label == 0 { tn++ } else { fn++ } } else { if instance.Output.Label == 0 { fp++ } else { tp++ } } iter.Next() } result.Metrics = make(map[string]float64) result.Metrics["precision"] = float64(tp) / float64(tp+fp) result.Metrics["recall"] = float64(tp) / float64(tp+fn) result.Metrics["tp"] = float64(tp) result.Metrics["fp"] = float64(fp) result.Metrics["tn"] = float64(tn) result.Metrics["fn"] = float64(fn) result.Metrics["fscore"] = 2 * result.Metrics["precision"] * result.Metrics["recall"] / (result.Metrics["precision"] + result.Metrics["recall"]) return }
func (e *AccuracyEvaluator) Evaluate(m supervised.Model, set data.Dataset) (result Evaluation) { correctPrediction := 0 totalPrediction := 0 iter := set.CreateIterator() iter.Start() for !iter.End() { instance := iter.GetInstance() out := m.Predict(instance) if instance.Output.Label == out.Label { correctPrediction++ } totalPrediction++ iter.Next() } result.Metrics = make(map[string]float64) result.Metrics["accuracy"] = float64(correctPrediction) / float64(totalPrediction) return }
func (opt *gdOptimizer) OptimizeWeights( weights *util.Matrix, derivative_func ComputeInstanceDerivativeFunc, set data.Dataset) { // 偏导数向量 derivative := weights.Populate() // 学习率计算器 learningRate := NewLearningRate(opt.options) // 优化循环 iterator := set.CreateIterator() step := 0 var learning_rate float64 convergingSteps := 0 oldWeights := weights.Populate() weightsDelta := weights.Populate() instanceDerivative := weights.Populate() log.Print("开始梯度递降优化") for { if opt.options.MaxIterations > 0 && step >= opt.options.MaxIterations { break } step++ // 每次遍历样本前对偏导数向量清零 derivative.Clear() // 遍历所有样本,计算偏导数向量并累加 iterator.Start() instancesProcessed := 0 for !iterator.End() { instance := iterator.GetInstance() derivative_func(weights, instance, instanceDerivative) derivative.Increment(instanceDerivative, 1.0/float64(set.NumInstances())) iterator.Next() instancesProcessed++ if opt.options.GDBatchSize > 0 && instancesProcessed >= opt.options.GDBatchSize { // 添加正则化项 derivative.Increment(ComputeRegularization(weights, opt.options), float64(instancesProcessed)/(float64(set.NumInstances())*float64(set.NumInstances()))) // 计算特征权重的增量 delta := opt.GetDeltaX(weights, derivative) // 根据学习率更新权重 learning_rate = learningRate.ComputeLearningRate(delta) weights.Increment(delta, learning_rate) // 重置 derivative.Clear() instancesProcessed = 0 } } if instancesProcessed > 0 { // 处理剩余的样本 derivative.Increment(ComputeRegularization(weights, opt.options), float64(instancesProcessed)/(float64(set.NumInstances())*float64(set.NumInstances()))) delta := opt.GetDeltaX(weights, derivative) learning_rate = learningRate.ComputeLearningRate(delta) weights.Increment(delta, learning_rate) } weightsDelta.WeightedSum(weights, oldWeights, 1, -1) oldWeights.DeepCopy(weights) weightsNorm := weights.Norm() weightsDeltaNorm := weightsDelta.Norm() log.Printf("#%d |w|=%1.3g |dw|/|w|=%1.3g lr=%1.3g", step, weightsNorm, weightsDeltaNorm/weightsNorm, learning_rate) // 判断是否溢出 if math.IsNaN(weightsNorm) { log.Fatal("优化失败:不收敛") } // 判断是否收敛 if weightsDelta.Norm()/weights.Norm() < opt.options.ConvergingDeltaWeight { convergingSteps++ if convergingSteps > opt.options.ConvergingSteps { log.Printf("收敛") break } } } }