/// <summary> /// Performs gradient descent to optomise theta parameters. /// </summary> /// <param name="theta">Initial Theta (Zeros)</param> /// <param name="x">Training set</param> /// <param name="y">Training labels</param> /// <param name="maxIterations">Maximum number of iterations to run gradient descent</param> /// <param name="learningRateAlpha">The learning rate (Alpha)</param> /// <param name="costFunction">Cost function to use for gradient descent</param> /// <param name="lambda">The regularization constant to apply</param> /// <param name="regularizer">The regularization function to apply</param> /// <returns></returns> public static Tuple<double, Vector> Run( Vector theta, Matrix x, Vector y, int maxIterations, double learningRateAlpha, ICostFunction costFunction, double lambda, IRegularizer regularizer) { var bestTheta = theta.Copy(); var bestCost = double.PositiveInfinity; double currentCost = 0; var currentGradient = theta.Copy(); for (var i = 0; i <= maxIterations; i++) { currentCost = costFunction.ComputeCost(bestTheta, x, y, lambda, regularizer); currentGradient = costFunction.ComputeGradient(bestTheta, x, y, lambda, regularizer); if (currentCost < bestCost) { bestTheta = bestTheta - learningRateAlpha * currentGradient; bestCost = currentCost; } else { learningRateAlpha = learningRateAlpha * 0.99; } } return new Tuple<double, Vector>(bestCost, bestTheta); }
public void Logistic_Regression_Test_CostFunction_2_WithoutRegularization() { Matrix X = new[,] { { 8, 1, 6 }, { 3, 5 ,7 }, { 4, 9, 2 }}; Vector y = new Vector(new double[] { 1, 1, 0 }); Vector theta = new Vector(new double[] { 0, 1, 0 }); ICostFunction logisticCostFunction = new LogisticCostFunction() { X = X, Y = y, Lambda = 0, }; double cost = logisticCostFunction.ComputeCost(theta.Copy()); theta = logisticCostFunction.ComputeGradient(theta.Copy()); Assert.Equal(3.1067d, System.Math.Round(cost, 4)); Assert.Equal(0.6093d, System.Math.Round(theta[0], 4)); Assert.Equal(2.8988d, System.Math.Round(theta[1], 4)); Assert.Equal(0.1131d, System.Math.Round(theta[2], 4)); }
public void Logistic_Regression_Test_CostFunction_1() { Matrix X = new[,] {{ 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 }, { 8, 1, 6 }, { 3, 5 ,7 }, { 4, 9, 2 }}; Vector y = new Vector(new double[] { 1, 0, 1, 0, 1, 0 }); Vector theta = new Vector(new double[] { 0, 1, 0 }); ICostFunction logisticCostFunction = new LogisticCostFunction() { X = X, Y = y, Lambda = 3, Regularizer = new L2Regularizer() }; double cost = logisticCostFunction.ComputeCost(theta.Copy()); theta = logisticCostFunction.ComputeGradient(theta.Copy()); Assert.Equal(2.2933d, System.Math.Round(cost, 4)); Assert.Equal(1.6702d, System.Math.Round(theta[0], 4)); Assert.Equal(2.1483d, System.Math.Round(theta[1], 4)); Assert.Equal(1.0887d, System.Math.Round(theta[2], 4)); }
public static Vector Calc(Vector v, Func<int, double, double> f) { var result = v.Copy(); for (int i = 0; i < v.Length; i++) result[i] = f(i, result[i]); return result; }
public static Vector Calc(Vector v, Func <int, double, double> f) { var result = v.Copy(); for (int i = 0; i < v.Length; i++) { result[i] = f(i, result[i]); } return(result); }
/// <summary>A Vector extension method that eaches.</summary> /// <param name="v">The v to act on.</param> /// <param name="transform">The transform.</param> /// <param name="asCopy">(Optional) true to as copy.</param> /// <returns>A Vector.</returns> public static Vector Each(this Vector v, Func <double, double> transform, bool asCopy = false) { Vector vector = (asCopy ? v.Copy() : v); for (int i = 0; i < vector.Length; i++) { vector[i] = transform(vector[i]); } return(vector); }
/// <summary>A Vector extension method that eaches.</summary> /// <param name="v">The v to act on.</param> /// <param name="transform">The transform including value and coordinate.</param> /// <param name="asCopy">(Optional) true to as copy.</param> /// <returns>A Vector.</returns> public static Vector Each(this Vector v, Func <double, int, double> transform, bool asCopy = false) { Vector vector = v; if (asCopy) { vector = v.Copy(); } for (int i = 0; i < vector.Length; i++) { vector[i] = transform(vector[i], i); } return(v); }
/// <summary> /// Adds a specified number of polynomial features to the training / test Vector. /// </summary> /// <param name="x">Training / Testing record</param> /// <param name="polynomialFeatures">Number of polynomial features to add</param> /// <returns></returns> public static Vector IncreaseDimensions(Vector x, int polynomialFeatures) { Vector xtemp = x.Copy(); int maxCols = xtemp.Length; for (int j = 0; j < maxCols - 1; j++) { for (int k = 0; k <= polynomialFeatures; k++) { for (int m = 0; m <= k; m++) { double v = (System.Math.Pow(xtemp[j], k - m) * System.Math.Pow(xtemp[j + 1], m)); xtemp = xtemp.Insert(xtemp.Length - 1, v); } } } return xtemp; }
/// <summary> /// Adds a specified number of polynomial features to the training / test Vector. /// </summary> /// <param name="x">Training / Testing record</param> /// <param name="polynomialFeatures">Number of polynomial features to add</param> /// <returns></returns> public static Vector IncreaseDimensions(Vector x, int polynomialFeatures) { var xtemp = x.Copy(); var maxCols = xtemp.Length; for (var j = 0; j < maxCols - 1; j++) { for (var k = 0; k <= polynomialFeatures; k++) { for (var m = 0; m <= k; m++) { var v = Math.Pow(xtemp[j], (double)(k - m)) * Math.Pow(xtemp[j + 1], (double)m); xtemp = xtemp.Insert(xtemp.Length - 1, v); } } } return xtemp; }
public void Logistic_Regression_Test_CostFunction_1() { Matrix X = new[,] {{ 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 }, { 8, 1, 6 }, { 3, 5 ,7 }, { 4, 9, 2 }}; Vector y = new Vector(new double[] { 1, 0, 1, 0, 1, 0 }); Vector theta = new Vector(new double[] { 0, 1, 0 }); numl.Math.Functions.Cost.ICostFunction logisticCostFunction = new numl.Math.Functions.Cost.LogisticCostFunction(); numl.Math.Functions.Regularization.IRegularizer regularizer = new numl.Math.Functions.Regularization.Regularization(); double cost = logisticCostFunction.ComputeCost(theta.Copy(), X, y, 3, regularizer); theta = logisticCostFunction.ComputeGradient(theta.Copy(), X, y, 3, regularizer); Assert.AreEqual(2.2933d, System.Math.Round(cost, 4)); Assert.AreEqual(1.6702d, System.Math.Round(theta[0], 4)); Assert.AreEqual(2.1483d, System.Math.Round(theta[1], 4)); Assert.AreEqual(1.0887d, System.Math.Round(theta[2], 4)); }