public void TestTrain() { double[][] x = { new [] {1.0}, new [] {3.0}, new [] {2.0}, new [] {200.0}, new [] {230.0}}; double[][] y = { new [] {1.0}, new [] {1.0}, new [] {1.0}, new [] {0.0}, new [] {0.0} }; var trainingData = BasicData.ConvertArrays(x, y); var regression = new MultipleLinearRegression(1) {LinkFunction = new LogitLinkFunction()}; var train = new TrainReweightLeastSquares(regression, trainingData); train.Iteration(); double[] input = { 0 }; double[] output = regression.ComputeRegression(input); Assert.AreEqual(0.883301730269988, output[0], AIFH.DefaultPrecision); }
public void TestTrain() { double[][] x = { new [] {5.0, 10.0, 2.0}, new []{10.0, 20.0, 4.0}, new []{15.0, 30.0, 6.0}, new []{20.0, 40.0, 8.0}, new []{25.0, 50.0, 10.0}}; double[][] y = { new []{70.0}, new []{132.0}, new []{194.0}, new []{256.0}, new []{318.0} }; var trainingData = BasicData.ConvertArrays(x, y); var regression = new MultipleLinearRegression(3); var train = new TrainLeastSquares(regression, trainingData); train.Iteration(); Assert.AreEqual(8, regression.LongTermMemory[0], 0.0001); Assert.AreEqual(-54.8, regression.LongTermMemory[1], 0.0001); Assert.AreEqual(8, regression.LongTermMemory[2], 0.0001); Assert.AreEqual(1, train.R2, 0.0001); Assert.AreEqual(0, train.Error, AIFH.DefaultPrecision); for (int i = 0; i < x.Length; i++) { double[] output = regression.ComputeRegression(x[i]); Assert.AreEqual(y[i][0], output[0], 0.0001); } }
/// <summary> /// Train. Single iteration. /// </summary> public void Iteration() { int rowCount = _trainingData.Count; int inputColCount = _trainingData[0].Input.Length; Matrix <double> xMatrix = new DenseMatrix(rowCount, inputColCount + 1); Matrix <double> yMatrix = new DenseMatrix(rowCount, 1); for (int row = 0; row < _trainingData.Count; row++) { BasicData dataRow = _trainingData[row]; int colSize = dataRow.Input.Count(); xMatrix[row, 0] = 1; for (int col = 0; col < colSize; col++) { xMatrix[row, col + 1] = dataRow.Input[col]; } yMatrix[row, 0] = dataRow.Ideal[0]; } // Calculate the least squares solution QR qr = xMatrix.QR(); Matrix <double> beta = qr.Solve(yMatrix); double sum = 0.0; for (int i = 0; i < inputColCount; i++) { sum += yMatrix[i, 0]; } double mean = sum / inputColCount; for (int i = 0; i < inputColCount; i++) { double dev = yMatrix[i, 0] - mean; _sst += dev * dev; } Matrix <double> residuals = xMatrix.Multiply(beta).Subtract(yMatrix); _sse = residuals.L2Norm() * residuals.L2Norm(); for (int i = 0; i < _algorithm.LongTermMemory.Length; i++) { _algorithm.LongTermMemory[i] = beta[i, 0]; } // calculate error _errorCalculation.Clear(); foreach (BasicData dataRow in _trainingData) { double[] output = _algorithm.ComputeRegression(dataRow.Input); _errorCalculation.UpdateError(output, dataRow.Ideal, 1.0); } _error = _errorCalculation.Calculate(); }
public void TestBasic() { var reg = new MultipleLinearRegression(1); Assert.AreEqual(2, reg.LongTermMemory.Length); var lnk = new LogLinkFunction(); reg.LinkFunction = lnk; Assert.IsTrue(reg.LinkFunction == lnk); reg.LongTermMemory[0] = 1; reg.LongTermMemory[1] = 2; double[] input = { 1.0 }; double[] output = reg.ComputeRegression(input); Assert.AreEqual(1, output.Length); Assert.AreEqual(1.0986122886681098, output[0], AIFH.DefaultPrecision); }
/// <summary> /// Perform one iteration of training. /// </summary> public void Iteration() { int rowCount = _trainingData.Count; int coeffCount = _algorithm.LongTermMemory.Length; var working = new double[rowCount, coeffCount]; var errors = new double[rowCount]; var weights = new double[rowCount]; for (int i = 0; i < rowCount; i++) { BasicData element = _trainingData[i]; working[i, 0] = 1; for (int j = 0; j < element.Input.Length; j++) { working[i, j + 1] = element.Input[j]; } } for (int i = 0; i < rowCount; i++) { BasicData element = _trainingData[i]; double y = _algorithm.ComputeRegression(element.Input)[0]; errors[i] = y - element.Ideal[0]; weights[i] = y * (1.0 - y); } for (int i = 0; i < coeffCount; i++) { _gradient[i, 0] = 0; for (int j = 0; j < coeffCount; j++) { _hessian[i, j] = 0; } } for (int j = 0; j < rowCount; j++) { for (int i = 0; i < coeffCount; i++) { _gradient[i, 0] += working[j, i] * errors[j]; } } for (int k = 0; k < weights.Length; k++) { for (int j = 0; j < coeffCount; j++) { for (int i = 0; i < coeffCount; i++) { _hessian[j, i] += working[k, i] * working[k, j] * weights[k]; } } } LU <double> lu = _hessian.LU(); Matrix <double> deltas = lu.Solve(_gradient); var prev = (double[])_algorithm.LongTermMemory.Clone(); for (int i = 0; i < _algorithm.LongTermMemory.Length; i++) { _algorithm.LongTermMemory[i] -= deltas[i, 0]; } double max = 0; for (int i = 0; i < deltas.ColumnCount; i++) { max = Math.Max(Math.Abs(deltas[i, 0]) / Math.Abs(prev[i]), max); } _error = max; }