public override void Init(IRepository repository, IEnumerable<string> releases) { base.Init(repository, releases); regression = new LogisticRegression(); string previousRevision = null; foreach (var revision in TrainReleases) { foreach (var file in GetFilesInRevision(revision)) { context .SetCommits(previousRevision, revision) .SetFiles(e => e.IdIs(file.ID)); regression.AddTrainingData( GetPredictorValuesFor(context), FileHasDefects(file.ID, revision, previousRevision) ); } previousRevision = revision; } regression.Train(); context.SetCommits(TrainReleases.Last(), PredictionRelease); }
private static LogisticRegression<bool> GetLogisticRegression(double[,] samples, bool[] knownOutput) { var clf = new LogisticRegression<bool>(); clf.Fit(DenseMatrix.OfArray(samples), knownOutput); return clf; }
/// <summary> /// Constructs a new Iterative Reweighted Least Squares. /// </summary> /// /// <param name="regression">The regression to estimate.</param> /// public IterativeReweightedLeastSquares(LogisticRegression regression) { this.regression = regression; this.parameterCount = regression.Coefficients.Length; this.hessian = new double[parameterCount, parameterCount]; this.gradient = new double[parameterCount]; }
static void Main(string[] args) { if (args.Length != 2) { Console.WriteLine("TestLogisticRegression [train corpus file name] [test corpus file name]"); return; } double[][] inputs; double[] outputs; Console.WriteLine("Loading train corpus..."); //Load training corpus LoadCorpusFromFile(args[0], out inputs, out outputs); //Try to normalize output value Normalize(outputs); Console.WriteLine("Logistic regression..."); LogisticRegression lr = new LogisticRegression(inputs[0].Length); double error = lr.Regress(inputs, outputs); Console.WriteLine("Parameter list:"); for (int i = 0; i < lr.Coefficients.Length; i++) { Console.WriteLine("Coefficient {0}: {1}", i, lr.Coefficients[i]); } Console.WriteLine("Delta: {0}", error); Console.WriteLine(); //Load test corpus Console.WriteLine("Testing regress result:"); LoadCorpusFromFile(args[1], out inputs, out outputs); //Try to normalize output value Normalize(outputs); for (int i = 0; i < outputs.Length; i++) { StringBuilder sb = new StringBuilder(); double output = lr.Compute(inputs[i]); for (int j = 0; j < inputs[i].Length; j++) { sb.Append(inputs[i][j].ToString() + " "); } sb.Append(outputs[i] + " RV:" + output); sb.Append(" Err:" + (output - outputs[i]).ToString()); Console.WriteLine(sb.ToString()); } }
public void HypothesisReturnsThetaZeroSigmoidIfXsIsEmpty() { // arrange var rnd = new Random(); var randomDouble = rnd.NextDouble(); var expectedResult = LogisticRegression.Sigmoid(randomDouble); IList <double> xs = new double[0]; IList <double> thetas = new double[] { randomDouble }; // act var result = LogisticRegression.Hypothesis(xs, thetas); // assert Assert.AreEqual(expectedResult, result, 1E-13); }
private static double[] gradient(double[][] input, double[] output, bool stochastic) { LogisticRegression regression; LogisticGradientDescent teacher; regression = new LogisticRegression(inputs: 2); teacher = new LogisticGradientDescent(regression) { Stochastic = stochastic, LearningRate = 1e-4, }; teacher.Run(input, output); return(teacher.Gradient); }
public ICU() { InitializeComponent(); current_frame_num1 = 0; current_frame_num2 = 0; F_E = new FeaturesExtraction(); knn = Serializer.Load <KNearestNeighbors>(Path.Combine(path, "knn7.bin")); RF = Serializer.Load <RandomForest>(Path.Combine(path, "RF7.bin")); LR = Serializer.Load <LogisticRegression>(Path.Combine(path, "LR7.bin")); SVM = Serializer.Load <SupportVectorMachine <Gaussian> >(Path.Combine(path, "SVM7.bin")); NB = Serializer.Load <NaiveBayes>(Path.Combine(path, "NB7.bin")); HMM = Serializer.Load <HiddenMarkovModel>(Path.Combine(path, "HMM_seq7.bin")); dataGridView1.RowTemplate.Height = 120; ((DataGridViewImageColumn)dataGridView1.Columns[0]).ImageLayout = DataGridViewImageCellLayout.Stretch; dataGridView1.Columns[1].Visible = false; }
void Update() { timeLap = timeLap + Time.deltaTime; GameObject[] PODs = GameObject.FindGameObjectsWithTag("LRPlayer"); if (PODs.Length == 0) { timesRessurect = timesRessurect + 1; decisionThrust = DecisionThrust(InpThrust, OutThrust); decisionSteer = DecisionSteer(InpSteer, OutSteer); CarInstantiate(); dataSizeSt = 1; dataSizeTh = 1; InpThrust = new double[dataSizeTh][]; InpThrust[0] = new double[4]; OutThrust = new int[1]; OutThrust[0] = 1; InpSteer = new double[dataSizeSt][]; InpSteer[0] = new double[5]; OutSteer = new int[1]; OutSteer[0] = 0; for (int i = 0; i < 4; i++) { InpThrust[0][i] = i; } for (int i = 0; i < 5; i++) { InpSteer[0][i] = i; } } if (timeScale != timeScaleAnt) { if (PODs.Length != 0) { for (int i = 0; i < PODs.Length; i++) { PODs[i].GetComponent <LRPlayerController>().SetTimeScale(timeScale); } } timeScaleAnt = timeScale; } }
public static LogisticRegression LoadAccordNetLogisticRegressionModel(String savedCoefficientFile) { StreamReader sr = new StreamReader(savedCoefficientFile); String[] weightsStr = sr.ReadLine().Trim().Split("\t".ToCharArray()); double[] weights = new double[weightsStr.Length]; for (int i = 0; i < weights.Length; i++) { weights[i] = double.Parse(weightsStr[i]); } double intercept = double.Parse(sr.ReadLine()); LogisticRegression lrAccord = new LogisticRegression(); lrAccord.Weights = weights; lrAccord.Intercept = intercept; return(lrAccord); }
public async Task CreateLogisticRegressionFromRemoteSource() { Client c = new Client(userName, apiKey); Source.Arguments args = new Source.Arguments(); args.Add("remote", "https://static.bigml.com/csv/iris.csv"); args.Add("name", "C# tests - Iris"); Source s = await c.CreateSource(args); s = await c.Wait <Source>(s.Resource); Assert.AreEqual(s.StatusMessage.StatusCode, Code.Finished); DataSet.Arguments argsDS = new DataSet.Arguments(); argsDS.Add("source", s.Resource); DataSet ds = await c.CreateDataset(argsDS); ds = await c.Wait <DataSet>(ds.Resource); Assert.AreEqual(ds.StatusMessage.StatusCode, Code.Finished); LogisticRegression.Arguments argsTM = new LogisticRegression.Arguments(); argsTM.Add("dataset", ds.Resource); LogisticRegression lr = await c.CreateLogisticRegression(argsTM); lr = await c.Wait <LogisticRegression>(lr.Resource); // test it is finished Assert.AreEqual(lr.StatusMessage.StatusCode, Code.Finished); // test update method Newtonsoft.Json.Linq.JObject changes = new Newtonsoft.Json.Linq.JObject(); Newtonsoft.Json.Linq.JArray tags = new Newtonsoft.Json.Linq.JArray(); tags.Add("Bindings C# test"); changes.Add("tags", tags); lr = await c.Update <LogisticRegression>(lr.Resource, changes); Assert.AreEqual(lr.Code, System.Net.HttpStatusCode.Accepted); await c.Delete(s); await c.Delete(ds); await c.Delete(lr); }
public static void Train() { DataHandler.ImportReviewData(3); var maxCount = 1; double[][] input = new double[maxCount][]; for (int i = 0; i < maxCount; i++) { input[i] = CalculateProbabilities(DataHandler.Reviews[i].reviewText); } double[] output = DataHandler.Reviews.Take(maxCount).Select(r => r.overall).ToArray(); LogisticRegressionAnalysis regression = new LogisticRegressionAnalysis(); LogisticRegression lr = regression.Learn(input, output); }
private static LogisticRegression TrainAccordModel(IDataView trainingData) { AccordIO data = IDataViewToAccord(trainingData); var trainer = new IterativeReweightedLeastSquares <LogisticRegression>() { MaxIterations = 1000, Regularization = 1e-6 }; // Use the teacher algorithm to learn the regression: LogisticRegression lr = trainer.Learn(data.inputs, data.labels); return(lr); // Classify the samples using the model //bool[] answers = lr.Decide(inputs); }
/// <summary> /// Fits a logistic regression model to data until convergence. /// </summary> /// private bool fit(LogisticRegression regression, double[][] input, double[] output) { IterativeReweightedLeastSquares irls = new IterativeReweightedLeastSquares(regression); double delta; int iteration = 0; do // learning iterations until convergence { delta = irls.Run(input, output); iteration++; } while (delta > limit && iteration < maxIterations); // Check if the full model has converged return(iteration <= maxIterations); }
private static double[] finiteDifferences(double[][] input, double[] output, bool stochastic) { var regression = new LogisticRegression(inputs: 2); var diff = new FiniteDifferences(3); diff.Function = (x) => { for (int i = 0; i < x.Length; i++) { regression.Coefficients[i] = x[i]; } return(regression.GetLogLikelihood(input, output)); }; return(diff.Compute(regression.Coefficients)); }
private static void Main() { var features = new List <Feature <Comment> >(); var badWordFeature = new BadWordFeature(); features.Add(new Feature <Comment>("Bad word", comment => badWordFeature.NumberOfBadWords(comment), 1d)); features.Add(new Feature <Comment>("Reputation", comment => Math.Log(1d + comment.UserReputation), -1d)); features.AddRange(BadWordFeature.ContainsIndividualWords()); IList <Comment> comments = new CommentRepository().GetComments(); IList <Sample <Comment> > samples = comments.Select( comment => ConvertToSample(comment, features)). ToList(); var logisticRegression = new LogisticRegression <Comment>(UseSecondOrder); var stopwatch = new Stopwatch(); stopwatch.Start(); IList <Dimension <Comment> > dimensions = logisticRegression.Iterate(samples, features, 0.01d); stopwatch.Stop(); Console.WriteLine("Duration: {0:N4} seconds", stopwatch.Elapsed.TotalSeconds); // Testing some different reputations: for (int userReputation = 0; userReputation < 10; userReputation++) { var test = new Sample <Comment>( new Comment { Text = "Hej med dig. Sex?", UserReputation = userReputation }, "X", false, features, UseSecondOrder); Vector <double> denseVector = new DenseVector(dimensions.Select(x => x.Theta).ToArray()); double probability = test.GetProbability(denseVector); Console.WriteLine("{0}, {1:P2}", userReputation, probability); } Console.ReadKey(); }
public LogisticRegression GetLogisticRegressionParams(int index, double percentage) { LogisticInfo LI = new LogisticInfo(); LI.LogisticParams = new double[2]; int length = MD.Length; int samplesize = (int)(length * percentage); double [][] inputArr = new double[samplesize * 2][]; for (int i = 0; i < samplesize * 2; i++) { inputArr[i] = new double[2]; } double[] outputArr = new double[samplesize * 2]; for (int i = 0; i < samplesize; i++) { inputArr[i][0] = MD[i].GetParameters()[index]; inputArr[i][1] = 0; outputArr[i] = 0; } int j = length - samplesize; for (int i = samplesize; i < samplesize * 2; i++) { inputArr[i][0] = MD[j].GetParameters()[index]; inputArr[i][1] = 0; outputArr[i] = 1; j++; } LogisticRegression LR = new LogisticRegression(); LR.NumberOfInputs = 1; var learner = new IterativeReweightedLeastSquares <LogisticRegression>() { Tolerance = 1e-4, // Let's set some convergence parameters Iterations = 100, // maximum number of iterations to perform Regularization = 0 }; LogisticRegression regression = learner.Learn(inputArr, outputArr); LI.LogisticParams[0] = -(regression.Intercept + 1); LI.LogisticParams[1] = regression.GetOddsRatio(1) - 1; return(regression); }
static IList <double> MergeScores(IList <IList <double> > scores, Dictionary <int, IList <int> > candidates, Dictionary <int, IList <int> > hits) { double[] weights; if (log_reg) { var lr = new LogisticRegression(); lr.LearnRate = learn_rate; lr.NumIter = num_it; lr.Regularization = regularization; lr.PredictorVariables = new Matrix <double>(scores); var targets = new byte[scores[0].Count]; int pos = 0; foreach (int u in candidates.Keys) { foreach (int i in candidates[u]) { targets[pos++] = hits[u].Contains(i) ? (byte)1 : (byte)0; } } lr.TargetVariables = targets; lr.Train(); //lr.InitModel(); weights = lr.parameters.ToArray(); /* * for (int i = 0; i < weights.Length; i++) * Console.Error.WriteLine(weights[i]); */ } else { weights = new double[scores.Count]; for (int i = 0; i < weights.Length; i++) { weights[i] = 1; } } return(MergeScores(scores, weights)); }
/// <summary> /// Check that the model is able to fit the classification data /// </summary> private void check_predictions(LogisticRegression<int> clf, Matrix<double> X, int[] y) { int nSamples = y.Length; int[] classes = y.Distinct().OrderBy(v => v).ToArray(); int nClasses = classes.Length; clf.Fit(X, y); var predicted = clf.Predict(X); Assert.IsTrue(classes.SequenceEqual(clf.Classes)); Assert.AreEqual(nSamples, predicted.Length); Assert.IsTrue(y.SequenceEqual(predicted)); Matrix<double> probabilities = clf.PredictProba(X); Assert.AreEqual(Tuple.Create(nSamples, nClasses), probabilities.Shape()); Assert.IsTrue(probabilities.SumOfEveryRow().AlmostEquals(DenseVector.Create(probabilities.RowCount, i => 1.0))); Assert.IsTrue(y.SequenceEqual(probabilities.ArgmaxColumns())); }
public static void training() { string filepath = Path.Combine(HostingEnvironment.ApplicationPhysicalPath + @"Content\files\indian_liver_patient.xls"); DataTable table = new ExcelReader(filepath).GetWorksheet("indian_liver_patient"); double[][] inputs = table.ToJagged <double>("Age", "Gender", "Total_Bilirubin", "Direct_Bilirubin", "Alkaline_Phosphotase" , "Alamine_Aminotransferase", "Aspartate_Aminotransferase" , "Total_Protiens", "Albumin", "Albumin_and_Globulin_Ratio"); int[] outputs = table.ToArray <int>("Dataset"); for (int i = 0; i < outputs.Length; i++) { outputs[i] = outputs[i] - 1; } DecisionVariable[] var = { new DecisionVariable("A", DecisionVariableKind.Continuous), new DecisionVariable("G", DecisionVariableKind.Continuous), new DecisionVariable("TB", DecisionVariableKind.Continuous), new DecisionVariable("DB", DecisionVariableKind.Continuous), new DecisionVariable("AP", DecisionVariableKind.Continuous), new DecisionVariable("AA", DecisionVariableKind.Continuous), new DecisionVariable("AS", DecisionVariableKind.Continuous), new DecisionVariable("TP", DecisionVariableKind.Continuous), new DecisionVariable("ALB", DecisionVariableKind.Continuous), new DecisionVariable("AGR", DecisionVariableKind.Continuous) }; tree = new DecisionTree(var, 2); C45Learning teacher = new C45Learning(tree); teacher.Learn(inputs, outputs); var learner = new IterativeReweightedLeastSquares <LogisticRegression>() { Tolerance = 1e-6, // Let's set some convergence parameters MaxIterations = 1000, // maximum number of iterations to perform Regularization = 0 }; regression = learner.Learn(inputs, outputs); }
public void GradAscentTest() { string file = @"C:\db\testset.txt"; var lines = File.ReadAllLines(file); double[,] dataMat = new double[lines.Length, 3]; double[,] labelMat = new double[lines.Length, 1]; for (int i = 0; i < lines.Length; i++) { var temp = lines[i].Split(new char[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); dataMat[i, 0] = 1.0; dataMat[i, 1] = double.Parse(temp[0]); dataMat[i, 2] = double.Parse(temp[1]); labelMat[i, 0] = double.Parse(temp[2]); } var result = LogisticRegression.GradAscent(dataMat, labelMat); Console.WriteLine(result); }
public void CalculateLogistic(double[][] x_train, int[] y_train) { try { var teacher = new ProbabilisticCoordinateDescent() { Tolerance = 1e-10, Complexity = 1e+10, }; var svm = teacher.Learn(x_train, y_train); this.regression = (LogisticRegression)svm; } catch { MessageBox.Show("학습실패LR"); } }
private async Task OnClassifyLogisticRegression() { try { var logisticRegression = new LogisticRegression(FirstClass, SecondClass); logisticRegression.Train(0.01); var stopwatch = new Stopwatch(); await Task.Run(() => { stopwatch.Start(); for (var i = 0; i < 5000; i++) { var randomPointX = random.NextDouble() * (PlotModel.Axes[0].Maximum - PlotModel.Axes[0].Minimum) + PlotModel.Axes[0].Minimum; var randomPointY = random.NextDouble() * (PlotModel.Axes[1].Maximum - PlotModel.Axes[1].Minimum) + PlotModel.Axes[1].Minimum; var logisticRegressionProbabilityResult = logisticRegression.Classify(randomPointX, randomPointY); if (logisticRegressionProbabilityResult > 0.5) { FirstClassScatterSeries.Points.Add(new ScatterPoint(randomPointX, randomPointY, 4, double.NaN, FirstClass.Id)); } else { SecondClassScatterSeries.Points.Add(new ScatterPoint(randomPointX, randomPointY, 4, double.NaN, FirstClass.Id)); } if (stopwatch.Elapsed > TimeSpan.FromMilliseconds(100)) { PlotModel.InvalidatePlot(true); stopwatch.Restart(); } } }); PlotModel.InvalidatePlot(true); } catch (Exception e) { MessageBox.Show(e.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error); } }
/// <summary> /// Check that the model is able to fit the classification data /// </summary> private void check_predictions(LogisticRegression <int> clf, Matrix <double> X, int[] y) { int nSamples = y.Length; int[] classes = y.Distinct().OrderBy(v => v).ToArray(); int nClasses = classes.Length; clf.Fit(X, y); var predicted = clf.Predict(X); Assert.IsTrue(classes.SequenceEqual(clf.Classes)); Assert.AreEqual(nSamples, predicted.Length); Assert.IsTrue(y.SequenceEqual(predicted)); Matrix <double> probabilities = clf.PredictProba(X); Assert.AreEqual(Tuple.Create(nSamples, nClasses), probabilities.Shape()); Assert.IsTrue(probabilities.SumOfEveryRow().AlmostEquals(DenseVector.Create(probabilities.RowCount, i => 1.0))); Assert.IsTrue(y.SequenceEqual(probabilities.ArgmaxColumns())); }
private void logReg() { int numObs = terrainVisResults[0].visScore.Count * terrainVisResults[0].visScore[0].Count; foreach (RefPlaneVis rpv in terrainVisResults) { double[][] input = new double[numObs][]; double[] output = new double[numObs]; int oNum = 0; for (int i = 0; i < rpv.visScore.Count; i++) { for (int s = 0; s < rpv.visScore[i].Count; s++) { double score = rpv.visScore[i][s]; if (Double.IsNaN(score)) { score = 0; } input[oNum] = new double[] { score, rpv.groupNum, score + rpv.groupNum };//score * rpv.groupNum, if (rpv.observationPts[i][s]) { output[oNum] = 1; } else { output[oNum] = 0; } oNum++; } } printInputOutput(input, output); var lra = new LogisticRegressionAnalysis(); // Now, we can use the learner to finally estimate our model: LogisticRegression regression = lra.Learn(input, output); var cf = lra.Coefficients; } }
public void RegularizationTest2() { CsvReader reader = CsvReader.FromText(Properties.Resources.regression, true); double[][] data = reader.ToTable().ToArray(System.Globalization.CultureInfo.InvariantCulture); double[][] inputs = data.GetColumns(new[] { 0, 1 }); double[] output = data.GetColumn(2); var regression = new LogisticRegression(2); var irls = new IterativeReweightedLeastSquares(regression); double error = irls.Run(inputs, output); double newError = 0; for (int i = 0; i < 50; i++) { newError = irls.Run(inputs, output); } double actual = irls.ComputeError(inputs, output); Assert.AreEqual(30.507262964894068, actual, 1e-8); Assert.AreEqual(3, regression.Coefficients.Length); Assert.AreEqual(-0.38409721299838279, regression.Coefficients[0], 1e-7); Assert.AreEqual(0.1065137931017601, regression.Coefficients[1], 1e-7); Assert.AreEqual(22.010378526331344, regression.Coefficients[2], 1e-7); for (int i = 0; i < 50; i++) { newError = irls.Run(inputs, output); } Assert.AreEqual(-0.38409721299838279, regression.Coefficients[0], 1e-7); Assert.AreEqual(0.1065137931017601, regression.Coefficients[1], 1e-8); Assert.AreEqual(22.010378588337979, regression.Coefficients[2], 1e-8); }
public void TestSparsify() { string[] target = iris.Target.Select(t => iris.TargetNames[t]).ToArray(); var clf = new LogisticRegression <string>(random: new Random(0)); clf.Fit(iris.Data, target); Matrix <double> predDD = clf.DecisionFunction(iris.Data); clf.Sparsify(); Assert.IsInstanceOfType(clf.Coef, typeof(SparseMatrix)); Matrix <double> predSD = clf.DecisionFunction(iris.Data); Matrix spData = SparseMatrix.OfMatrix(iris.Data); Matrix <double> predSS = clf.DecisionFunction(spData); clf.Densify(); Matrix <double> predDS = clf.DecisionFunction(spData); Assert.IsTrue(predDD.AlmostEquals(predSD)); Assert.IsTrue(predDD.AlmostEquals(predSS)); Assert.IsTrue(predDD.AlmostEquals(predDS)); }
private static void ShowAccordIntermediateData(IDataView input, LogisticRegression accordModel) { var convertedInput = IDataViewToAccord(input).inputs; bool[] lrOutput = accordModel.Decide(convertedInput); var lrScore = accordModel.Scores(convertedInput); var lrProbability = accordModel.Probabilities(convertedInput); var inputEnumerable = mlContext.Data.CreateEnumerable <IDataViewWrapper>(input, true); sw.WriteLine("Label\tScore\tProbability\tPrediction"); int count = 0; foreach (IDataViewWrapper pp in inputEnumerable) { int label = pp.Label ? 1 : 0; int prediction = lrOutput[count] ? 1 : 0; double score = lrScore[count][1]; double probability = lrProbability[count][1]; sw.WriteLine("{0}\t{1}\t{2}\t{3}", label, score, probability, prediction); count++; } sw.Flush(); }
public void TestPredictIris() { int nSamples = iris.Data.RowCount; string[] target = iris.Target.Select(v => iris.TargetNames[v]).ToArray(); var clf = new LogisticRegression <string>(c: iris.Data.RowCount); clf.Fit(iris.Data, target); Assert.IsTrue(target.Distinct().OrderBy(t => t).SequenceEqual(clf.Classes)); var pred = clf.Predict(iris.Data); var matchingN = pred.Zip(target, Tuple.Create).Where(t => t.Item1 == t.Item2).Count(); Assert.IsTrue(1.0 * matchingN / pred.Length > 0.95); var probabilities = clf.PredictProba(iris.Data); Assert.IsTrue(probabilities.SumOfEveryRow().AlmostEquals(DenseVector.Create(nSamples, i => 1.0))); pred = probabilities.RowEnumerator().Select(r => iris.TargetNames[r.Item2.MaximumIndex()]).ToArray(); matchingN = pred.Zip(target, Tuple.Create).Where(t => t.Item1 == t.Item2).Count(); Assert.IsTrue(1.0 * matchingN / pred.Length > 0.95); }
//--------------------------------------------- #region Constructors /// <summary> /// Constructs a Logistic Regression Analysis. /// </summary> /// /// <param name="inputs">The input data for the analysis.</param> /// <param name="outputs">The output data for the analysis.</param> /// public LogisticRegressionAnalysis(double[][] inputs, double[] outputs) { // Initial argument checking if (inputs == null) { throw new ArgumentNullException("inputs"); } if (outputs == null) { throw new ArgumentNullException("outputs"); } if (inputs.Length != outputs.Length) { throw new ArgumentException("The number of rows in the input array must match the number of given outputs."); } initialize(inputs, outputs); // Start regression using the Null Model this.regression = new LogisticRegression(inputCount); }
private static void logisticRegression(double[][] inputs, int[] outputs) { // Create iterative re-weighted least squares for logistic regressions var teacher = new IterativeReweightedLeastSquares <LogisticRegression>() { MaxIterations = 100, Regularization = 1e-6 }; // Use the teacher algorithm to learn the regression: LogisticRegression lr = teacher.Learn(inputs, outputs); // Classify the samples using the model bool[] answers = lr.Decide(inputs); // Convert to Int32 so we can plot: int[] zeroOneAnswers = answers.ToZeroOne(); // Plot the results ScatterplotBox.Show("Expected results", inputs, outputs); ScatterplotBox.Show("Logistic Regression results", inputs, zeroOneAnswers) .Hold(); }
private static void logistic(double[][] inputs, int[] outputs) { // In our problem, we have 2 inputs (x, y pairs) var logistic = new LogisticRegression(inputs: 2); // Create a iterative re-weighted least squares algorithm var teacher = new IterativeReweightedLeastSquares(logistic); // Logistic Regression expects the output labels // to range from 0 to k, so we convert -1 to be 0: // outputs = outputs.Apply(x => x < 0 ? 0 : x); // Iterate until stop criteria is met double error = double.PositiveInfinity; double previous; do { previous = error; // Compute one learning iteration error = teacher.Run(inputs, outputs); } while (Math.Abs(previous - error) < 1e-10 * previous); // Classify the samples using the model int[] answers = inputs.Apply(logistic.Compute).Apply(Math.Round).ToInt32(); // Plot the results ScatterplotBox.Show("Expected results", inputs, outputs); ScatterplotBox.Show("Logistic Regression results", inputs, answers) .Hold(); }
public void When_Compute_Logistic_Regression() { double[][] inputs = { new double[] { 55, 0 }, new double[] { 28, 0 }, new double[] { 65, 1 }, new double[] { 46, 0 }, new double[] { 86, 1 }, new double[] { 56, 1 }, new double[] { 85, 0 }, new double[] { 33, 0 }, new double[] { 21, 1 }, new double[] { 42, 1 } }; double[] outputs = { 0, 0, 0, 1, 1, 1, 0, 0, 0, 1 }; var logisticRegression = new LogisticRegression(); logisticRegression.Regress(inputs, outputs); var result = logisticRegression.Compute(new double[] { 87, 1 }); var oddsRatio = logisticRegression.GetOddsRatio(); var standardErrors = logisticRegression.GetStandardErrors(); Assert.Equal(0.75143272858390264, result); Assert.Equal(0.085627701183141239, oddsRatio[0]); Assert.Equal(1.0208597029292656, oddsRatio[1]); Assert.Equal(5.8584748981778869, oddsRatio[2]); Assert.Equal(2.1590686019476122, standardErrors[0]); Assert.Equal(0.0337904223210436, standardErrors[1]); Assert.Equal(1.4729903935788495, standardErrors[2]); }
#pragma warning restore 612, 618 private void computeInner(double[][] inputData, double[] outputData, double[] weights) { for (int i = 0; i < NumberOfInputs; i++) { // Create a diminished inner model without the current variable double[][] data = inputData.RemoveColumn(i); // Perform likelihood-ratio tests against diminished nested models var innerModel = new LogisticRegression(NumberOfInputs); var learning = new IterativeReweightedLeastSquares(innerModel) { Iterations = iterations, Tolerance = tolerance, Regularization = regularization }; learning.Learn(data, outputData, weights); double ratio = 2.0 * (logLikelihood - innerModel.GetLogLikelihood(data, outputData)); ratioTests[i + 1] = new ChiSquareTest(ratio, 1); } innerComputed = true; }
private void computeInner(double limit, int maxIterations) { // Perform likelihood-ratio tests against diminished nested models LogisticRegression innerModel = new LogisticRegression(inputCount - 1); IterativeReweightedLeastSquares learning = new IterativeReweightedLeastSquares(innerModel); for (int i = 0; i < inputCount; i++) { // Create a diminished inner model without the current variable double[][] data = inputData.RemoveColumn(i); int iteration = 0; double delta = 0; do // learning iterations until convergence { delta = learning.Run(data, outputData); iteration++; } while (delta > limit && iteration < maxIterations); double ratio = 2.0 * (logLikelihood - innerModel.GetLogLikelihood(data, outputData)); ratioTests[i + 1] = new ChiSquareTest(ratio, 1); } }
/// <summary> /// Constructs a new Iterative Reweighted Least Squares. /// </summary> /// /// <param name="regression">The regression to estimate.</param> /// public IterativeReweightedLeastSquares(LogisticRegression regression) { // TODO: Remove this method Initialize(regression); }
public void TestSparsify() { string[] target = iris.Target.Select(t => iris.TargetNames[t]).ToArray(); var clf = new LogisticRegression<string>(random: new Random(0)); clf.Fit(iris.Data, target); Matrix<double> predDD = clf.DecisionFunction(iris.Data); clf.Sparsify(); Assert.IsInstanceOfType(clf.Coef, typeof(SparseMatrix)); Matrix<double> predSD = clf.DecisionFunction(iris.Data); Matrix spData = SparseMatrix.OfMatrix(iris.Data); Matrix<double> predSS = clf.DecisionFunction(spData); clf.Densify(); Matrix<double> predDS = clf.DecisionFunction(spData); Assert.IsTrue(predDD.AlmostEquals(predSD)); Assert.IsTrue(predDD.AlmostEquals(predSS)); Assert.IsTrue(predDD.AlmostEquals(predDS)); }
public void TestWriteParameters() { var clf = new LogisticRegression<int>(random: new Random(0)); clf.Fit(X, Y1); clf.Coef.MapInplace(v => 0); clf.Intercept.MapInplace(v => 0); Assert.IsTrue(clf.DecisionFunction(X).Column(0).AlmostEquals(new DenseVector(new double[]{0, 0, 0}))); }
public void TestLiblinearRandomState() { var classification = SampleGenerator.MakeClassification(nSamples: 20); var lr1 = new LogisticRegression<int>(random: new Random(0)); lr1.Fit(classification.X, classification.Y); var lr2 = new LogisticRegression<int>(random: new Random(0)); lr2.Fit(classification.X, classification.Y); Assert.IsTrue(lr1.Coef.AlmostEquals(lr2.Coef)); }
public void TestPredictIris() { int nSamples = iris.Data.RowCount; string[] target = iris.Target.Select(v => iris.TargetNames[v]).ToArray(); var clf = new LogisticRegression<string>(c: iris.Data.RowCount); clf.Fit(iris.Data, target); Assert.IsTrue(target.Distinct().OrderBy(t => t).SequenceEqual(clf.Classes)); var pred = clf.Predict(iris.Data); var matchingN = pred.Zip(target, Tuple.Create).Where(t => t.Item1 == t.Item2).Count(); Assert.IsTrue(1.0*matchingN/pred.Length > 0.95); var probabilities = clf.PredictProba(iris.Data); Assert.IsTrue(probabilities.SumOfEveryRow().AlmostEquals(DenseVector.Create(nSamples, i => 1.0))); pred = probabilities.RowEnumerator().Select(r => iris.TargetNames[r.Item2.MaximumIndex()]).ToArray(); matchingN = pred.Zip(target, Tuple.Create).Where(t => t.Item1 == t.Item2).Count(); Assert.IsTrue(1.0 * matchingN / pred.Length > 0.95); }
/// <summary> /// Constructs a new Gradient Descent algorithm. /// </summary> /// /// <param name="regression">The regression to estimate.</param> /// public LogisticGradientDescent(LogisticRegression regression) { this.regression = regression; this.parameterCount = regression.Coefficients.Length; this.gradient = new double[parameterCount]; this.deltas = new double[parameterCount]; }
/// <summary> /// Constructs a new Iterative Reweighted Least Squares. /// </summary> /// /// <param name="regression">The regression to estimate.</param> /// public IterativeReweightedLeastSquares(LogisticRegression regression) { var glm = GeneralizedLinearRegression.FromLogisticRegression(regression, makeCopy: false); constructor(glm); }