public void ScalarEncoderUnitTestNonPeriodic(double input, int[] expectedResult)
{
CortexNetworkContext ctx = new CortexNetworkContext();
Dictionary <string, object> encoderSettings = new Dictionary <string, object>();
encoderSettings.Add("W", 25);
encoderSettings.Add("N", (int)0);
encoderSettings.Add("MinVal", (double)1);
encoderSettings.Add("MaxVal", (double)50);
encoderSettings.Add("Radius", (double)2.5);
encoderSettings.Add("Resolution", (double)0);
encoderSettings.Add("Periodic", (bool)false);
encoderSettings.Add("ClipInput", (bool)true);
encoderSettings.Add("Name", "TestScalarEncoder");
encoderSettings.Add("IsRealCortexModel", true);
ScalarEncoder encoder = new ScalarEncoder(encoderSettings);
var result = encoder.Encode(input);
Debug.WriteLine(input);
Debug.WriteLine(NeoCortexApi.Helpers.StringifyVector(result));
Debug.WriteLine(NeoCortexApi.Helpers.StringifyVector(expectedResult));
Assert.IsTrue(expectedResult.SequenceEqual(result));
}
public void SeasonEncoderTest(int input, int[] expectedResult)
{
CortexNetworkContext ctx = new CortexNetworkContext();
ScalarEncoder encoder = new ScalarEncoder(new Dictionary <string, object>()
{
{ "W", 3 },
{ "N", 12 },
{ "Radius", -1.0 },
{ "MinVal", 1.0 },
{ "MaxVal", 366.0 },
{ "Periodic", true },
{ "Name", "season" },
{ "ClipInput", true },
});
//for (int i = 1; i < 367; i++)
//{
var result = encoder.Encode(input);
Debug.WriteLine(input);
Debug.WriteLine(NeoCortexApi.Helpers.StringifyVector(result));
Debug.WriteLine(NeoCortexApi.Helpers.StringifyVector(expectedResult));
//}
Assert.IsTrue(expectedResult.SequenceEqual(result));
}
public void TimeTickEncodingTest(double input, int[] expectedResult)
{
CortexNetworkContext ctx = new CortexNetworkContext();
DateTime now = DateTime.Now;
ScalarEncoder encoder = new ScalarEncoder(new Dictionary <string, object>()
{
{ "W", 21 },
{ "N", 1024 },
{ "Radius", -1.0 },
{ "MinVal", 0.0 },
{ "MaxVal", (double)(now - now.AddYears(-1)).TotalDays },
{ "Periodic", true },
{ "Name", "season" },
{ "ClipInput", true },
});
for (long i = 0; i < (long)encoder.MaxVal; i += 1)
{
var to = (double)(now - now.AddYears(-1)).Ticks;
input = (double)i;
var result = encoder.Encode(input);
Debug.WriteLine(input);
Debug.WriteLine(NeoCortexApi.Helpers.StringifyVector(result));
Assert.IsTrue(result.Count(k => k == 1) == encoder.W);
}
//Assert.IsTrue(expectedResult.SequenceEqual(result));
}
public void InitMultiencoder()
{
CortexNetworkContext ctx = new CortexNetworkContext();
// Gets set of default properties, which more or less every encoder requires.
Dictionary <string, object> encoderSettings = getDefaultSettings();
encoderSettings[EncoderProperties.EncoderQualifiedName] = typeof(TestEncoder).AssemblyQualifiedName;
// We change here value of Name property.
encoderSettings["Name"] = "hello";
// We add here new property.
encoderSettings.Add("TestProp1", "hello");
var encoder = ctx.CreateEncoder(typeof(TestEncoder).FullName, encoderSettings);
// Property can also be set this way.
encoder["abc"] = "1";
Assert.IsTrue((string)encoder["TestProp1"] == "hello");
Assert.IsTrue((string)encoder["Name"] == "hello");
Assert.IsTrue((string)encoder["abc"] == "1");
}
public void EncodeFullDateTimeTest(int w, double r, Object input, int[] expectedOutput)
{
CortexNetworkContext ctx = new CortexNetworkContext();
var now = DateTimeOffset.Now;
Dictionary <string, Dictionary <string, object> > encoderSettings = getFullEncoderSettings();
var encoder = new DateTimeEncoder(encoderSettings, DateTimeEncoder.Precision.Days);
var result = encoder.Encode(DateTimeOffset.Parse(input.ToString()));
// This is a limitation for 2D drawing only.
if ((result.Length % 2) != 0)
{
throw new ArgumentException("Only odd number of bits is allowed. Please set Offset pproperty of all encoders to odd value.");
}
Debug.WriteLine(NeoCortexApi.Helpers.StringifyVector(result));
int[,] twoDimenArray = ArrayUtils.Make2DArray <int>(result, (int)Math.Sqrt(result.Length), (int)Math.Sqrt(result.Length));
var twoDimArray = ArrayUtils.Transpose(twoDimenArray);
NeoCortexUtils.DrawBitmap(twoDimArray, 1024, 1024, $"FullDateTime_out_{input.ToString().Replace("/", "-").Replace(":", "-")}_32x32-N-{encoderSettings["DateTimeEncoder"]["N"]}-W-{encoderSettings["DateTimeEncoder"]["W"]}.png", Color.Yellow, Color.Black);
// Assert.IsTrue(result.SequenceEqual(expectedOutput));
}
public void EncodeDateTimeTest(int w, double r, Object input, int[] expectedOutput)
{
CortexNetworkContext ctx = new CortexNetworkContext();
var now = DateTimeOffset.Now;
Dictionary <string, Dictionary <string, object> > encoderSettings = new Dictionary <string, Dictionary <string, object> >();
encoderSettings.Add("DateTimeEncoder", new Dictionary <string, object>()
{
{ "W", 21 },
{ "N", 1024 },
{ "MinVal", now.AddYears(-10) },
{ "MaxVal", now },
{ "Periodic", false },
{ "Name", "DateTimeEncoder" },
{ "ClipInput", false },
{ "Padding", 5 },
});
var encoder = new DateTimeEncoder(encoderSettings, DateTimeEncoder.Precision.Days);
var result = encoder.Encode(DateTimeOffset.Parse(input.ToString()));
Debug.WriteLine(NeoCortexApi.Helpers.StringifyVector(result));
//Debug.WriteLine(NeoCortexApi.Helpers.StringifyVector(expectedOutput));
int[,] twoDimenArray = ArrayUtils.Make2DArray <int>(result, 32, 32);
var twoDimArray = ArrayUtils.Transpose(twoDimenArray);
NeoCortexUtils.DrawBitmap(twoDimArray, 1024, 1024, $"DateTime_out_{input.ToString().Replace("/", "-").Replace(":", "-")}_32x32-N-{encoderSettings["DateTimeEncoder"]["N"]}-W-{encoderSettings["DateTimeEncoder"]["W"]}.png");
// Assert.IsTrue(result.SequenceEqual(expectedOutput));
}
public void InitTest2()
{
CortexNetworkContext ctx = new CortexNetworkContext();
Dictionary <string, object> encoderSettings = getDefaultSettings();
var encoder = ctx.CreateEncoder(typeof(DateTimeEncoder).FullName, encoderSettings);
foreach (var item in encoderSettings)
{
Assert.IsTrue(item.Value == encoder[item.Key]);
}
}
public void EncodeTimeOnlyTest3(Object input, int[] expectedOutput)
{
CortexNetworkContext ctx = new CortexNetworkContext();
Dictionary <string, object> encoderSettings = getDefaultSettings();
DateTimeEncoderExperimental encoder = new DateTimeEncoderExperimental(encoderSettings);
var result = encoder.EncodeTimeOnly(input);
Debug.WriteLine(NeoCortexApi.Helpers.StringifyVector(result));
Debug.WriteLine(NeoCortexApi.Helpers.StringifyVector(expectedOutput));
Assert.IsTrue(result.SequenceEqual(expectedOutput));
}
public void TestSequence()
{
CortexNetworkContext context = new CortexNetworkContext();
var descriptor = loadMetaDataWithCategoricLabel();
var data = loadSampleDate();
DataSequenceSensor sensor = new DataSequenceSensor(data, descriptor, context);
while (sensor.MoveNext())
{
Debug.WriteLine(Helpers.StringifyVector(sensor.Current));
}
}
public void EncodeTimeOnlyTest(Object input, int[] expectedOutput)
{
CortexNetworkContext ctx = new CortexNetworkContext();
Dictionary <string, object> encoderSettings = getDefaultSettings();
DateTimeEncoder encoder = new DateTimeEncoder(encoderSettings);
var result = encoder.EncodeTimeOnly(input);
foreach (var item in result)
{
Debug.Write(item + ",");
}
Assert.IsTrue(result.SequenceEqual(expectedOutput));
}
public void ScalarEncoderUnitTestPeriodic(double input, int[] expectedResult)
{
CortexNetworkContext ctx = new CortexNetworkContext();
Dictionary <string, object> encoderSettings = getDefaultSettings();
ScalarEncoder encoder = new ScalarEncoder(encoderSettings);
var result = encoder.Encode(input);
Debug.WriteLine(input);
Debug.WriteLine(NeoCortexApi.Helpers.StringifyVector(result));
Debug.WriteLine(NeoCortexApi.Helpers.StringifyVector(expectedResult));
Assert.IsTrue(expectedResult.SequenceEqual(result));
}
/// <summary>
/// Main constructor
/// </summary>
public DataMapper(DataDescriptor descriptor, CortexNetworkContext context)
{
this.m_Context = context;
this.m_Descriptor = descriptor;
foreach (var feature in descriptor.Features)
{
if (feature.EncoderSettings != null)
{
feature.Encoder = this.m_Context.CreateEncoder(feature.EncoderSettings);
}
else
{
throw new ArgumentException("Encoder settings not specified.");
}
}
}
public void InitializeAllEncodersTest()
{
CortexNetworkContext ctx = new CortexNetworkContext();
Assert.IsTrue(ctx.Encoders != null && ctx.Encoders.Count > 0);
Dictionary <string, object> encoderSettings = getDefaultSettings();
foreach (var item in ctx.Encoders)
{
var encoder = ctx.CreateEncoder(typeof(DateTimeEncoder).FullName, encoderSettings);
foreach (var sett in encoderSettings)
{
Assert.IsTrue(sett.Value == encoder[sett.Key]);
}
}
}
/// <summary>
/// Create a List of encoded data as an array of 0 and 1
/// <br>Scalar Encoder initiation,</br>
/// <br>logging the encoded data information to CSV file</br>
/// <br>draw encoded data to bitmaps</br>
/// </summary>
/// <param name="inputDoubleArray"></param>
/// <param name="inputDimSize">how many elements the ouput has</param>
/// <returns></returns>
internal List <int[]> ScalarEncoderDoubleArray(
double[] inputDoubleArray,
int inputDimSize,
String testFolder)
{
List <int[]> arrays = new List <int[]>();
int encodeDim = inputDimSize;
CortexNetworkContext ctx = new CortexNetworkContext();
Dictionary <string, object> encoderSettings = new Dictionary <string, object>
{
{ "W", 25 },
{ "N", encodeDim *encodeDim },
{ "MinVal", inputDoubleArray.Min() - 0.01 },
{ "MaxVal", inputDoubleArray.Max() + 0.01 },
{ "Radius", (double)2.5 },
{ "Resolution", (double)0 },
{ "Periodic", (bool)false },
{ "ClipInput", (bool)true },
{ "Name", "TestScalarEncoder" },
{ "IsRealCortexModel", true }
};
ScalarEncoder encoder = new ScalarEncoder(encoderSettings);
for (int i = 0; i < inputDoubleArray.Length; i++)
{
Debug.WriteLine($"Output Dimension of the Scalar Encoder : {encoder.N}");
var result = encoder.Encode(inputDoubleArray[i]);
Debug.WriteLine($"the input value is {inputDoubleArray[i]}");
Debug.WriteLine($"resulting SDR: {NeoCortexApi.Helpers.StringifyVector(result)}");
arrays.Add(result);
int[,] arrayToDraw = ArrayUtils.Transpose(ArrayUtils.Make2DArray <int>(result, encodeDim, encodeDim));
NeoCortexUtils.DrawBitmap(
arrayToDraw,
OutImgSize, OutImgSize,
$"{outputFolder}\\{testFolder}\\{encoderOutputFolder}\\encodedValnumber_{i}.png",
Color.FromArgb(44, 44, 44),
Color.FromArgb(200, 200, 250),
$"encodedVal of {inputDoubleArray[i]}");
}
LogToCSV(inputDoubleArray, arrays, $"{testFolder}\\{logOutputFolder}\\scalarEncoderOutput.csv");
return(arrays);
}
private float Train(int inpBits, IHtmModule <object, object> network, HtmClassifier <double, ComputeCycle> cls, bool isNewBornMode = true)
{
float accurracy;
string outFolder = nameof(RunPowerPredictionExperiment);
Directory.CreateDirectory(outFolder);
CortexNetworkContext ctx = new CortexNetworkContext();
Dictionary <string, object> scalarEncoderSettings = getScalarEncoderDefaultSettings(inpBits);
//var dateTimeEncoderSettings = getFullDateTimeEncoderSettings();
ScalarEncoder scalarEncoder = new ScalarEncoder(scalarEncoderSettings);
//DateTimeEncoder dtEncoder = new DateTimeEncoder(dateTimeEncoderSettings, DateTimeEncoder.Precision.Hours);
string fileName = "TestFiles\\rec-center-hourly-short.csv";
using (StreamReader sr = new StreamReader(fileName))
{
string line;
int cnt = 0;
int matches = 0;
using (StreamWriter sw = new StreamWriter("out.csv"))
{
while ((line = sr.ReadLine()) != null)
{
cnt++;
//if (isNewBornMode && cnt > 100) break;
bool x = false;
if (x)
{
break;
}
List <int> output = new List <int>();
string[] tokens = line.Split(",");
// Encode scalar value
var result = scalarEncoder.Encode(tokens[1]);
output.AddRange(result);
// This part adds datetime components to the input vector.
//output.AddRange(new int[scalarEncoder.Offset]);
//DateTime dt = DateTime.Parse(tokens[0], CultureInfo.InvariantCulture);
// Encode date/time/hour.
//result = dtEncoder.Encode(new DateTimeOffset(dt, TimeSpan.FromMilliseconds(0)));
//output.AddRange(result);
// This performs a padding to the inputBits = 10404 = 102*102.
output.AddRange(new int[inpBits - output.Count]);
var outArr = output.ToArray();
Debug.WriteLine($"-------------- {tokens[1]} --------------");
if (isNewBornMode)
{
for (int j = 0; j < 10; j++)
{
// Output here are active cells.
var res = network.Compute(output.ToArray(), true);
Debug.WriteLine(Helpers.StringifyVector(((int[])res)));
}
}
else
{
var lyrOut = network.Compute(output.ToArray(), true) as ComputeCycle;;
double input = Convert.ToDouble(tokens[1], CultureInfo.InvariantCulture);
if (input == lastPredictedValue)
{
matches++;
Debug.WriteLine($"Match {input}");
}
else
{
Debug.WriteLine($"Missmatch Actual value: {input} - Predicted value: {lastPredictedValue}");
}
cls.Learn(input, lyrOut.ActiveCells.ToArray());
lastPredictedValue = cls.GetPredictedInputValue(lyrOut.PredictiveCells.ToArray());
sw.WriteLine($"{tokens[0]};{input.ToString(CultureInfo.InvariantCulture)};{lastPredictedValue.ToString(CultureInfo.InvariantCulture)}");
Debug.WriteLine($"W: {Helpers.StringifyVector(lyrOut.WinnerCells.Select(c => c.Index).ToArray())}");
Debug.WriteLine($"P: {Helpers.StringifyVector(lyrOut.PredictiveCells.Select(c => c.Index).ToArray())}");
Debug.WriteLine($"Current input: {input} Predicted Input: {lastPredictedValue}");
int[,] twoDimenArray = ArrayUtils.Make2DArray <int>(outArr, (int)Math.Sqrt(outArr.Length), (int)Math.Sqrt(output.Count));
var twoDimArray = ArrayUtils.Transpose(twoDimenArray);
NeoCortexUtils.DrawBitmap(twoDimArray, 1024, 1024, $"{outFolder}\\{tokens[0].Replace("/", "-").Replace(":", "-")}.png", Color.Yellow, Color.Black, text: input.ToString());
}
Debug.WriteLine($"NewBorn stage: {isNewBornMode} - record: {cnt}");
}
}
accurracy = (float)matches / (float)cnt * (float)100.0;
}
return(accurracy);
}
