ComputeMSE() public static method

Computes the Mean Squared Error of the given inputs.
public static ComputeMSE ( Vector y1, Vector y2 ) : double
y1 numl.Math.LinearAlgebra.Vector Predicted values.
y2 numl.Math.LinearAlgebra.Vector Actual values.
return double
Beispiel #1
0
        /// <summary>
        /// Scores a set of predictions against the actual values.
        /// </summary>
        /// <param name="predictions">Predicted values.</param>
        /// <param name="actual">Actual values.</param>
        /// <param name="truthLabel">(Optional) the truth label in the <paramref name="actual"/> vector.</param>
        /// <param name="falseLabel">(Optional) the false label in the <paramref name="actual"/> vector.</param>
        /// <returns></returns>
        public static Score ScorePredictions(Vector predictions, Vector actual,
                                             double truthLabel = Ject.DefaultTruthValue, double falseLabel = Ject.DefaultFalseValue)
        {
            var score = new numl.Supervised.Score()
            {
                TotalPositives = actual.Where(w => w == truthLabel).Count(),
                TotalNegatives = actual.Where(w => (w == falseLabel || w != truthLabel)).Count(),

                TruePositives  = actual.Where((i, idx) => i == truthLabel && i == predictions[idx]).Count(),
                FalsePositives = actual.Where((i, idx) => (i == falseLabel || i != truthLabel) && predictions[idx] == truthLabel).Count(),

                TrueNegatives  = actual.Where((i, idx) => (i == falseLabel || i != truthLabel) && predictions[idx] != truthLabel).Count(),
                FalseNegatives = actual.Where((i, idx) => i == truthLabel && (predictions[idx] == falseLabel || predictions[idx] != truthLabel)).Count(),

                Examples = predictions.Length
            };

            score._IsBinary = actual.IsBinary();

            // if the labels are continuous values then calculate accuracy manually
            if (!score._IsBinary)
            {
                score._totalAccuracy = (predictions.Where((d, idx) => d == actual[idx]).Count() / predictions.Length);
            }

            score.RMSE         = Score.ComputeRMSE(predictions, actual);
            score.CoefRMSE     = Score.ComputeCoefRMSE(predictions, actual);
            score.NormRMSE     = Score.ComputeRMSE(predictions, actual);
            score.MeanAbsError = Score.ComputeMeanError(predictions, actual);
            score.SSE          = Score.ComputeSSE(predictions, actual);
            score.MSE          = Score.ComputeMSE(predictions, actual);
            score.CrossEntropy = Score.ComputeCrossEntropy(predictions, actual);

            return(score);
        }
Beispiel #2
0
 /// <summary>
 /// Computes the Root Mean Squared Error for the given inputs.
 /// </summary>
 /// <param name="y1">Predicted values.</param>
 /// <param name="y2">Actual values.</param>
 /// <returns>Double.</returns>
 public static double ComputeRMSE(Vector y1, Vector y2)
 {
     return(System.Math.Sqrt(Score.ComputeMSE(y1, y2)));
 }