public void TestEncode()
{
var eq = new Equilateral(3, -1, 1);
double[] d = eq.Encode(1);
Assert.AreEqual(0.8660254037844386, d[0], AIFH.DefaultPrecision);
Assert.AreEqual(-0.5, d[1], AIFH.DefaultPrecision);
}
/// <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]);
}
}
/**
* Use equilateral encoding to encode a column, use zero for the off value and one for the on value.
* <p/>
* http://www.heatonresearch.com/wiki/Equilateral
*
* @param column The column to use.
* @param offValue The off value to use.
* @param onValue The on value to use.
* @return The column to index mapping (the same result as calling enumerateClasses).
*/
public IDictionary <String, int> EncodeEquilateral(int column, double offValue, double onValue)
{
// remember the column name
String name = _headers[column];
// make space for it
IDictionary <String, int> classes = EnumerateClasses(column);
int classCount = classes.Count;
InsertColumns(column + 1, classCount - 1);
// perform the equilateral
var eq = new Equilateral(classCount, offValue, onValue);
foreach (var obj in _data)
{
int index = classes[obj[column].ToString()];
double[] encoded = eq.Encode(index);
for (int i = 0; i < classCount - 1; i++)
{
obj[column + i] = encoded[i];
}
}
// name the new columns
for (int i = 0; i < classes.Count; i++)
{
_headers[column + i] = name + "-" + i;
}
return(classes);
}
public void TestDecode()
{
var eq = new Equilateral(3, -1, 1);
double[] d0 = { 0.866, 0.5 };
double[] d1 = { -0.866, 0.5 };
double[] d2 = { 0, -1 };
Assert.AreEqual(2, eq.Decode(d0));
Assert.AreEqual(2, eq.Decode(d1));
Assert.AreEqual(0, eq.Decode(d2));
}
public void TestError()
{
var eq = new Equilateral(3, -1, 1);
eq.Encode(10);
}
/**
* Use equilateral encoding to encode a column, use zero for the off value and one for the on value.
* <p/>
* http://www.heatonresearch.com/wiki/Equilateral
*
* @param column The column to use.
* @param offValue The off value to use.
* @param onValue The on value to use.
* @return The column to index mapping (the same result as calling enumerateClasses).
*/
public IDictionary<String, int> EncodeEquilateral(int column, double offValue, double onValue)
{
// remember the column name
String name = _headers[column];
// make space for it
IDictionary<String, int> classes = EnumerateClasses(column);
int classCount = classes.Count;
InsertColumns(column + 1, classCount - 1);
// perform the equilateral
var eq = new Equilateral(classCount, offValue, onValue);
foreach (var obj in _data)
{
int index = classes[obj[column].ToString()];
double[] encoded = eq.Encode(index);
for (int i = 0; i < classCount - 1; i++)
{
obj[column + i] = encoded[i];
}
}
// name the new columns
for (int i = 0; i < classes.Count; i++)
{
_headers[column + i] = name + "-" + i;
}
return classes;
}