public void TestComputeInferOrLearnOnly()
{
var classifier = new SDRClassifier(new[] { 1 }, 1.0, 0.1);
int recordNum = 0;
// Learn only
var retVal = classifier.Compute <double>(recordNum, new Map <string, object> {
{ "bucketIdx", 4 }, { "actValue", 34.7 }
},
new[] { 1, 5, 9 }, true, false);
Assert.IsNull(retVal);
// Infer only
var retVal1 = classifier.Compute <double>(recordNum, new Map <string, object> {
{ "bucketIdx", 2 }, { "actValue", 14.2 }
},
new[] { 1, 5, 9 }, false, true);
recordNum += 1;
var retVal2 = classifier.Compute <double>(recordNum, new Map <string, object> {
{ "bucketIdx", 3 }, { "actValue", 20.5 }
},
new[] { 1, 5, 9 }, false, true);
recordNum += 1;
Assert.IsTrue((retVal1.GetStats(1)).SequenceEqual(retVal2.GetStats(1)));
}
private Classification <double> _compute(SDRClassifier classifier, int recordNum, int[] pattern, int bucket, double value)
{
var classification = new Map <string, object> {
{ "bucketIdx", bucket }, { "actValue", value }
};
return(classifier.Compute <double>(recordNum, classification, pattern, true, true));
}
public void TestComputeInferAndLearnFalse()
{
var classifier = new SDRClassifier(new[] { 1 }, 1.0, 0.1);
int recordNum = 0;
// Learn only
var retVal = classifier.Compute <double>(recordNum, new Map <string, object> {
{ "bucketIdx", 4 }, { "actValue", 34.7 }
},
new[] { 1, 5, 9 }, false, false);
}
public void TestComputeResultTypes()
{
var classifier = new SDRClassifier(new[] { 1 }, 0.1, 0.1);
var result = classifier.Compute <double>(0, new Map <string, object> {
{ "bucketIdx", 4 }, { "actValue", 34.7 }
}, new[] { 1, 5, 9 }, true, true);
Assert.IsTrue(Arrays.AreEqual(new[] { 1 }, result.StepSet()));
Assert.AreEqual(1, result.GetActualValueCount());
Assert.AreEqual(34.7, result.GetActualValue(0), 0.01);
}
public void TestSingleValue0Steps()
{
var classifier = new SDRClassifier(new[] { 0 }, 1.0);
// Enough times to perform Inference and learn associations
Classification <double> retVal = null;
for (int i = 0; i < 10; i++)
{
retVal = _compute(classifier, i, new[] { 1, 5 }, 0, 10);
}
Assert.AreEqual(retVal.GetActualValue(0), 10);
Assert.IsTrue(retVal.GetStat(0, 0) > 0.9, "value of 1 must be greater then 0.9 and is " + retVal.GetStat(0, 0));
}
public void TestComputeComplex()
{
var classifier = new SDRClassifier(new[] { 1 }, 1.0, 0.1);
int recordNum = 0;
classifier.Compute <double>(recordNum, new Map <string, object> {
{ "bucketIdx", 4 }, { "actValue", 34.7 }
},
new[] { 1, 5, 9 }, true, true);
recordNum += 1;
classifier.Compute <double>(recordNum, new Map <string, object> {
{ "bucketIdx", 5 }, { "actValue", 41.7 }
},
new[] { 0, 6, 9, 11 }, true, true);
recordNum += 1;
classifier.Compute <double>(recordNum, new Map <string, object> {
{ "bucketIdx", 5 }, { "actValue", 44.9 }
},
new[] { 6, 9 }, true, true);
recordNum += 1;
classifier.Compute <double>(recordNum, new Map <string, object> {
{ "bucketIdx", 4 }, { "actValue", 42.9 }
},
new[] { 1, 5, 9 }, true, true);
recordNum += 1;
var result = classifier.Compute <double>(recordNum, new Map <string, object> {
{ "bucketIdx", 4 }, { "actValue", 34.7 }
},
new[] { 1, 5, 9 }, true, true);
recordNum += 1;
Assert.IsTrue(Arrays.AreEqual(new[] { 1 }, result.StepSet()));
Assert.AreEqual(6, result.GetActualValueCount());
double[] actValues = result.GetActualValues();
Assert.AreEqual((double)actValues[4], 35.520000457763672, 0.0001);
Assert.AreEqual((double)actValues[5], 42.020000457763672, 0.0001);
double[] resultDoubles = (double[])result.GetStats(1);
Assert.AreEqual(6, resultDoubles.Length);
Assert.AreEqual(resultDoubles[0], 0.034234, 0.0001);
Assert.AreEqual(resultDoubles[1], 0.034234, 0.0001);
Assert.AreEqual(resultDoubles[2], 0.034234, 0.0001);
Assert.AreEqual(resultDoubles[3], 0.034234, 0.0001);
Assert.AreEqual(resultDoubles[4], 0.093058, 0.0001);
Assert.AreEqual(resultDoubles[5], 0.770004, 0.0001);
}
public void TestComputeWithMissingValue()
{
var classifier = new SDRClassifier(new[] { 1 }, 0.1, 0.1);
var result = classifier.Compute <double?>(0, new Map <string, object> {
{ "bucketIdx", null }, { "actValue", null }
},
new[] { 1, 5, 9 }, true, true);
Assert.IsTrue(Arrays.AreEqual(new[] { 1 }, result.StepSet()));
Assert.AreEqual(1, result.GetActualValueCount());
double?[] actValues = result.GetActualValues();
Assert.AreEqual(1, actValues.Length);
Assert.AreEqual(null, actValues[0]);
}
public void TestCompute1()
{
var classifier = new SDRClassifier(new[] { 1 }, 0.1, 0.1);
var retVal = classifier.Compute <double>(0, new Map <string, object> {
{ "bucketIdx", 4 }, { "actValue", 34.7 }
},
new[] { 1, 5, 9 }, true, true);
Assert.IsTrue(Arrays.AreEqual(new[] { 1 }, retVal.StepSet()));
Assert.AreEqual(1, retVal.GetActualValueCount());
double[] actValues = retVal.GetActualValues();
Assert.AreEqual(1, actValues.Length);
Assert.IsInstanceOfType(actValues[0], typeof(double));
Assert.AreEqual(actValues[0], 34.7, 0.0001);
}
public void TestComputeCategory()
{
var classifier = new SDRClassifier(new[] { 1 }, 0.1, 0.1);
classifier.Compute <string>(0, new Map <string, object> {
{ "bucketIdx", 4 }, { "actValue", "D" }
},
new[] { 1, 5, 9 }, true, true);
var result = classifier.Compute <string>(1, new Map <string, object> {
{ "bucketIdx", 4 }, { "actValue", "D" }
},
new[] { 1, 5, 9 }, true, true);
Assert.IsTrue(Arrays.AreEqual(new[] { 1 }, result.StepSet()));
Assert.AreEqual(5, result.GetActualValueCount());
double[] actValues = result.GetStats(1);
Assert.AreEqual("D", result.GetActualValue(4));
}
public void TestOverlapPattern()
{
var classifier = new SDRClassifier(new[] { 1 }, 10.0);
_compute(classifier, 0, new[] { 1, 5 }, 9, 9);
_compute(classifier, 1, new[] { 1, 5 }, 9, 9);
var retVal = _compute(classifier, 2, new[] { 3, 5 }, 2, 2);
// Since overlap - should be previous with high likelihood
double[] actValues = retVal.GetActualValues();
Assert.AreEqual(actValues[9], 9);
double[] resultDoubles = retVal.GetStats(1);
Assert.IsTrue(resultDoubles[9] > 0.9);
retVal = _compute(classifier, 3, new[] { 3, 5 }, 2, 2);
resultDoubles = retVal.GetStats(1);
// Second example: now new value should be more probable than old
Assert.IsTrue(resultDoubles[2] > resultDoubles[9]);
}
public void TestMultistepSingleValue()
{
var classifier = new SDRClassifier(new[] { 1, 2 });
Classification <double> retVal = null;
for (int i = 0; i < 10; i++)
{
retVal = _compute(classifier, i, new[] { 1, 5 }, 0, 10);
}
// Since overlap - should be previous with high likelihood
double[] actValues = retVal.GetActualValues();
Assert.AreEqual((double)actValues[0], 10);
double[] resultDoubles1 = (double[])retVal.GetStats(1);
double[] resultDoubles2 = (double[])retVal.GetStats(2);
Assert.AreEqual(resultDoubles1[0], 1);
Assert.AreEqual(resultDoubles2[0], 1);
}
public void TestMultistepPredictions()
{
var classifier = new SDRClassifier(new[] { 0, 1 }, 1.0, 0.1, 0);
int[] sdr1 = new[] { 1, 3, 5 };
int[] sdr2 = new[] { 2, 4, 6 };
int recordNum = 0;
for (int i = 0; i < 100; i++)
{
classifier.Compute <double>(recordNum: recordNum, patternNZ: sdr1,
classification: new Map <string, object> {
{ "bucketIdx", 0 }, { "actValue", 0 }
},
learn: true, infer: false);
recordNum++;
classifier.Compute <double>(recordNum: recordNum, patternNZ: sdr2,
classification: new Map <string, object> {
{ "bucketIdx", 1 }, { "actValue", 1.0 }
},
learn: true, infer: false);
recordNum++;
}
var result1 = classifier.Compute <double>(recordNum: recordNum, patternNZ: sdr1,
classification: null, learn: false, infer: true);
var result2 = classifier.Compute <double>(recordNum: recordNum, patternNZ: sdr2,
classification: null, learn: false, infer: true);
Assert.AreEqual(1.0, result1.GetStats(0)[0], 0.01);
Assert.AreEqual(0.0, result1.GetStats(0)[1], 0.01);
Assert.AreEqual(0.0, result2.GetStats(0)[0], 0.01);
Assert.AreEqual(1.0, result2.GetStats(0)[1], 0.01);
}
public void TestInitialization()
{
var c = new SDRClassifier(new[] { 1 }, 0.1, 0.1);
Assert.IsNotNull(c);
}
