/// <summary> /// Query a regression algorithm using equilateral encoding. /// </summary> /// <param name="alg">The algorithm being used.</param> /// <param name="theTrainingData">The training data.</param> /// <param name="items">The category items classified.</param> /// <param name="high">The high value.</param> /// <param name="low">The low value.</param> public static void QueryEquilateral( IRegressionAlgorithm alg, IList <BasicData> theTrainingData, IDictionary <string, int> items, double high, double low) { // first, we need to invert the items. Right now it maps from category to index. We need index to category. IDictionary <int, string> invMap = new Dictionary <int, string>(); foreach (var key in items.Keys) { var value = items[key]; invMap[value] = key; } // now we can query var eq = new Equilateral(items.Count, high, low); foreach (var data in theTrainingData) { var output = alg.ComputeRegression(data.Input); var idealIndex = eq.Decode(data.Ideal); var actualIndex = eq.Decode(output); Console.WriteLine(VectorUtil.DoubleArrayToString(data.Input) + " -> " + invMap[actualIndex] + ", Ideal: " + invMap[idealIndex]); } }
/// <summary> /// Query a regression algorithm using one-of-n encoding. /// </summary> /// <param name="alg">The algorithm being used.</param> /// <param name="theTrainingData">The training data.</param> /// <param name="items">The category items classified.</param> public static void QueryOneOfN( IRegressionAlgorithm alg, IList <BasicData> theTrainingData, IDictionary <String, int> items) { // first, we need to invert the items. Right now it maps from category to index. We need index to category. IDictionary <int, String> invMap = new Dictionary <int, string>(); foreach (string key in items.Keys) { int value = items[key]; invMap[value] = key; } // now we can query foreach (BasicData data in theTrainingData) { double[] output = alg.ComputeRegression(data.Input); int idealIndex = VectorUtil.MaxIndex(data.Ideal); int actualIndex = VectorUtil.MaxIndex(output); Console.WriteLine(VectorUtil.DoubleArrayToString(data.Input) + " -> " + invMap[actualIndex] + ", Ideal: " + invMap[idealIndex]); } }
/// <summary> /// Query a regression algorithm using equilateral encoding. /// </summary> /// <param name="alg">The algorithm being used.</param> /// <param name="theTrainingData">The training data.</param> /// <param name="items">The category items classified.</param> /// <param name="high">The high value.</param> /// <param name="low">The low value.</param> public static void QueryEquilateral( IRegressionAlgorithm alg, IList<BasicData> theTrainingData, IDictionary<String, int> items, double high, double low) { // first, we need to invert the items. Right now it maps from category to index. We need index to category. IDictionary<int, String> invMap = new Dictionary<int, string>(); foreach (string key in items.Keys) { int value = items[key]; invMap[value] = key; } // now we can query Equilateral eq = new Equilateral(items.Count, high, low); foreach (BasicData data in theTrainingData) { double[] output = alg.ComputeRegression(data.Input); int idealIndex = eq.Decode(data.Ideal); int actualIndex = eq.Decode(output); Console.WriteLine(VectorUtil.DoubleArrayToString(data.Input) + " -> " + invMap[actualIndex] + ", Ideal: " + invMap[idealIndex]); } }
/// <summary> /// Query a regression algorithm and see how close it matches the training data. /// </summary> /// <param name="alg">The algorithm to evaluate.</param> /// <param name="theTrainingData">The training data.</param> public static void Query(IRegressionAlgorithm alg, IList <BasicData> theTrainingData) { foreach (BasicData data in theTrainingData) { double[] output = alg.ComputeRegression(data.Input); Console.WriteLine(VectorUtil.DoubleArrayToString(data.Input) + " -> " + VectorUtil.DoubleArrayToString(output) + ", Ideal: " + VectorUtil.DoubleArrayToString(data.Ideal)); } }
/// <summary> /// Query a regression algorithm and see how close it matches the training data. /// </summary> /// <param name="alg">The algorithm to evaluate.</param> /// <param name="theTrainingData">The training data.</param> public static void Query(IRegressionAlgorithm alg, IList<BasicData> theTrainingData) { foreach (BasicData data in theTrainingData) { double[] output = alg.ComputeRegression(data.Input); Console.WriteLine(VectorUtil.DoubleArrayToString(data.Input) + " -> " + VectorUtil.DoubleArrayToString(output) + ", Ideal: " + VectorUtil.DoubleArrayToString(data.Ideal)); } }
/// <summary> /// Calculate error for regression. /// </summary> /// <param name="dataset">The dataset.</param> /// <param name="model">The model to evaluate.</param> /// <param name="calc">The error calculation.</param> /// <returns>The error.</returns> public static double CalculateRegressionError(IList <BasicData> dataset, IRegressionAlgorithm model, IErrorCalculation calc) { calc.Clear(); foreach (var item in dataset) { var output = model.ComputeRegression(item.Input); calc.UpdateError(output, item.Ideal, 1.0); } return(calc.Calculate()); }
/// <inheritdoc/> public double CalculateScore(IMLMethod algo) { IErrorCalculation ec = ErrorCalc.Create(); IRegressionAlgorithm ralgo = (IRegressionAlgorithm)algo; // evaulate ec.Clear(); foreach (BasicData pair in _trainingData) { double[] output = ralgo.ComputeRegression(pair.Input); ec.UpdateError(output, pair.Ideal, 1.0); } return(ec.Calculate()); }
/// <summary> /// Query a regression algorithm using one-of-n encoding. /// </summary> /// <param name="alg">The algorithm being used.</param> /// <param name="theTrainingData">The training data.</param> /// <param name="items">The category items classified.</param> public static void QueryOneOfN( IRegressionAlgorithm alg, IList<BasicData> theTrainingData, IDictionary<string, int> items) { // first, we need to invert the items. Right now it maps from category to index. We need index to category. IDictionary<int, string> invMap = new Dictionary<int, string>(); foreach (var key in items.Keys) { var value = items[key]; invMap[value] = key; } // now we can query foreach (var data in theTrainingData) { var output = alg.ComputeRegression(data.Input); var idealIndex = VectorUtil.MaxIndex(data.Ideal); var actualIndex = VectorUtil.MaxIndex(output); Console.WriteLine(VectorUtil.DoubleArrayToString(data.Input) + " -> " + invMap[actualIndex] + ", Ideal: " + invMap[idealIndex]); } }