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);
}
