protected double GenerateRegression(double[] x, double[] y) { OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); SimpleLinearRegression regression = ols.Learn(x, y); return(regression.Slope); }
public override void SolveTransforamtion() { //https://numerics.mathdotnet.com/Regression.html#Regularization if (records.Count > minNumberOfPointToSolve) { if (records.Count % caclulationSteps == 0 || records.Count == minNumberOfPointToSolve) { double[][] out_x = new double[records.Count][]; double[][] out_z = new double[records.Count][]; double[][] out_y = new double[records.Count][]; double[][] in_XY = new double[records.Count][]; double[][] in_XYZ = new double[records.Count][]; int idx = 0; foreach (TransformationRecord r in records) { out_x[idx] = new double[] { r.ArPosition.x }; out_z[idx] = new double[] { r.ArPosition.z }; out_y[idx] = new double[] { r.ArPosition.y }; in_XY[idx] = new double[] { r.GpsPosition.Longitude, r.GpsPosition.Latitude }; in_XYZ[idx] = new double[] { r.GpsPosition.Longitude, r.GpsPosition.Latitude, r.GpsPosition.Altitude }; idx++; } regression_x = ols_x.Learn(in_XY, out_x); regression_z = ols_z.Learn(in_XY, out_z); regression_y = ols_y.Learn(in_XYZ, out_y); if (CalcualteError && testRecords.Count > 0) { List <Vector3> testArLocationsPredicted = TransformGpsToWorld(testRecords.GetGPSLocations()); Error_Horizontal = CalculateRMSE(testArLocationsPredicted, testRecords.GetARPositions()); } } } }
private static void multivariateLinear() { double[][] inputs = { // variables: x1 x2 x3 new double[] { 1, 1, 1 }, // input sample 1 new double[] { 2, 1, 1 }, // input sample 2 new double[] { 3, 1, 1 }, // input sample 3 }; double[][] outputs = { // variables: y1 y2 new double[] { 2, 3 }, // corresponding output to sample 1 new double[] { 4, 6 }, // corresponding output to sample 2 new double[] { 6, 9 }, // corresponding output to sample 3 }; // Use Ordinary Least Squares to create the regression OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); // Now, compute the multivariate linear regression: MultivariateLinearRegression regression = ols.Learn(inputs, outputs); // We can obtain predictions using double[][] predictions = regression.Transform(inputs); // The prediction error is double error = new SquareLoss(outputs).Loss(predictions); // 0 }
private MultipleLinearRegression PerformRegression(List <LeadingIndicator> indicators) { double[][] inputs = { new double[] { indicators[0].StockIndex, indicators[0].M2Level }, new double[] { indicators[1].StockIndex, indicators[1].M2Level }, new double[] { indicators[2].StockIndex, indicators[2].M2Level }, new double[] { indicators[3].StockIndex, indicators[3].M2Level }, }; double[] outputs = { indicators[0].GdpOutput, indicators[1].GdpOutput, indicators[2].GdpOutput, indicators[3].GdpOutput, }; // We will use Ordinary Least Squares to create a // linear regression model with an intercept term var ols = new OrdinaryLeastSquares() { UseIntercept = true }; // Use Ordinary Least Squares to estimate a regression model MultipleLinearRegression regression = ols.Learn(inputs, outputs); return(regression); }
public static void test2() { var ols = new OrdinaryLeastSquares() { UseIntercept = true }; double[][] inputs = { new double[] { 1, 1 }, new double[] { 0, 1 }, new double[] { 1, 0 }, new double[] { 0, 0 }, }; double[] outputs = { 1, 1, 1, 1 }; MultipleLinearRegression regression = ols.Learn(inputs, outputs); double a = regression.Weights[0]; // a = 0 double b = regression.Weights[1]; // b = 0 double c = regression.Intercept; // c = 1 double[] predicted = regression.Transform(inputs); double error = new SquareLoss(outputs).Loss(predicted); }
public override void SolveTransforamtion() { //https://numerics.mathdotnet.com/Regression.html#Regularization /// <summary> /// Least-Squares fitting the points (X,y) = ((x0,x1,..,xk),y) to a linear surface y : X -> p0*x0 + p1*x1 + ... + pk*xk, /// returning a function y' for the best fitting combination. /// If an intercept is added, its coefficient will be prepended to the resulting parameters. /// </summary> if (records.Count > minNumberOfPointToSolve) { if (records.Count % caclulationSteps == 0 || records.Count == minNumberOfPointToSolve) { //double[] out_x = new double[records.Count]; //double[] out_y = new double[records.Count]; double[][] out_xy = new double[records.Count][]; double[][] in_XY = new double[records.Count][]; int idx = 0; foreach (TransformationRecord r in records) { out_xy[idx] = new double[] { r.ArPosition.x, r.ArPosition.z }; in_XY[idx] = new double[] { r.GpsPosition.Longitude, r.GpsPosition.Latitude }; idx++; } regression = ols.Learn(in_XY, out_xy); //// We can obtain predictions using //double[][] predictions = regression.Transform(in_XY); //// The prediction error is //double error = new SquareLoss(out_xy).Loss(predictions); // 0 //double[] r2 = regression.CoefficientOfDetermination(in_XY, out_xy); } } }
private static void LinearRegressionLearning(IEnumerable <MatchingPair> trainingData, IEnumerable <MatchingPair> testData, IDictionary <string, IndexableAttributeMetadata> actualMetadata) { var stopWatch = new Stopwatch(); stopWatch.Start(); var trainingInputs = trainingData.Select(data => data.ToVectorArray(actualMetadata)).ToArray(); var trainingOutputs = trainingData.Select(data => new[] { data.PercentMatch }).ToArray(); var testInputs = testData.Select(data => data.ToVectorArray(actualMetadata)).ToArray(); var testOutputs = testData.Select(data => new[] { data.PercentMatch }).ToArray(); var leastSquares = new OrdinaryLeastSquares(); var regression = leastSquares.Learn(trainingInputs, trainingOutputs); var predictions = regression.Transform(trainingInputs); var error = new SquareLoss(trainingOutputs).Loss(predictions); Logger.InfoFormat("Linear Regression: In-sample error: {0}", error); predictions = regression.Transform(testInputs); error = new SquareLoss(testOutputs).Loss(predictions); Logger.InfoFormat("Linear Regression: Out-of-sample error: {0}", error); stopWatch.Stop(); Logger.InfoFormat("Linear Regression learning took {0}", stopWatch.Elapsed); }
public CircleModel FittingCircleWithLeastSquares(double[][] points) { var ols = new OrdinaryLeastSquares { UseIntercept = true, IsRobust = true }; var outputs = points.Select(t => Math.Pow(t[0], 2) + Math.Pow(t[1], 2)).ToArray(); var regression = ols.Learn(points, outputs); // As result, we will be given the following: var a = regression.Weights[0] / 2; // a = 0 var b = regression.Weights[1] / 2; // b = 0 var c = regression.Intercept; // c = 1 c = Math.Sqrt(c + a * a + b * b); var midPoint = points[points.Length / 2]; var result = new CircleModel { X = a, Y = b, XSource = midPoint[0], YSource = midPoint[1], R = c, R_geo = GeoTools.CalculateDistance(midPoint[1], midPoint[0], b, a) }; return(result); }
//EXAMPLE: http://accord-framework.net/docs/html/T_Accord_Statistics_Models_Regression_Linear_MultivariateLinearRegression.htm static void Main(string[] args) { CSV_Parser parser = new CSV_Parser(); RegressionData data = parser.ParseDataFile(); // Use Ordinary Least Squares to create the regression OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); // Now, compute the multivariate linear regression: MultivariateLinearRegression regression = ols.Learn(data.InterestRatings, data.MajorRatings); // We can obtain predictions using double[][] predictions = regression.Transform(data.InterestRatings); // The prediction error is double error = new SquareLoss(data.MajorRatings).Loss(predictions); // 0 // We can also check the r-squared coefficients of determination: //double[] r2 = regression.CoefficientOfDetermination(topicRatings, majorRatings); double[][] r2 = regression.Weights; Console.WriteLine("WEIGHTS:"); //writeCSVfile(data, r2); GenerateCSFile(data, r2); Console.WriteLine("Coefficient Of Determination"); double[] r3 = regression.CoefficientOfDetermination(data.InterestRatings, data.MajorRatings); for (int i = 0; i < r3.Length; i++) { Console.WriteLine(r3[i]); } Console.Read(); }
/// <summary> /// The main application entry point. /// </summary> /// <param name="args">Command line arguments.</param> public static void Main(string[] args) { // get data Console.WriteLine("Loading data...."); var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ".."); path = Path.Combine(path, ".."); path = Path.Combine(path, "california_housing.csv"); var housing = Frame.ReadCsv(path, separators: ","); // housing = housing.Where(kv => ((decimal)kv.Value["median_house_value"]) < 500000); // set up a few series var total_rooms = housing["total_rooms"]; var median_house_value = housing["median_house_value"]; var median_income = housing["median_income"]; // convert the house value range to thousands median_house_value /= 1000; // set up feature and label var feature = total_rooms.Values.ToArray(); // var feature = median_income.Values.ToArray(); var labels = median_house_value.Values.ToArray(); // train the model Console.WriteLine("Training model...."); var learner = new OrdinaryLeastSquares(); var model = learner.Learn(feature, labels); // show results Console.WriteLine($"Slope: {model.Slope}"); Console.WriteLine($"Intercept: {model.Intercept}"); // validate the model var predictions = model.Transform(feature); var rmse = Math.Sqrt(new SquareLoss(labels).Loss(predictions)); var range = Math.Abs(labels.Max() - labels.Min()); Console.WriteLine($"Label range: {range}"); Console.WriteLine($"RMSE: {rmse} {rmse / range * 100:0.00}%"); // generate plot arrays var x = feature.Concat(feature).ToArray(); var y = predictions.Concat(labels).ToArray(); // set up color array var colors1 = Enumerable.Repeat(1, labels.Length).ToArray(); var colors2 = Enumerable.Repeat(2, labels.Length).ToArray(); var c = colors1.Concat(colors2).ToArray(); // plot the data var plot = new Scatterplot("Training", "feature", "label"); plot.Compute(x, y, c); ScatterplotBox.Show(plot); Console.ReadLine(); }
public void prediction_test() { // Example from http://www.real-statistics.com/multiple-regression/confidence-and-prediction-intervals/ var dt = Accord.IO.CsvReader.FromText(Resources.linreg, true).ToTable(); double[] y = dt.Columns["Poverty"].ToArray(); double[][] x = dt.ToArray("Infant Mort", "White", "Crime"); // Use Ordinary Least Squares to learn the regression OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); // Use OLS to learn the multiple linear regression MultipleLinearRegression regression = ols.Learn(x, y); Assert.AreEqual(3, regression.NumberOfInputs); Assert.AreEqual(1, regression.NumberOfOutputs); Assert.AreEqual(0.443650703716698, regression.Intercept, 1e-5); Assert.AreEqual(1.2791842411083394, regression.Weights[0], 1e-5); Assert.AreEqual(0.036259242392669415, regression.Weights[1], 1e-5); Assert.AreEqual(0.0014225014835705938, regression.Weights[2], 1e-5); double rse = regression.GetStandardError(x, y); Assert.AreEqual(rse, 2.4703520840798507, 1e-5); double[][] im = ols.GetInformationMatrix(); double mse = regression.GetStandardError(x, y); double[] se = regression.GetStandardErrors(mse, im); Assert.AreEqual(0.30063086032754965, se[0], 1e-10); Assert.AreEqual(0.033603448179240082, se[1], 1e-10); Assert.AreEqual(0.0022414548866296342, se[2], 1e-10); Assert.AreEqual(3.9879881671805824, se[3], 1e-10); double[] x0 = new double[] { 7, 80, 400 }; double y0 = regression.Transform(x0); Assert.AreEqual(y0, 12.867680376316864, 1e-5); double actual = regression.GetStandardError(x0, mse, im); Assert.AreEqual(0.35902764658470271, actual, 1e-10); DoubleRange ci = regression.GetConfidenceInterval(x0, mse, x.Length, im); Assert.AreEqual(ci.Min, 12.144995206616116, 1e-5); Assert.AreEqual(ci.Max, 13.590365546017612, 1e-5); actual = regression.GetPredictionStandardError(x0, mse, im); Assert.AreEqual(2.4963053239397244, actual, 1e-10); DoubleRange pi = regression.GetPredictionInterval(x0, mse, x.Length, im); Assert.AreEqual(pi.Min, 7.8428783761994554, 1e-5); Assert.AreEqual(pi.Max, 17.892482376434273, 1e-5); }
public static void ModelTrain() { // var m = RoomsAvito.GroupBy(x => x.id).Select(x => x.First()); // var RoomsAvito = HomeController.RoomsAvito.Take(30000); var m = repo.List().Count(); double[][] inp = new double[repo.List().Count()][]; double[] outp = new double[repo.List().Count()]; int i = 0; foreach (Room roomAvito in repo.List()) { int n = 1; if (roomAvito.room_type == "Вторичка") { n = 0; } double k = 0; foreach (MetroInfo info in MetroInfos) { if (info.metro == roomAvito.metro) { k = info.k; break; } } inp[i] = new double[] { k, roomAvito.centre_distance, roomAvito.metro_distance, roomAvito.S, roomAvito.num, n }; outp[i] = (int)roomAvito.price; i++; } Accord.Math.Random.Generator.Seed = 0; var ols = new OrdinaryLeastSquares(); { ols.UseIntercept = true; ols.IsRobust = true; }; regression = ols.Learn(inp, outp); Polynomial p = new Polynomial(2, 1); double[][] z = p.Transform(inp); // Now, create an usual OLS algorithm var ols1 = new OrdinaryLeastSquares() { UseIntercept = true }; // Use the algorithm to learn a multiple regression regression1 = ols1.Learn(z, outp); // Check the quality of the regression: }
private static double[] LinearRegression(List <Wine> testingSet, List <Wine> trainingSet) { var teacher = new OrdinaryLeastSquares(); var forest = teacher.Learn(trainingSet.Select(x => x.GetParams()).ToArray(), trainingSet.Select(x => (double)x.Quality).ToArray()); var result = forest.Transform(testingSet.Select(x => x.GetParams()).ToArray()); return(result); }
/// <summary> /// Run the lesson. /// </summary> public static void Run() { // get data Console.WriteLine("Loading data...."); var path = Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\..\california_housing.csv")); var housing = Frame.ReadCsv(path, separators: ","); housing = housing.Where(kv => ((decimal)kv.Value["median_house_value"]) < 500000); // create the median_high_house_value feature housing.AddColumn("median_high_house_value", housing["median_house_value"].Select(v => v.Value >= 265000 ? 1.0 : 0.0)); // shuffle the frame var rnd = new Random(); var indices = Enumerable.Range(0, housing.Rows.KeyCount).OrderBy(v => rnd.NextDouble()); housing = housing.IndexRowsWith(indices).SortRowsByKey(); // create training, validation, and test frames var training = housing.Rows[Enumerable.Range(0, 12000)]; var validation = housing.Rows[Enumerable.Range(12000, 2500)]; var test = housing.Rows[Enumerable.Range(14500, 2500)]; // build the list of features we're going to use var columns = new string[] { "latitude", "longitude", "housing_median_age", "total_rooms", "total_bedrooms", "population", "households", "median_income" }; // train the model using a linear regressor var learner = new OrdinaryLeastSquares() { IsRobust = true }; var regression = learner.Learn( training.Columns[columns].ToArray2D <double>().ToJagged(), training["median_high_house_value"].Values.ToArray()); // get probabilities var features_validation = validation.Columns[columns].ToArray2D <double>().ToJagged(); var label_validation = validation["median_high_house_value"].Values.ToArray(); var probabilities = regression.Transform(features_validation); // calculate the histogram of probabilities var histogram = new Histogram(); histogram.Compute(probabilities, 0.05); // draw the histogram Plot(histogram, "Probability Histogram", "prediction", "count"); }
static void Main(string[] args) { // sample input and output double[] inputs = { 10, 20, 30, 40, 50 }; double[] outputs = { 1, 2, 3, 4, 5 }; // 1. Linear Regression var learner = new OrdinaryLeastSquares() { UseIntercept = true }; var model = learner.Learn(inputs, outputs); var preds = model.Transform(inputs); Console.WriteLine("\n\n* Linear Regression Preds: {0}", String.Join(", ", preds)); // 2. Linear SVM var learner2 = new LinearRegressionNewtonMethod() { Epsilon = 2.1, Tolerance = 1e-5, UseComplexityHeuristic = true }; var svmInputs = inputs.Select(x => new double[] { x, x }).ToArray(); var model2 = learner2.Learn(svmInputs, outputs); var preds2 = model2.Score(svmInputs); Console.WriteLine("\n\n* Linear SVM Preds: {0}", String.Join(", ", preds2)); // 3. Polynomial SVM var learner3 = new FanChenLinSupportVectorRegression <Polynomial>() { Kernel = new Polynomial(3) }; var model3 = learner3.Learn(svmInputs, outputs); var preds3 = model3.Score(svmInputs); Console.WriteLine("\n\n* Polynomial SVM Preds: {0}", String.Join(", ", preds3)); // 4. Gaussian SVM var learner4 = new FanChenLinSupportVectorRegression <Gaussian>() { Kernel = new Gaussian() }; var model4 = learner4.Learn(svmInputs, outputs); var preds4 = model4.Score(svmInputs); Console.WriteLine("\n\n* Gaussian SVM Preds: {0}", String.Join(", ", preds4)); Console.WriteLine("\n\n\n\nDONE!!"); Console.ReadKey(); }
public void weight_test() { MultivariateLinearRegression reference; double[] referenceR2; { double[][] data = { new[] { 1.0, 10.7, 2.4 }, // new[] { 1.0, 10.7, 2.4 }, // new[] { 1.0, 10.7, 2.4 }, // new[] { 1.0, 10.7, 2.4 }, // new[] { 1.0, 10.7, 2.4 }, // 5 times weight 1 new[] { 1.0, 12.5, 3.6 }, new[] { 1.0, 43.2, 7.6 }, new[] { 1.0, 10.2, 1.1 }, }; double[][] x = Jagged.ColumnVector(data.GetColumn(1)); double[][] y = Jagged.ColumnVector(data.GetColumn(2)); var ols = new OrdinaryLeastSquares(); reference = ols.Learn(x, y); referenceR2 = reference.CoefficientOfDetermination(x, y); } MultivariateLinearRegression target; double[] targetR2; { double[][] data = { new[] { 5.0, 10.7, 2.4 }, // 1 times weight 5 new[] { 1.0, 12.5, 3.6 }, new[] { 1.0, 43.2, 7.6 }, new[] { 1.0, 10.2, 1.1 }, }; double[] weights = data.GetColumn(0); double[][] x = Jagged.ColumnVector(data.GetColumn(1)); double[][] y = Jagged.ColumnVector(data.GetColumn(2)); OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); target = ols.Learn(x, y, weights); targetR2 = target.CoefficientOfDetermination(x, y, weights: weights); } Assert.IsTrue(reference.Weights.IsEqual(target.Weights)); Assert.IsTrue(reference.Intercepts.IsEqual(target.Intercepts, 1e-8)); Assert.AreEqual(0.16387475666214069, target.Weights[0][0], 1e-6); Assert.AreEqual(0.59166925681755056, target.Intercepts[0], 1e-6); Assert.AreEqual(referenceR2[0], targetR2[0], 1e-8); Assert.AreEqual(0.91476129548901486, targetR2[0], 1e-10); }
public void weight_test_linear() { SimpleLinearRegression reference; double referenceR2; { double[][] data = { new[] { 1.0, 10.7, 2.4 }, // new[] { 1.0, 10.7, 2.4 }, // new[] { 1.0, 10.7, 2.4 }, // new[] { 1.0, 10.7, 2.4 }, // new[] { 1.0, 10.7, 2.4 }, // 5 times weight 1 new[] { 1.0, 12.5, 3.6 }, new[] { 1.0, 43.2, 7.6 }, new[] { 1.0, 10.2, 1.1 }, }; double[] x = data.GetColumn(1); double[] y = data.GetColumn(2); var ols = new OrdinaryLeastSquares(); reference = ols.Learn(x, y); referenceR2 = reference.CoefficientOfDetermination(x, y); } SimpleLinearRegression target; double targetR2; { double[][] data = { new[] { 5.0, 10.7, 2.4 }, // 1 times weight 5 new[] { 1.0, 12.5, 3.6 }, new[] { 1.0, 43.2, 7.6 }, new[] { 1.0, 10.2, 1.1 }, }; double[] weights = data.GetColumn(0); double[] x = data.GetColumn(1); double[] y = data.GetColumn(2); OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); target = ols.Learn(x, y, weights); targetR2 = target.CoefficientOfDetermination(x, y, weights); } Assert.AreEqual(reference.Slope, target.Slope); Assert.AreEqual(reference.Intercept, target.Intercept, 1e-8); Assert.AreEqual(0.16387475666214069, target.Slope, 1e-6); Assert.AreEqual(0.59166925681755056, target.Intercept, 1e-6); Assert.AreEqual(referenceR2, targetR2, 1e-8); Assert.AreEqual(0.91476129548901486, targetR2); }
public MultipleLinearRegression Learn(double[][] inputs, double[] outputs) { var ols = new OrdinaryLeastSquares() { UseIntercept = true }; // Use Ordinary Least Squares to estimate a regression model MultipleLinearRegression regression = ols.Learn(inputs, outputs); // As result, we will be given the following: //double a = regression.Weights[0]; // a = 0 //double b = regression.Weights[1]; // b = 0 //double c = regression.Intercept; // c = 1 // This is the plane described by the equation // ax + by + c = z => 0x + 0y + 1 = z => 1 = z. // We can compute the predicted points using double[] predicted = regression.Transform(inputs); // And the squared error loss using double error = new SquareLoss(outputs).Loss(predicted); // We can also compute other measures, such as the coefficient of determination r² double r2 = new RSquaredLoss(numberOfInputs: 2, expected: outputs).Loss(predicted); // should be 1 // We can also compute the adjusted or weighted versions of r² using var r2loss = new RSquaredLoss(numberOfInputs: 2, expected: outputs) { Adjust = true, // Weights = weights; // (if you have a weighted problem) }; double ar2 = r2loss.Loss(predicted); // should be 1 // Alternatively, we can also use the less generic, but maybe more user-friendly method directly: double ur2 = regression.CoefficientOfDetermination(inputs, outputs, adjust: true); // should be 1 Console.WriteLine("Weights:"); foreach (var w in regression.Weights) { Console.WriteLine($",{w}"); } Console.WriteLine("Intercept:"); Console.WriteLine($",{regression.Intercept}"); Console.WriteLine($"error:{error}"); Console.WriteLine($"r2:{r2}"); Console.WriteLine($"r2loss:{r2loss}"); Console.WriteLine($"ar2:{ar2}"); Console.WriteLine($"ur2:{ur2}"); return(regression); }
public void Learn(IList <XYtoZ> dsLearn) { double [][] inputs = dsLearn.Select(i => new double[] { i.X, i.Y }).ToArray(); double [] outputs = dsLearn.Select(i => i.Z).ToArray(); var ols = new OrdinaryLeastSquares() { IsRobust = _isRobust }; _multipleLinearRegression = ols.Learn(inputs, outputs); }
public static SimpleLinearRegression AnalyzeMonthToGradeDependency() { CalculateCorrelationMonthToGrade(); OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); SimpleLinearRegression regression = ols.Learn(DataHandler.Reviews.Select(r => (double)r.reviewTime.Month).ToArray(), DataHandler.Reviews.Select(r => r.overall).ToArray()); double s = regression.Slope; double c = regression.Intercept; return(regression); }
public void Learn(IList <XtoY> dsLearn) { double [] inputs = dsLearn.Select(i => i.X).ToArray(); double [] outputs = dsLearn.Select(i => i.Y).ToArray(); var ols = new OrdinaryLeastSquares() { IsRobust = _isRobust }; _simpleLinearRegression = ols.Learn(inputs, outputs); }
public static void TrainRegression() { // use ordinary least squares as train type var ols = new OrdinaryLeastSquares() { UseIntercept = true }; // Use Ordinary Least Squares to estimate a regression model Predictor.MultipleGeneralRegression = ols.Learn(PredictorPointsTrain, FrequencyLabelsDouble); }
public double Slope(KalibreringDTO kDTO) { double[] kalibreringer = new double[] { (kDTO.KalibrerDoubles[0] + kDTO.KalibrerDoubles[3]) / 2, (kDTO.KalibrerDoubles[1] + kDTO.KalibrerDoubles[4]) / 2, (kDTO.KalibrerDoubles[2] + kDTO.KalibrerDoubles[5]) / 2 }; double[] output = new double[] { 10, 50, 100 }; OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); SimpleLinearRegression regression = ols.Learn(kalibreringer, output); slope = regression.Slope; return(slope); }
/// <summary> /// Calculates the Variance Inflation Factors (VIFs) for the different coefficients. /// </summary> /// <returns>An array containing corresponding VIFs.</returns> /// <param name="inputs">The inputs that a model was trained on.</param> public static float[] CalculateVIFs(double[][] inputs) { //Rotate array and create resultant array. inputs = MathUtils.RotateArray(inputs); float[] VIFs = new float[inputs.Length]; //Loop through each variable for (int a = 0; a < inputs.Length; a++) { //The inputs/outputs for the regression models. double[][] regressionInputs = new double[inputs[0].Length][]; double[] regressionOutput = new double[inputs[0].Length]; //Loop through and assign all of the independent variables as IVs, //except inputs[a], which becomes the dependent variable. for (int b = 0; b < inputs[0].Length; b++) { regressionInputs[b] = new double[inputs.Length - 1]; for (int c = 0, d = 0; c < inputs.Length; c++) { if (a == c) { regressionOutput[b] = inputs[a][b]; } else { regressionInputs[b][d] = inputs[c][b]; d++; } } } //Perform regression OrdinaryLeastSquares ols = new OrdinaryLeastSquares() { UseIntercept = true }; MultipleLinearRegression regression = ols.Learn(regressionInputs, regressionOutput); //Make predictions double[] predictions = regression.Transform(regressionInputs); //Calculate the loss double r2 = (new RSquaredLoss(inputs.Length - 1, regressionOutput)).Loss(predictions); //Calculate the VIF VIFs[a] = (float)(1.0f / (1.0f - r2)); } return(VIFs); }
private void Train(IEnumerable <SprintDataRow> trainingDataset) { // Set the independant variables double[][] inputs = trainingDataset.Select(x => new double[] { x.SprintNumber, x.HoursProgrammer1, x.HoursProgrammer2, x.HoursProgrammer3 }).ToArray(); // Set the dependant variables double[] outputs = trainingDataset.Select(x => x.NumberOfProcessedStoryPoints).ToArray(); // Train the model var ols = new OrdinaryLeastSquares(); this._multipleLinearRegressionModel = ols.Learn(inputs, outputs); }
public RegressionResult PerformRegression(double[] trainX, double[] trainY, double[] testX, double[] testY) { OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); SimpleLinearRegression regression = ols.Learn(trainX, trainY); return(new RegressionResult { FormulaUsed = regression.ToString(), PredictionOnTestSet = testX.Select(regression.Transform).ToArray(), PredictionOnTrainingSet = trainX.Select(regression.Transform).ToArray(), Regression = regression }); }
/// <summary> /// Gets a fitted approximation to the forward values. /// </summary> /// <param name="date">The date at which the regressors should be observed.</param> /// <param name="cfs">The sum of the PV of all the cashflows on the path that take place after <paramref name="date"/>.</param> /// <returns></returns> public double[] FitCFs(Date date, double[] cfs) { //double[][] inputs = GetPolynomialValsRegular(date, 3); var inputs = GetIntrinsic(date, 10); var ols = new OrdinaryLeastSquares { UseIntercept = true, IsRobust = true }; var regression = ols.Learn(inputs, cfs); var result = regression.Transform(inputs); return(result); }
private void Train(IEnumerable <SprintDataRow> trainingDataset) { // Our independant variable is the number of hours double[] inputs = trainingDataset.Select(x => Convert.ToDouble(x.NumberOfHours)).ToArray(); // Our dependant variable is the number of processed story points double[] outputs = trainingDataset.Select(x => x.NumberOfProcessedStoryPoints).ToArray(); // Train the model OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); this._linearRegressionModel = ols.Learn(inputs, outputs); }
public double EstimateSurface(uint price) { var apartments = _repository.GetAll(); double[] inputs = apartments.Select(x => (double)x.Price).ToArray(); double[] outputs = apartments.Select(x => x.Surface).ToArray(); var ols = new OrdinaryLeastSquares(); var regression = ols.Learn(inputs, outputs); double result = regression.Transform(price); return(result); }
/// <summary> /// Register data that corresponds to the gesture /// </summary> protected override void RegisterGesture() { //We only detectr frame with a minimum of velocity in the palm gesture if (Math.Abs(this.SelectedHand.PalmVelocity.x) >= MIN_GESTURE_VELOCITY_X_FRAME_DETECTION) { //We keep the departure point for the gesture if (_frameGestureCount == 0) { _gestureFirstPoint = this.SelectedHand.StabilizedPalmPosition; } _frameGestureCount++; //Determine the direction of the initiated gesture _currentGestureDirection = this.SelectedHand.PalmVelocity.x > 0 ? Side.Right : Side.Left; _inputs.Add(this.SelectedHand.StabilizedPalmPosition.x); _outputs.Add(this.SelectedHand.StabilizedPalmPosition.y); //Use Ordinary Least Squares to learn the regression try { _regression = _ols.Learn(_inputs.ToArray(), _outputs.ToArray()); //Gets the coefficient of determination, as known R-squared _coefficientDetermination = _regression.CoefficientOfDetermination(_inputs.ToArray(), _outputs.ToArray()); //Checking max velocity on the gesture //Abs use for compatibility for both gesture (right and left) _xVelocityMax = Math.Max(Math.Abs(this.SelectedHand.PalmVelocity.x), _xVelocityMax); _xVelocityMin = Math.Min(Math.Abs(this.SelectedHand.PalmVelocity.x), _xVelocityMin); //Calc the distance from the first point of the gesture //Do the hypothenus of the triangle given from the delta between the first point and the current point _distance = Math.Sqrt(Math.Pow(this.SelectedHand.StabilizedPalmPosition.x - _gestureFirstPoint.x, 2) + Math.Pow(this.SelectedHand.StabilizedPalmPosition.y - _gestureFirstPoint.y, 2)); } catch (InvalidOperationException ex) { Console.WriteLine("Exception: {0}", ex.Message); _regression = null; _frameGestureCount = 0; _xVelocityMax = 0; _xVelocityMin = Double.MaxValue; _distance = 0; _inputs.Clear(); _outputs.Clear(); } } }
public void logarithm_learn() { #region doc_learn // This is the same data from the example available at // http://mathbits.com/MathBits/TISection/Statistics2/logarithmic.htm // Declare your inputs and output data double[] inputs = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; double[] outputs = { 6, 9.5, 13, 15, 16.5, 17.5, 18.5, 19, 19.5, 19.7, 19.8 }; // Transform inputs to logarithms double[] logx = Matrix.Log(inputs); // Use Ordinary Least Squares to learn the regression OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); // Use OLS to learn the simple linear regression SimpleLinearRegression lr = ols.Learn(logx, outputs); // Compute predicted values for inputs double[] predicted = lr.Transform(logx); // Get an expression representing the learned regression model // We just have to remember that 'x' will actually mean 'log(x)' string result = lr.ToString("N4", CultureInfo.InvariantCulture); // Result will be "y(x) = 6.1082x + 6.0993" // The mean squared error between the expected and the predicted is double error = new SquareLoss(outputs).Loss(predicted); // 0.261454 #endregion Assert.AreEqual(0.26145460024250794, error, 1e-8); Assert.AreEqual(6.1081800414945704, lr.Slope, 1e-8); Assert.AreEqual(6.0993411396126653, lr.Intercept, 1e-8); Assert.AreEqual("y(x) = 6.1082x + 6.0993", result); }
public void learn_test() { #region doc_learn // We will try to model a plane as an equation in the form // "ax + by + c = z". We have two input variables (x and y) // and we will be trying to find two parameters a and b and // an intercept term c. // We will use Ordinary Least Squares to create a // linear regression model with an intercept term var ols = new OrdinaryLeastSquares() { UseIntercept = true }; // Now suppose you have some points double[][] inputs = { new double[] { 1, 1 }, new double[] { 0, 1 }, new double[] { 1, 0 }, new double[] { 0, 0 }, }; // located in the same Z (z = 1) double[] outputs = { 1, 1, 1, 1 }; // Use Ordinary Least Squares to estimate a regression model MultipleLinearRegression regression = ols.Learn(inputs, outputs); // As result, we will be given the following: double a = regression.Coefficients[0]; // a = 0 double b = regression.Coefficients[1]; // b = 0 double c = regression.Intercept; // c = 1 // This is the plane described by the equation // ax + by + c = z => 0x + 0y + 1 = z => 1 = z. // We can compute the predicted points using double[] predicted = regression.Transform(inputs); // And the squared error loss using double error = new SquareLoss(outputs).Loss(predicted); #endregion Assert.AreEqual(2, regression.NumberOfInputs); Assert.AreEqual(1, regression.NumberOfOutputs); Assert.AreEqual(0.0, a, 1e-6); Assert.AreEqual(0.0, b, 1e-6); Assert.AreEqual(1.0, c, 1e-6); Assert.AreEqual(0.0, error, 1e-6); double[] expected = regression.Compute(inputs); double[] actual = regression.Transform(inputs); Assert.IsTrue(expected.IsEqual(actual, 1e-10)); double r = regression.CoefficientOfDetermination(inputs, outputs); Assert.AreEqual(1.0, r); }
public void learn_test() { #region doc_learn // Let's say we have some univariate, continuous sets of input data, // and a corresponding univariate, continuous set of output data, such // as a set of points in R². A simple linear regression is able to fit // a line relating the input variables to the output variables in which // the minimum-squared-error of the line and the actual output points // is minimum. // Declare some sample test data. double[] inputs = { 80, 60, 10, 20, 30 }; double[] outputs = { 20, 40, 30, 50, 60 }; // Use Ordinary Least Squares to learn the regression OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); // Use OLS to learn the simple linear regression SimpleLinearRegression regression = ols.Learn(inputs, outputs); // Compute the output for a given input: double y = regression.Transform(85); // The answer will be 28.088 // We can also extract the slope and the intercept term // for the line. Those will be -0.26 and 50.5, respectively. double s = regression.Slope; // -0.264706 double c = regression.Intercept; // 50.588235 #endregion // Expected slope and intercept double eSlope = -0.264706; double eIntercept = 50.588235; Assert.AreEqual(28.088235294117649, y, 1e-10); Assert.AreEqual(eSlope, s, 1e-5); Assert.AreEqual(eIntercept, c, 1e-5); Assert.IsFalse(double.IsNaN(y)); }
public void prediction_test() { // example data from http://www.real-statistics.com/regression/confidence-and-prediction-intervals/ double[][] input = { new double[] { 5, 80 }, new double[] { 23, 78 }, new double[] { 25, 60 }, new double[] { 48, 53 }, new double[] { 17, 85 }, new double[] { 8, 84 }, new double[] { 4, 73 }, new double[] { 26, 79 }, new double[] { 11, 81 }, new double[] { 19, 75 }, new double[] { 14, 68 }, new double[] { 35, 72 }, new double[] { 29, 58 }, new double[] { 4, 92 }, new double[] { 23, 65 }, }; double[] cig = input.GetColumn(0); double[] exp = input.GetColumn(1); // Use Ordinary Least Squares to learn the regression OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); // Use OLS to learn the simple linear regression SimpleLinearRegression regression = ols.Learn(cig, exp); Assert.AreEqual(1, regression.NumberOfInputs); Assert.AreEqual(1, regression.NumberOfOutputs); double x0 = 20; double y0 = regression.Transform(x0); Assert.AreEqual(y0, 73.1564, 1e-4); double syx = regression.GetStandardError(cig, exp); Assert.AreEqual(7.974682, syx, 1e-5); double ssx = cig.Subtract(cig.Mean()).Pow(2).Sum(); Assert.AreEqual(2171.6, ssx, 1e-5); double n = exp.Length; double x0c = x0 - cig.Mean(); double var = 1 / n + (x0c * x0c) / ssx; Assert.AreEqual(0.066832443052741455, var, 1e-10); double expected = syx * Math.Sqrt(var); double actual = regression.GetStandardError(x0, cig, exp); Assert.AreEqual(2.061612, expected, 1e-5); Assert.AreEqual(expected, actual, 1e-10); DoubleRange ci = regression.GetConfidenceInterval(x0, cig, exp); Assert.AreEqual(ci.Min, 68.702569616457751, 1e-5); Assert.AreEqual(ci.Max, 77.610256563931543, 1e-5); actual = regression.GetPredictionStandardError(x0, cig, exp); Assert.AreEqual(8.2368569010499666, actual, 1e-10); DoubleRange pi = regression.GetPredictionInterval(x0, cig, exp); Assert.AreEqual(pi.Min, 55.361765613397054, 1e-5); Assert.AreEqual(pi.Max, 90.95106056699224, 1e-5); }
public void new_api_test() { #region doc_learn // Fix the random number generator Accord.Math.Random.Generator.Seed = 0; double[,] data = // This is the same data used in the RANSAC sample app { { 1.0, 0.79 }, { 3, 2.18 }, { 5, 5.99 }, { 7.0, 7.65 }, { 9.0, 9.55 }, { 11, 11.89 }, { 13, 13.73 }, { 15.0, 14.77 }, { 17.0, 18.00 }, { 1.2, 1.45 }, { 1.5, 1.18 }, { 1.8, 1.92 }, { 2.1, 1.47 }, { 2.4, 2.41 }, { 2.7, 2.35 }, { 3.0, 3.41 }, { 3.3, 3.78 }, { 3.6, 3.21 }, { 3.9, 4.76 }, { 4.2, 5.03 }, { 4.5, 4.19 }, { 4.8, 3.81 }, { 5.1, 6.07 }, { 5.4, 5.74 }, { 5.7, 6.39 }, { 6, 6.11 }, { 6.3, 6.86 }, { 6.6, 6.35 }, { 6.9, 7.9 }, { 7.2, 8.04 }, { 7.5, 8.48 }, { 7.8, 8.07 }, { 8.1, 8.22 }, { 8.4, 8.41 }, { 8.7, 9.4 }, { 9, 8.8 }, { 9.3, 8.44 }, { 9.6, 9.32 }, { 9.9, 9.18 }, { 10.2, 9.86 }, { 10.5, 10.16 }, { 10.8, 10.28 }, { 11.1, 11.07 }, { 11.4, 11.66 }, { 11.7, 11.13 }, { 12, 11.55 }, { 12.3, 12.62 }, { 12.6, 12.27 }, { 12.9, 12.33 }, { 13.2, 12.37 }, { 13.5, 12.75 }, { 13.8, 14.44 }, { 14.1, 14.71 }, { 14.4, 13.72 }, { 14.7, 14.54 }, { 15, 14.67 }, { 15.3, 16.04 }, { 15.6, 15.21 }, { 1, 3.9 }, { 2, 11.5 }, { 3.0, 13.0 }, { 4, 0.9 }, { 5, 5.5 }, { 6, 16.2 }, { 7.0, 0.8 }, { 8, 9.4 }, { 9, 9.5 }, { 10, 17.5 }, { 11.0, 6.3 }, { 12, 12.6 }, { 13, 1.5 }, { 14, 1.5 }, { 2.0, 10 }, { 3, 9 }, { 15, 2 }, { 15.5, 1.2 }, }; // First, fit simple linear regression directly for comparison reasons. double[] x = data.GetColumn(0); // Extract the independent variable double[] y = data.GetColumn(1); // Extract the dependent variable // Use Ordinary Least Squares to learn the regression OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); // Estimate a line passing through the (x, y) points SimpleLinearRegression regression = ols.Learn(x, y); // Now, compute the values predicted by the // regression for the original input points double[] commonOutput = regression.Transform(x); // Now, fit simple linear regression using RANSAC int maxTrials = 1000; int minSamples = 20; double probability = 0.950; double errorThreshold = 1000; // Create a RANSAC algorithm to fit a simple linear regression var ransac = new RANSAC<SimpleLinearRegression>(minSamples) { Probability = probability, Threshold = errorThreshold, MaxEvaluations = maxTrials, // Define a fitting function Fitting = (int[] sample) => { // Build a Simple Linear Regression model return new OrdinaryLeastSquares() .Learn(x.Get(sample), y.Get(sample)); }, // Define a inlier detector function Distances = (SimpleLinearRegression r, double threshold) => { var inliers = new List<int>(); for (int i = 0; i < x.Length; i++) { // Compute error for each point double error = r.Transform(x[i]) - y[i]; // If the square error is low enough, if (error * error < threshold) inliers.Add(i); // the point is considered an inlier. } return inliers.ToArray(); } }; // Now that the RANSAC hyperparameters have been specified, we can // compute another regression model using the RANSAC algorithm: int[] inlierIndices; SimpleLinearRegression robustRegression = ransac.Compute(data.Rows(), out inlierIndices); // Compute the output of the model fitted by RANSAC double[] ransacOutput = robustRegression.Transform(x); #endregion Assert.AreEqual(ransac.TrialsNeeded, 0); Assert.AreEqual(ransac.TrialsPerformed, 1); string a = inlierIndices.ToCSharp(); string b = ransacOutput.ToCSharp(); int[] expectedInliers = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 }; double[] expectedOutput = new double[] { 1.96331236445045, 3.42042856976283, 4.87754477507521, 6.33466098038758, 7.79177718569996, 9.24889339101234, 10.7060095963247, 12.1631258016371, 13.6202420069495, 2.10902398498169, 2.32759141577855, 2.5461588465754, 2.76472627737226, 2.98329370816912, 3.20186113896597, 3.42042856976283, 3.63899600055969, 3.85756343135654, 4.0761308621534, 4.29469829295026, 4.51326572374711, 4.73183315454397, 4.95040058534082, 5.16896801613768, 5.38753544693454, 5.6061028777314, 5.82467030852825, 6.04323773932511, 6.26180517012196, 6.48037260091882, 6.69894003171568, 6.91750746251253, 7.13607489330939, 7.35464232410625, 7.5732097549031, 7.79177718569996, 8.01034461649682, 8.22891204729367, 8.44747947809053, 8.66604690888738, 8.88461433968424, 9.1031817704811, 9.32174920127795, 9.54031663207481, 9.75888406287167, 9.97745149366852, 10.1960189244654, 10.4145863552622, 10.6331537860591, 10.8517212168559, 11.0702886476528, 11.2888560784497, 11.5074235092465, 11.7259909400434, 11.9445583708402, 12.1631258016371, 12.3816932324339, 12.6002606632308, 1.96331236445045, 2.69187046710664, 3.42042856976283, 4.14898667241902, 4.87754477507521, 5.6061028777314, 6.33466098038758, 7.06321908304377, 7.79177718569996, 8.52033528835615, 9.24889339101234, 9.97745149366852, 10.7060095963247, 11.4345676989809, 2.69187046710664, 3.42042856976283, 12.1631258016371, 12.5274048529652 }; Assert.IsTrue(inlierIndices.IsEqual(expectedInliers)); Assert.IsTrue(ransacOutput.IsEqual(expectedOutput, 1e-10)); }
public void prediction_test() { // Example from http://www.real-statistics.com/multiple-regression/confidence-and-prediction-intervals/ var dt = Accord.IO.CsvReader.FromText(Resources.linreg, true).ToTable(); double[][] y = dt.ToArray("Poverty"); double[][] x = dt.ToArray("Infant Mort", "White", "Crime"); // Use Ordinary Least Squares to learn the regression OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); // Use OLS to learn the multiple linear regression MultivariateLinearRegression regression = ols.Learn(x, y); Assert.AreEqual(3, regression.NumberOfInputs); Assert.AreEqual(1, regression.NumberOfOutputs); Assert.AreEqual(0.443650703716698, regression.Intercepts[0], 1e-5); Assert.AreEqual(1.2791842411083394, regression.Weights[0][0], 1e-5); Assert.AreEqual(0.036259242392669415, regression.Weights[1][0], 1e-5); Assert.AreEqual(0.0014225014835705938, regression.Weights[2][0], 1e-5); double rse = regression.GetStandardError(x, y)[0]; Assert.AreEqual(rse, 2.4703520840798507, 1e-5); double[][] im = ols.GetInformationMatrix(); double[] mse = regression.GetStandardError(x, y); double[][] se = regression.GetStandardErrors(mse, im); Assert.AreEqual(0.30063086032754965, se[0][0], 1e-10); Assert.AreEqual(0.033603448179240082, se[0][1], 1e-10); Assert.AreEqual(0.0022414548866296342, se[0][2], 1e-10); Assert.AreEqual(3.9879881671805824, se[0][3], 1e-10); double[] x0 = new double[] { 7, 80, 400 }; double y0 = regression.Transform(x0)[0]; Assert.AreEqual(y0, 12.867680376316864, 1e-5); double actual = regression.GetStandardError(x0, mse, im)[0]; Assert.AreEqual(0.35902764658470271, actual, 1e-10); DoubleRange ci = regression.GetConfidenceInterval(x0, mse, x.Length, im)[0]; Assert.AreEqual(ci.Min, 12.144995206616116, 1e-5); Assert.AreEqual(ci.Max, 13.590365546017612, 1e-5); actual = regression.GetPredictionStandardError(x0, mse, im)[0]; Assert.AreEqual(2.4963053239397244, actual, 1e-10); DoubleRange pi = regression.GetPredictionInterval(x0, mse, x.Length, im)[0]; Assert.AreEqual(pi.Min, 7.8428783761994554, 1e-5); Assert.AreEqual(pi.Max, 17.892482376434273, 1e-5); }
public void learn_test1() { #region doc_learn // The multivariate linear regression is a generalization of // the multiple linear regression. In the multivariate linear // regression, not only the input variables are multivariate, // but also are the output dependent variables. // In the following example, we will perform a regression of // a 2-dimensional output variable over a 3-dimensional input // variable. double[][] inputs = { // variables: x1 x2 x3 new double[] { 1, 1, 1 }, // input sample 1 new double[] { 2, 1, 1 }, // input sample 2 new double[] { 3, 1, 1 }, // input sample 3 }; double[][] outputs = { // variables: y1 y2 new double[] { 2, 3 }, // corresponding output to sample 1 new double[] { 4, 6 }, // corresponding output to sample 2 new double[] { 6, 9 }, // corresponding output to sample 3 }; // With a quick eye inspection, it is possible to see that // the first output variable y1 is always the double of the // first input variable. The second output variable y2 is // always the triple of the first input variable. The other // input variables are unused. Nevertheless, we will fit a // multivariate regression model and confirm the validity // of our impressions: // Use Ordinary Least Squares to create the regression OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); // Now, compute the multivariate linear regression: MultivariateLinearRegression regression = ols.Learn(inputs, outputs); // We can obtain predictions using double[][] predictions = regression.Transform(inputs); // The prediction error is double error = new SquareLoss(outputs).Loss(predictions); // 0 // At this point, the regression error will be 0 (the fit was // perfect). The regression coefficients for the first input // and first output variables will be 2. The coefficient for // the first input and second output variables will be 3. All // others will be 0. // // regression.Coefficients should be the matrix given by // // double[,] coefficients = { // { 2, 3 }, // { 0, 0 }, // { 0, 0 }, // }; // // We can also check the r-squared coefficients of determination: double[] r2 = regression.CoefficientOfDetermination(inputs, outputs); #endregion // The first input variable coefficients will be 2 and 3: Assert.AreEqual(2, regression.Coefficients[0, 0], 1e-10); Assert.AreEqual(3, regression.Coefficients[0, 1], 1e-10); // And all other coefficients will be 0: Assert.AreEqual(0, regression.Coefficients[1, 0], 1e-10); Assert.AreEqual(0, regression.Coefficients[1, 1], 1e-10); Assert.AreEqual(0, regression.Coefficients[2, 0], 1e-10); Assert.AreEqual(0, regression.Coefficients[2, 1], 1e-10); Assert.AreEqual(3, regression.NumberOfInputs); Assert.AreEqual(2, regression.NumberOfOutputs); // Which should be one for both output variables: Assert.AreEqual(1, r2[0]); Assert.AreEqual(1, r2[1]); foreach (var e in regression.Coefficients) Assert.IsFalse(double.IsNaN(e)); Assert.AreEqual(0, error, 1e-10); Assert.IsFalse(double.IsNaN(error)); }
private void btnCompute_Click(object sender, EventArgs e) { DataTable dataTable = dgvAnalysisSource.DataSource as DataTable; if (dataTable == null) return; // Gather the available data double[][] data = dataTable.ToArray(); // First, fit simple linear regression directly for comparison reasons. double[] x = data.GetColumn(0); // Extract the independent variable double[] y = data.GetColumn(1); // Extract the dependent variable // Use Ordinary Least Squares to learn the regression OrdinaryLeastSquares ols = new OrdinaryLeastSquares(); // Estimate a line passing through the (x, y) points SimpleLinearRegression regression = ols.Learn(x, y); // Now, compute the values predicted by the // regression for the original input points double[] commonOutput = regression.Transform(x); // Now, fit simple linear regression using RANSAC int maxTrials = (int)numMaxTrials.Value; int minSamples = (int)numSamples.Value; double probability = (double)numProbability.Value; double errorThreshold = (double)numThreshold.Value; // Create a RANSAC algorithm to fit a simple linear regression var ransac = new RANSAC<SimpleLinearRegression>(minSamples) { Probability = probability, Threshold = errorThreshold, MaxEvaluations = maxTrials, // Define a fitting function Fitting = delegate(int[] sample) { // Retrieve the training data double[] inputs = x.Get(sample); double[] outputs = y.Get(sample); // Build a Simple Linear Regression model return new OrdinaryLeastSquares().Learn(inputs, outputs); }, // Define a check for degenerate samples Degenerate = delegate(int[] sample) { // In this case, we will not be performing such checks. return false; }, // Define a inlier detector function Distances = delegate(SimpleLinearRegression r, double threshold) { List<int> inliers = new List<int>(); for (int i = 0; i < x.Length; i++) { // Compute error for each point double error = r.Transform(x[i]) - y[i]; // If the squared error is below the given threshold, // the point is considered to be an inlier. if (error * error < threshold) inliers.Add(i); } return inliers.ToArray(); } }; // Now that the RANSAC hyperparameters have been specified, we can // compute another regression model using the RANSAC algorithm: int[] inlierIndices; SimpleLinearRegression robustRegression = ransac.Compute(data.Length, out inlierIndices); if (robustRegression == null) { lbStatus.Text = "RANSAC failed. Please try again after adjusting its parameters."; return; // the RANSAC algorithm did not find any inliers and no model was created } // Compute the output of the model fitted by RANSAC double[] ransacOutput = robustRegression.Transform(x); // Create scatter plot comparing the outputs from the standard // linear regression and the RANSAC-fitted linear regression. CreateScatterplot(graphInput, x, y, commonOutput, ransacOutput, x.Get(inlierIndices), y.Get(inlierIndices)); lbStatus.Text = "Regression created! Please compare the RANSAC " + "regression (blue) with the simple regression (in red)."; }