mirror of
https://github.com/gonum/gonum.git
synced 2025-10-05 15:16:59 +08:00
251 lines
6.8 KiB
Go
251 lines
6.8 KiB
Go
// Copyright ©2016 The Gonum Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package stat_test
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
|
|
"gonum.org/v1/gonum/floats"
|
|
"gonum.org/v1/gonum/integrate"
|
|
"gonum.org/v1/gonum/stat"
|
|
)
|
|
|
|
func ExampleROC_weighted() {
|
|
y := []float64{0, 3, 5, 6, 7.5, 8}
|
|
classes := []bool{false, true, false, true, true, true}
|
|
weights := []float64{4, 1, 6, 3, 2, 2}
|
|
|
|
tpr, fpr, _ := stat.ROC(nil, y, classes, weights)
|
|
fmt.Printf("true positive rate: %v\n", tpr)
|
|
fmt.Printf("false positive rate: %v\n", fpr)
|
|
|
|
// Output:
|
|
// true positive rate: [0 0.25 0.5 0.875 0.875 1 1]
|
|
// false positive rate: [0 0 0 0 0.6 0.6 1]
|
|
}
|
|
|
|
func ExampleROC_unweighted() {
|
|
y := []float64{0, 3, 5, 6, 7.5, 8}
|
|
classes := []bool{false, true, false, true, true, true}
|
|
|
|
tpr, fpr, _ := stat.ROC(nil, y, classes, nil)
|
|
fmt.Printf("true positive rate: %v\n", tpr)
|
|
fmt.Printf("false positive rate: %v\n", fpr)
|
|
|
|
// Output:
|
|
// true positive rate: [0 0.25 0.5 0.75 0.75 1 1]
|
|
// false positive rate: [0 0 0 0 0.5 0.5 1]
|
|
}
|
|
|
|
func ExampleROC_threshold() {
|
|
y := []float64{0.1, 0.4, 0.35, 0.8}
|
|
classes := []bool{false, false, true, true}
|
|
stat.SortWeightedLabeled(y, classes, nil)
|
|
|
|
tpr, fpr, thresh := stat.ROC(nil, y, classes, nil)
|
|
fmt.Printf("true positive rate: %v\n", tpr)
|
|
fmt.Printf("false positive rate: %v\n", fpr)
|
|
fmt.Printf("cutoff thresholds: %v\n", thresh)
|
|
|
|
// Output:
|
|
// true positive rate: [0 0.5 0.5 1 1]
|
|
// false positive rate: [0 0 0.5 0.5 1]
|
|
// cutoff thresholds: [+Inf 0.8 0.4 0.35 0.1]
|
|
}
|
|
|
|
func ExampleROC_unsorted() {
|
|
y := []float64{8, 7.5, 6, 5, 3, 0}
|
|
classes := []bool{true, true, true, false, true, false}
|
|
weights := []float64{2, 2, 3, 6, 1, 4}
|
|
|
|
stat.SortWeightedLabeled(y, classes, weights)
|
|
|
|
tpr, fpr, _ := stat.ROC(nil, y, classes, weights)
|
|
fmt.Printf("true positive rate: %v\n", tpr)
|
|
fmt.Printf("false positive rate: %v\n", fpr)
|
|
|
|
// Output:
|
|
// true positive rate: [0 0.25 0.5 0.875 0.875 1 1]
|
|
// false positive rate: [0 0 0 0 0.6 0.6 1]
|
|
}
|
|
|
|
func ExampleROC_knownCutoffs() {
|
|
y := []float64{8, 7.5, 6, 5, 3, 0}
|
|
classes := []bool{true, true, true, false, true, false}
|
|
weights := []float64{2, 2, 3, 6, 1, 4}
|
|
cutoffs := []float64{-1, 3, 4}
|
|
|
|
stat.SortWeightedLabeled(y, classes, weights)
|
|
|
|
tpr, fpr, _ := stat.ROC(cutoffs, y, classes, weights)
|
|
fmt.Printf("true positive rate: %v\n", tpr)
|
|
fmt.Printf("false positive rate: %v\n", fpr)
|
|
|
|
// Output:
|
|
// true positive rate: [0.875 1 1]
|
|
// false positive rate: [0.6 0.6 1]
|
|
}
|
|
|
|
func ExampleROC_equallySpacedCutoffs() {
|
|
y := []float64{8, 7.5, 6, 5, 3, 0}
|
|
classes := []bool{true, true, true, false, true, true}
|
|
weights := []float64{2, 2, 3, 6, 1, 4}
|
|
n := 9
|
|
|
|
stat.SortWeightedLabeled(y, classes, weights)
|
|
cutoffs := make([]float64, n)
|
|
floats.Span(cutoffs, math.Nextafter(y[0], y[0]-1), y[len(y)-1])
|
|
|
|
tpr, fpr, _ := stat.ROC(cutoffs, y, classes, weights)
|
|
fmt.Printf("true positive rate: %.3v\n", tpr)
|
|
fmt.Printf("false positive rate: %.3v\n", fpr)
|
|
|
|
// Output:
|
|
// true positive rate: [0.167 0.333 0.583 0.583 0.583 0.667 0.667 0.667 1]
|
|
// false positive rate: [0 0 0 1 1 1 1 1 1]
|
|
}
|
|
|
|
func ExampleROC_aUC_unweighted() {
|
|
y := []float64{0.1, 0.35, 0.4, 0.8}
|
|
classes := []bool{true, false, true, false}
|
|
|
|
tpr, fpr, _ := stat.ROC(nil, y, classes, nil)
|
|
|
|
// Compute Area Under Curve.
|
|
auc := integrate.Trapezoidal(fpr, tpr)
|
|
fmt.Printf("true positive rate: %v\n", tpr)
|
|
fmt.Printf("false positive rate: %v\n", fpr)
|
|
fmt.Printf("auc: %v\n", auc)
|
|
|
|
// Output:
|
|
// true positive rate: [0 0 0.5 0.5 1]
|
|
// false positive rate: [0 0.5 0.5 1 1]
|
|
// auc: 0.25
|
|
}
|
|
|
|
func ExampleROC_aUC_weighted() {
|
|
y := []float64{0.1, 0.35, 0.4, 0.8}
|
|
classes := []bool{true, false, true, false}
|
|
weights := []float64{1, 2, 2, 1}
|
|
|
|
tpr, fpr, _ := stat.ROC(nil, y, classes, weights)
|
|
|
|
// Compute Area Under Curve.
|
|
auc := integrate.Trapezoidal(fpr, tpr)
|
|
fmt.Printf("auc: %f\n", auc)
|
|
|
|
// Output:
|
|
// auc: 0.444444
|
|
|
|
}
|
|
|
|
func ExampleTOC() {
|
|
classes := []bool{
|
|
false, false, false, false, false, false,
|
|
false, false, false, false, false, false,
|
|
false, false, true, true, true, true,
|
|
true, true, true, false, false, true,
|
|
false, true, false, false, true, false,
|
|
}
|
|
|
|
min, ntp, max := stat.TOC(classes, nil)
|
|
fmt.Printf("minimum bound: %v\n", min)
|
|
fmt.Printf("TOC: %v\n", ntp)
|
|
fmt.Printf("maximum bound: %v\n", max)
|
|
|
|
// Output:
|
|
// minimum bound: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9 10]
|
|
// TOC: [0 0 1 1 1 2 2 3 3 3 4 5 6 7 8 9 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10]
|
|
// maximum bound: [0 1 2 3 4 5 6 7 8 9 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10]
|
|
}
|
|
|
|
func ExampleTOC_unsorted() {
|
|
y := []float64{8, 7.5, 6, 5, 3, 0}
|
|
classes := []bool{true, false, true, false, false, false}
|
|
weights := []float64{4, 1, 6, 3, 2, 2}
|
|
|
|
stat.SortWeightedLabeled(y, classes, weights)
|
|
|
|
min, ntp, max := stat.TOC(classes, weights)
|
|
fmt.Printf("minimum bound: %v\n", min)
|
|
fmt.Printf("TOC: %v\n", ntp)
|
|
fmt.Printf("maximum bound: %v\n", max)
|
|
|
|
// Output:
|
|
// minimum bound: [0 0 0 3 6 8 10]
|
|
// TOC: [0 4 4 10 10 10 10]
|
|
// maximum bound: [0 4 5 10 10 10 10]
|
|
}
|
|
|
|
func ExampleTOC_aUC_unweighted() {
|
|
classes := []bool{true, false, true, false}
|
|
|
|
_, ntp, _ := stat.TOC(classes, nil)
|
|
pos := ntp[len(ntp)-1]
|
|
base := float64(len(classes)) - pos
|
|
|
|
// Compute the area under ntp and under the
|
|
// minimum bound.
|
|
x := floats.Span(make([]float64, len(classes)+1), 0, float64(len(classes)))
|
|
aucNTP := integrate.Trapezoidal(x, ntp)
|
|
aucMin := pos * pos / 2
|
|
|
|
// Calculate the the area under the curve
|
|
// within the bounding parallelogram.
|
|
auc := aucNTP - aucMin
|
|
|
|
// Calculate the area within the bounding
|
|
// parallelogram.
|
|
par := pos * base
|
|
|
|
// The AUC is the ratio of the area under
|
|
// the curve within the bounding parallelogram
|
|
// and the total parallelogram bound.
|
|
auc /= par
|
|
|
|
fmt.Printf("number of true positives: %v\n", ntp)
|
|
fmt.Printf("auc: %v\n", auc)
|
|
|
|
// Output:
|
|
// number of true positives: [0 0 1 1 2]
|
|
// auc: 0.25
|
|
}
|
|
|
|
func ExampleTOC_aUC_weighted() {
|
|
classes := []bool{true, false, true, false}
|
|
weights := []float64{1, 2, 2, 1}
|
|
|
|
min, ntp, max := stat.TOC(classes, weights)
|
|
|
|
// Compute the area under ntp and under the
|
|
// minimum and maximum bounds.
|
|
x := make([]float64, len(classes)+1)
|
|
floats.CumSum(x[1:], weights)
|
|
aucNTP := integrate.Trapezoidal(x, ntp)
|
|
aucMin := integrate.Trapezoidal(x, min)
|
|
aucMax := integrate.Trapezoidal(x, max)
|
|
|
|
// Calculate the the area under the curve
|
|
// within the bounding parallelogram.
|
|
auc := aucNTP - aucMin
|
|
|
|
// Calculate the area within the bounding
|
|
// parallelogram.
|
|
par := aucMax - aucMin
|
|
|
|
// The AUC is the ratio of the area under
|
|
// the curve within the bounding parallelogram
|
|
// and the total parallelogram bound.
|
|
auc /= par
|
|
|
|
fmt.Printf("number of true positives: %v\n", ntp)
|
|
fmt.Printf("auc: %f\n", auc)
|
|
|
|
// Output:
|
|
// number of true positives: [0 0 2 2 3]
|
|
// auc: 0.444444
|
|
}
|