Documentation
¶
Overview ¶
Package metrics includes score functions, performance metrics and pairwise metrics and distance computations.
Index ¶
- func AUC(fpr, tpr []float64) float64
- func AccuracyScore(Ytrue, Ypred mat.Matrix, normalize bool, sampleWeight *mat.Dense) float64
- func AveragePrecisionScore(Ytrue, Yscore *mat.Dense, average string, sampleWeight []float64) float64
- func ConfusionMatrix(YTrue, YPred *mat.Dense, sampleWeight []float64) *mat.Dense
- func F1Score(Ytrue, Ypred *mat.Dense, average string, sampleWeight []float64) float64
- func FBetaScore(Ytrue, Ypred *mat.Dense, beta float64, average string, sampleWeight []float64) float64
- func MeanAbsoluteError(yTrue, yPred mat.Matrix, sampleWeight *mat.Dense, multioutput string) *mat.Dense
- func MeanSquaredError(yTrue, yPred mat.Matrix, sampleWeight *mat.Dense, multioutput string) *mat.Dense
- func PrecisionRecallCurve(Ytrue, ProbasPred *mat.Dense, posLabel float64, sampleWeight []float64) (precision, recall, thresholds []float64)
- func PrecisionRecallFScoreSupport(YTrue, YPred *mat.Dense, beta float64, labels []float64, posLabel int, ...) (precision, recall, fscore, support float64)
- func PrecisionScore(Ytrue, Ypred *mat.Dense, average string, sampleWeight []float64) float64
- func R2Score(yTrue, yPred mat.Matrix, sampleWeight *mat.Dense, multioutput string) *mat.Dense
- func ROCAUCScore(Ytrue, Yscore *mat.Dense, average string, sampleWeight []float64) float64
- func ROCCurve(Ytrue, Yscore *mat.Dense, posLabel float64, sampleWeight []float64) (fpr, tpr, thresholds []float64)
- func RecallScore(Ytrue, Ypred *mat.Dense, average string, sampleWeight []float64) float64
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func AUC ¶
AUC Compute Area Under the Curve (AUC) using the trapezoidal rule
Example ¶
// example adapted from https://github.com/scikit-learn/scikit-learn/blob/a24c8b46/sklearn/metrics/ranking.py#L453
Y := mat.NewDense(4, 1, []float64{1, 1, 2, 2})
scores := mat.NewDense(4, 1, []float64{.1, .4, .35, .8})
fpr, tpr, _ := ROCCurve(Y, scores, 2., nil)
fmt.Println("auc:", AUC(fpr, tpr))
Output: auc: 0.75
func AccuracyScore ¶
AccuracyScore reports (weighted) true values/nSamples
Example ¶
// adapted from example in https://github.com/scikit-learn/scikit-learn/blob/0.19.1/sklearn/metrics/classification.py
var nilDense *mat.Dense
normalize, sampleWeight := true, nilDense
Ypred, Ytrue := mat.NewDense(4, 1, []float64{0, 2, 1, 3}), mat.NewDense(4, 1, []float64{0, 1, 2, 3})
fmt.Println(AccuracyScore(Ytrue, Ypred, normalize, sampleWeight))
fmt.Println(AccuracyScore(mat.NewDense(2, 2, []float64{0, 1, 1, 1}), mat.NewDense(2, 2, []float64{1, 1, 1, 1}), normalize, sampleWeight))
Output: 0.5 0.5
func AveragePrecisionScore ¶
func AveragePrecisionScore(Ytrue, Yscore *mat.Dense, average string, sampleWeight []float64) float64
AveragePrecisionScore compute average precision (AP) from prediction scores
Example ¶
// adapted from https://github.com/scikit-learn/scikit-learn/blob/a24c8b46/sklearn/metrics/ranking.py#L180
Ytrue := mat.NewDense(4, 1, []float64{0, 0, 1, 1})
Yscores := mat.NewDense(4, 1, []float64{.1, .4, .35, .8})
fmt.Printf("AveragePrecisionScore : %.2f\n", AveragePrecisionScore(Ytrue, Yscores, "macro", nil))
// import numpy as np
// from sklearn.metrics import average_precision_score
// y_true = np.array([[0,0], [0,0], [1,1], [1,1]])
// y_scores = np.array([[0.1,.5],[ 0.4,.4], [0.35,.35], [0.8,.4]])
// average_precision_score(y_true, y_scores,"macro"),average_precision_score(y_true, y_scores,"micro")
/*
np.average( [0.83333333 0.41666667] , None )
np.average( [0.63571429] , None )
(0.625, 0.6357142857142857)
*/
//FIXME
Ytrue = mat.NewDense(4, 2, []float64{0, 0, 0, 0, 1, 1, 1, 1})
Yscores = mat.NewDense(4, 2, []float64{.1, .5, .4, .4, .35, .35, .8, .4})
fmt.Printf("AveragePrecisionScore macro: %.3f\n", AveragePrecisionScore(Ytrue, Yscores, "macro", nil))
fmt.Printf("AveragePrecisionScore micro: %.3f\n", AveragePrecisionScore(Ytrue, Yscores, "micro", []float64{1, 1, 1, 1}))
Output: AveragePrecisionScore : 0.83 AveragePrecisionScore macro: 0.625 AveragePrecisionScore micro: 0.636
func ConfusionMatrix ¶
ConfusionMatrix Compute confusion matrix to evaluate the accuracy of a classification operate only on 1st Y column uses preprocessing.LabelEncoder to map class values to class indices
Example ¶
// adapted from example in http://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html#sklearn.metrics.confusion_matrix
YTrue := mat.NewDense(6, 1, []float64{2, 0, 2, 2, 0, 1})
YPred := mat.NewDense(6, 1, []float64{0, 0, 2, 2, 0, 2})
fmt.Println(mat.Formatted(ConfusionMatrix(YTrue, YPred, nil)))
Output: ⎡2 0 0⎤ ⎢0 0 1⎥ ⎣1 0 2⎦
func F1Score ¶
F1Score v https://en.wikipedia.org/wiki/F1_score average must be macro|micro|weighted.. //TODO binary,samples
Example ¶
// adapted from example in https://github.com/scikit-learn/scikit-learn/blob/0.19.1/sklearn/metrics/classification.py
Ytrue, Ypred := mat.NewDense(6, 1, []float64{0, 1, 2, 0, 1, 2}), mat.NewDense(6, 1, []float64{0, 2, 1, 0, 0, 1})
var sampleWeight []float64
fmt.Printf("%.2f\n", F1Score(Ytrue, Ypred, "macro", sampleWeight))
fmt.Printf("%.2f\n", F1Score(Ytrue, Ypred, "micro", sampleWeight))
fmt.Printf("%.2f\n", F1Score(Ytrue, Ypred, "weighted", sampleWeight))
Output: 0.27 0.33 0.27
func FBetaScore ¶
func FBetaScore(Ytrue, Ypred *mat.Dense, beta float64, average string, sampleWeight []float64) float64
FBetaScore is the weighted harmonic mean of precision and recall,
reaching its optimal value at 1 and its worst value at 0. The `beta` parameter determines the weight of precision in the combined score. ``beta < 1`` lends more weight to precision, while ``beta > 1`` favors recall (``beta -> 0`` considers only precision, ``beta -> inf`` only recall)
average must be macro|micro|weighted.. //TODO binary,samples
Example ¶
// adapted from example in https://github.com/scikit-learn/scikit-learn/blob/0.19.1/sklearn/metrics/classification.py
Ytrue, Ypred := mat.NewDense(6, 1, []float64{0, 1, 2, 0, 1, 2}), mat.NewDense(6, 1, []float64{0, 2, 1, 0, 0, 1})
var sampleWeight []float64
fmt.Printf("%.2f\n", FBetaScore(Ytrue, Ypred, .5, "macro", sampleWeight))
fmt.Printf("%.2f\n", FBetaScore(Ytrue, Ypred, .5, "micro", sampleWeight))
fmt.Printf("%.2f\n", FBetaScore(Ytrue, Ypred, .5, "weighted", sampleWeight))
Output: 0.24 0.33 0.24
func MeanAbsoluteError ¶
func MeanAbsoluteError(yTrue, yPred mat.Matrix, sampleWeight *mat.Dense, multioutput string) *mat.Dense
MeanAbsoluteError regression loss Read more in the :ref:`User Guide <mean_absolute_error>`. Parameters ---------- y_true : array-like of shape = (n_samples) or (n_samples, n_outputs)
Ground truth (correct) target values.
y_pred : array-like of shape = (n_samples) or (n_samples, n_outputs)
Estimated target values.
sample_weight : array-like of shape = (n_samples), optional
Sample weights.
multioutput : string in ['raw_values', 'uniform_average']
or array-like of shape (n_outputs)
Defines aggregating of multiple output values.
Array-like value defines weights used to average errors.
'raw_values' :
Returns a full set of errors in case of multioutput input.
'uniform_average' :
Errors of all outputs are averaged with uniform weight.
Returns ------- loss : float or ndarray of floats
If multioutput is 'raw_values', then mean absolute error is returned for each output separately. If multioutput is 'uniform_average' or an ndarray of weights, then the weighted average of all output errors is returned. MAE output is non-negative floating point. The best value is 0.0.
Examples -------- >>> from sklearn.metrics import mean_absolute_error >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> mean_absolute_error(y_true, y_pred) 0.5 >>> y_true = [[0.5, 1], [-1, 1], [7, -6]] >>> y_pred = [[0, 2], [-1, 2], [8, -5]] >>> mean_absolute_error(y_true, y_pred) 0.75 >>> mean_absolute_error(y_true, y_pred, multioutput='raw_values') array([ 0.5, 1. ]) >>> mean_absolute_error(y_true, y_pred, multioutput=[0.3, 0.7]) ... # doctest: +ELLIPSIS 0.849...
func MeanSquaredError ¶
func MeanSquaredError(yTrue, yPred mat.Matrix, sampleWeight *mat.Dense, multioutput string) *mat.Dense
MeanSquaredError regression loss Read more in the :ref:`User Guide <mean_squared_error>`. Parameters ---------- y_true : array-like of shape = (n_samples) or (n_samples, n_outputs)
Ground truth (correct) target values.
y_pred : array-like of shape = (n_samples) or (n_samples, n_outputs)
Estimated target values.
sample_weight : array-like of shape = (n_samples), optional
Sample weights.
multioutput : string in ['raw_values', 'uniform_average']
or array-like of shape (n_outputs)
Defines aggregating of multiple output values.
Array-like value defines weights used to average errors.
'raw_values' :
Returns a full set of errors in case of multioutput input.
'uniform_average' :
Errors of all outputs are averaged with uniform weight.
Returns ------- loss : float or ndarray of floats
A non-negative floating point value (the best value is 0.0), or an array of floating point values, one for each individual target.
func PrecisionRecallCurve ¶
func PrecisionRecallCurve(Ytrue, ProbasPred *mat.Dense, posLabel float64, sampleWeight []float64) (precision, recall, thresholds []float64)
PrecisionRecallCurve compute precision-recall pairs for different probability thresholds
Note: this implementation is restricted to the binary classification task.
The precision is the ratio ``tp / (tp + fp)`` where ``tp`` is the number of
true positives and ``fp`` the number of false positives. The precision is
intuitively the ability of the classifier not to label as positive a sample
that is negative.
The recall is the ratio ``tp / (tp + fn)`` where ``tp`` is the number of
true positives and ``fn`` the number of false negatives. The recall is
intuitively the ability of the classifier to find all the positive samples.
The last precision and recall values are 1. and 0. respectively and do not
have a corresponding threshold. This ensures that the graph starts on the
x axis.
Parameters
y_true : array, shape = [n_samples]
True targets of binary classification in range {-1, 1} or {0, 1}.
probas_pred : array, shape = [n_samples]
Estimated probabilities or decision function.
pos_label : int or str, default=None
The label of the positive class
sample_weight : array-like of shape = [n_samples], optional
Sample weights.
Returns
precision : array, shape = [n_thresholds + 1]
Precision values such that element i is the precision of
predictions with score >= thresholds[i] and the last element is 1.
recall : array, shape = [n_thresholds + 1]
Decreasing recall values such that element i is the recall of
predictions with score >= thresholds[i] and the last element is 0.
thresholds : array, shape = [n_thresholds <= len(np.unique(probas_pred))]
Increasing thresholds on the decision function used to compute
precision and recall.
Example ¶
// example adapted from https://github.com/scikit-learn/scikit-learn/blob/a24c8b46/sklearn/metrics/ranking.py#L423
Ytrue := mat.NewDense(4, 1, []float64{0, 0, 1, 1})
Yscores := mat.NewDense(4, 1, []float64{.1, .4, .35, .8})
precision, recall, thresholds := PrecisionRecallCurve(Ytrue, Yscores, 1, nil)
fmt.Printf("precision: %.3g\n", precision)
fmt.Printf("recall: %.3g\n", recall)
fmt.Printf("thresholds: %.3g\n", thresholds)
Output: precision: [0.667 0.5 1 1] recall: [1 0.5 0.5 0] thresholds: [0.35 0.4 0.8]
func PrecisionRecallFScoreSupport ¶
func PrecisionRecallFScoreSupport(YTrue, YPred *mat.Dense, beta float64, labels []float64, posLabel int, average string, warnFor []string, sampleWeight []float64) (precision, recall, fscore, support float64)
PrecisionRecallFScoreSupport Compute precision, recall, F-measure and support for each class operate only on 1st Y column average must be macro|micro|weighted.. //TODO binary,samples posLabel is -1 or index of classes (index of class in ordered unique class values). if posLabel>=0, restuls are returned for the respective class only
Example ¶
// adapted from example in https://github.com/scikit-learn/scikit-learn/blob/0.19.1/sklearn/metrics/classification.py
var precision, recall, fscore, support float64
// cat, dog, pig := 0., 1., 2.
Ytrue, Ypred := mat.NewDense(6, 1, []float64{0, 1, 2, 0, 1, 2}), mat.NewDense(6, 1, []float64{0, 2, 1, 0, 0, 1})
precision, recall, fscore, support = PrecisionRecallFScoreSupport(Ytrue, Ypred, 1, nil, -1, "macro", nil, nil)
fmt.Printf("macro %.2f\n", []float64{precision, recall, fscore, support})
precision, recall, fscore, support = PrecisionRecallFScoreSupport(Ytrue, Ypred, 1, nil, -1, "micro", nil, nil)
fmt.Printf("micro %.2f\n", []float64{precision, recall, fscore, support})
precision, recall, fscore, support = PrecisionRecallFScoreSupport(Ytrue, Ypred, 1, nil, -1, "weighted", nil, nil)
fmt.Printf("weighted %.2f\n", []float64{precision, recall, fscore, support})
Output: macro [0.22 0.33 0.27 0.00] micro [0.33 0.33 0.33 0.00] weighted [0.22 0.33 0.27 0.00]
func PrecisionScore ¶
PrecisionScore v https://en.wikipedia.org/wiki/F1_score average must be macro|micro|weighted.. //TODO binary,samples
Example ¶
// adapted from example in https://github.com/scikit-learn/scikit-learn/blob/0.19.1/sklearn/metrics/classification.py
Ytrue, Ypred := mat.NewDense(6, 1, []float64{0, 1, 2, 0, 1, 2}), mat.NewDense(6, 1, []float64{0, 2, 1, 0, 0, 1})
var sampleWeight []float64
fmt.Printf("%.2f\n", PrecisionScore(Ytrue, Ypred, "macro", sampleWeight))
fmt.Printf("%.2f\n", PrecisionScore(Ytrue, Ypred, "micro", sampleWeight))
fmt.Printf("%.2f\n", PrecisionScore(Ytrue, Ypred, "weighted", sampleWeight))
Output: 0.22 0.33 0.22
func R2Score ¶
R2Score """R^2 (coefficient of determination) regression score function. Best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of y, disregarding the input features, would get a R^2 score of 0.0. Read more in the :ref:`User Guide <r2Score>`. Parameters ---------- yTrue : array-like of shape = (nSamples) or (nSamples, nOutputs)
Ground truth (correct) target values.
yPred : array-like of shape = (nSamples) or (nSamples, nOutputs)
Estimated target values.
sampleWeight : array-like of shape = (nSamples), optional
Sample weights.
multioutput : string in ['rawValues', 'uniformAverage', \ 'varianceWeighted'] or None or array-like of shape (nOutputs)
Defines aggregating of multiple output scores.
Array-like value defines weights used to average scores.
Default is "uniformAverage".
'rawValues' :
Returns a full set of scores in case of multioutput input.
'uniformAverage' :
Scores of all outputs are averaged with uniform weight.
'varianceWeighted' :
Scores of all outputs are averaged, weighted by the variances
of each individual output.
.. versionchanged:: 0.19
Default value of multioutput is 'uniformAverage'.
Returns ------- z : float or ndarray of floats
The R^2 score or ndarray of scores if 'multioutput' is 'rawValues'.
Notes ----- This is not a symmetric function. Unlike most other scores, R^2 score may be negative (it need not actually be the square of a quantity R). References ---------- .. [1] `Wikipedia entry on the Coefficient of determination
<https://en.wikipedia.org/wiki/CoefficientOfDetermination>`_
Examples -------- >>> from sklearn.metrics import r2Score >>> yTrue = [3, -0.5, 2, 7] >>> yPred = [2.5, 0.0, 2, 8] >>> r2Score(yTrue, yPred) # doctest: +ELLIPSIS 0.948... >>> yTrue = [[0.5, 1], [-1, 1], [7, -6]] >>> yPred = [[0, 2], [-1, 2], [8, -5]] >>> r2Score(yTrue, yPred, multioutput='varianceWeighted') ... # doctest: +ELLIPSIS 0.938... >>> yTrue = [1,2,3] >>> yPred = [1,2,3] >>> r2Score(yTrue, yPred) 1.0 >>> yTrue = [1,2,3] >>> yPred = [2,2,2] >>> r2Score(yTrue, yPred) 0.0 >>> yTrue = [1,2,3] >>> yPred = [3,2,1] >>> r2Score(yTrue, yPred) -3.0 """
Example ¶
// adapted from example in https://github.com/scikit-learn/scikit-learn/blob/0.19.1/sklearn/metrics/regression.py
yTrue := mat.NewDense(4, 1, []float64{3, -0.5, 2, 7})
yPred := mat.NewDense(4, 1, []float64{2.5, 0.0, 2, 8})
fmt.Printf("%.3f\n", R2Score(yTrue, yPred, nil, "").At(0, 0))
yTrue = mat.NewDense(3, 2, []float64{0.5, 1, -1, 1, 7, -6})
yPred = mat.NewDense(3, 2, []float64{0, 2, -1, 2, 8, -5})
fmt.Printf("%.3f\n", R2Score(yTrue, yPred, nil, "variance_weighted").At(0, 0))
yTrue = mat.NewDense(3, 1, []float64{1, 2, 3})
yPred = mat.NewDense(3, 1, []float64{1, 2, 3})
fmt.Printf("%.3f\n", R2Score(yTrue, yPred, nil, "").At(0, 0))
yTrue = mat.NewDense(3, 1, []float64{1, 2, 3})
yPred = mat.NewDense(3, 1, []float64{2, 2, 2})
fmt.Printf("%g\n", R2Score(yTrue, yPred, nil, "").At(0, 0))
yTrue = mat.NewDense(3, 1, []float64{1, 2, 3})
yPred = mat.NewDense(3, 1, []float64{3, 2, 1})
sampleWeight := mat.NewDense(3, 1, []float64{1, 1, 1})
fmt.Printf("%g\n", R2Score(yTrue, yPred, sampleWeight, "").At(0, 0))
Output: 0.949 0.938 1.000 0 -3
func ROCAUCScore ¶
ROCAUCScore compute Area Under the Receiver Operating Characteristic Curve (ROC AUC) from prediction scores. y_true : array, shape = [n_samples] or [n_samples, n_classes] True binary labels in binary label indicators. y_score : array, shape = [n_samples] or [n_samples, n_classes] Target scores, can either be probability estimates of the positive class, confidence values, or non-thresholded measure of decisions (as returned by "decision_function" on some classifiers). average : string, [None, 'micro', 'macro' (default), 'samples', 'weighted'] If “None“, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data: “'micro'“:
Calculate metrics globally by considering each element of the label indicator matrix as a label.
“'macro'“:
Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.
“'weighted'“:
Calculate metrics for each label, and find their average, weighted by support (the number of true instances for each label).
“'samples'“:
Calculate metrics for each instance, and find their average.
sample_weight : array-like of shape = [n_samples], optional Sample weights. Returns auc : float
Example ¶
// example adapted from https://github.com/scikit-learn/scikit-learn/blob/a24c8b46/sklearn/metrics/ranking.py#L256
Ytrue := mat.NewDense(4, 1, []float64{0, 0, 1, 1})
Yscores := mat.NewDense(4, 1, []float64{.1, .4, .35, .8})
fmt.Println("auc:", ROCAUCScore(Ytrue, Yscores, "", nil))
Output: auc: 0.75
func ROCCurve ¶
func ROCCurve(Ytrue, Yscore *mat.Dense, posLabel float64, sampleWeight []float64) (fpr, tpr, thresholds []float64)
ROCCurve Compute Receiver operating characteristic (ROC) y_true : array, shape = [n_samples] True binary labels in range {0, 1} or {-1, 1}. If labels are not binary, pos_label should be explicitly given. y_score : array, shape = [n_samples] Target scores, can either be probability estimates of the positive class, confidence values, or non-thresholded measure of decisions (as returned by "decision_function" on some classifiers). pos_label : int or str, default=None Label considered as positive and others are considered negative. sample_weight : array-like of shape = [n_samples], optional Sample weights.
Example ¶
// example adapted from https://github.com/scikit-learn/scikit-learn/blob/a24c8b46/sklearn/metrics/ranking.py#L453
Y := mat.NewDense(4, 1, []float64{1, 1, 2, 2})
scores := mat.NewDense(4, 1, []float64{.1, .4, .35, .8})
fpr, tpr, thresholds := ROCCurve(Y, scores, 2., nil)
fmt.Println("fpr:", fpr)
fmt.Println("tpr:", tpr)
fmt.Println("thresholds:", thresholds)
Output: fpr: [0 0.5 0.5 1] tpr: [0.5 0.5 1 1] thresholds: [0.8 0.4 0.35 0.1]
func RecallScore ¶
RecallScore v https://en.wikipedia.org/wiki/F1_score average must be macro|micro|weighted.. //TODO binary,samples
Example ¶
// adapted from example in https://github.com/scikit-learn/scikit-learn/blob/0.19.1/sklearn/metrics/classification.py
Ytrue, Ypred := mat.NewDense(6, 1, []float64{0, 1, 2, 0, 1, 2}), mat.NewDense(6, 1, []float64{0, 2, 1, 0, 0, 1})
var sampleWeight []float64
fmt.Printf("%.2f\n", RecallScore(Ytrue, Ypred, "macro", sampleWeight))
fmt.Printf("%.2f\n", RecallScore(Ytrue, Ypred, "micro", sampleWeight))
fmt.Printf("%.2f\n", RecallScore(Ytrue, Ypred, "weighted", sampleWeight))
Output: 0.33 0.33 0.33
Types ¶
This section is empty.
Source Files