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