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 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 ScalarEncodingExperiment() { string outFolder = nameof(ScalarEncodingExperiment); Directory.CreateDirectory(outFolder); DateTime now = DateTime.Now; ScalarEncoder encoder = new ScalarEncoder(new Dictionary <string, object>() { { "W", 21 }, { "N", 1024 }, { "Radius", -1.0 }, { "MinVal", 0.0 }, { "MaxVal", 100.0 }, { "Periodic", false }, { "Name", "scalar" }, { "ClipInput", false }, }); for (double i = 0.0; i < (long)encoder.MaxVal; i += 0.1) { var result = encoder.Encode(i); 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, $"{outFolder}\\{i}.png", Color.Yellow, Color.Black, text: i.ToString()); } }
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)); }
/// <summary> /// Encode the passenger data based on day month segment and day of week /// </summary> /// <param name="taxiData"></param> /// <returns></returns> public static List <Dictionary <string, int[]> > EncodePassengerData(List <ProcessedData> taxiData) { var unsortedTaxiData = taxiData.GroupBy(c => new { c.Date }).AsEnumerable().Cast <dynamic>(); var multSequenceTaxiData = unsortedTaxiData.ToList(); List <Dictionary <string, int[]> > ListOfEncodedTrainingSDR = new List <Dictionary <string, int[]> >(); ScalarEncoder dayEncoder = FetchDayEncoder(); ScalarEncoder monthEncoder = FetchMonthEncoder(); ScalarEncoder segmentEncoder = FetchSegmentEncoder(); ScalarEncoder dayOfWeekEncoder = FetchWeekDayEncoder(); foreach (var sequenceData in multSequenceTaxiData) { var tempDictionary = new Dictionary <string, int[]>(); foreach (var sequence in sequenceData) { var observationLabel = sequence.Passanger_count; int day = sequence.Date.Day; int month = sequence.Date.Month; int segement = Convert.ToInt32(sequence.Segment); int dayOfWeek = (int)sequence.Date.DayOfWeek; int[] sdr = new int[0]; sdr = sdr.Concat(dayEncoder.Encode(day)).ToArray(); sdr = sdr.Concat(monthEncoder.Encode(month)).ToArray(); sdr = sdr.Concat(segmentEncoder.Encode(segement)).ToArray(); sdr = sdr.Concat(dayOfWeekEncoder.Encode(dayOfWeek)).ToArray(); // UNCOMMENT THESE LINES TO DRAW SDR BITMAP //int[,] twoDimenArray = ArrayUtils.Make2DArray<int>(sdr, 100, 100); //var twoDimArray = ArrayUtils.Transpose(twoDimenArray); //NeoCortexUtils.DrawBitmap(twoDimArray, 1024, 1024, $"{sequence.Date.Day}.png", null); if (tempDictionary.Count > 0 && tempDictionary.ContainsKey(observationLabel.ToString())) { var newKey = observationLabel + "," + segement; tempDictionary.Add(newKey, sdr); } else { tempDictionary.Add(observationLabel.ToString(), sdr); } } ListOfEncodedTrainingSDR.Add(tempDictionary); } return(ListOfEncodedTrainingSDR); }
public void MonthEncoderTest(string input) { ScalarEncoder monthEncoder = DateTimeEncoders.FetchMonthEncoder(); DateTime dateTime = DateTime.Parse(input); int month = dateTime.Month; var result = monthEncoder.Encode(month); int[,] twoDimenArray = ArrayUtils.Make2DArray <int>(result, 100, 100); var twoDimArray = ArrayUtils.Transpose(twoDimenArray); NeoCortexUtils.DrawBitmap(twoDimArray, 1024, 1024, $"{dateTime.Day}.png", null); }
public void DayOfWeekEncoderTest(string input) { ScalarEncoder dayEncoder = DateTimeEncoders.FetchDayEncoder(); DateTime dateTime = DateTime.Parse(input); int dayOfWeek = (int)dateTime.DayOfWeek; var result = dayEncoder.Encode(dayOfWeek); int[,] twoDimenArray = ArrayUtils.Make2DArray <int>(result, 100, 100); var twoDimArray = ArrayUtils.Transpose(twoDimenArray); NeoCortexUtils.DrawBitmap(twoDimArray, 1024, 1024, $"{dateTime.Day}.png", null); }
public void SegmentEncoderTest(string input) { ScalarEncoder segmentEncoder = DateTimeEncoders.FetchSegmentEncoder(); DateTime dateTime = DateTime.Parse(input); var time = dateTime.ToString("HH:mm"); Slot slot = CSVPRocessingMethods.GetSlot(time); var result = segmentEncoder.Encode(slot.Segment); int[,] twoDimenArray = ArrayUtils.Make2DArray <int>(result, 100, 100); var twoDimArray = ArrayUtils.Transpose(twoDimenArray); NeoCortexUtils.DrawBitmap(twoDimArray, 1024, 1024, $"{dateTime.Day}.png", null); }
/// <summary> /// Returns the input vectors as array of integers /// </summary> /// <param name="inputSequence">An array of double, consisting the starting indexes for each input vector</param> /// <param name="min">Minimum index in the input vector plane</param> /// <param name="max">Maximum index in the input vector plane</param> /// <param name="inputs"> /// </param> /// <param name="outFolder">The path where the input vectors are to be generated</param> /// <returns></returns> static List <int[]> GetEncodedSequence(double[] inputSequence, double min, double max, InputParameters inputs, string outFolder) { List <int[]> sdrList = new List <int[]>(); DateTime now = DateTime.Now; ScalarEncoder encoder = new ScalarEncoder(new Dictionary <string, object>() { { "W", inputs.getWidth() }, { "N", 1024 }, { "Radius", inputs.getRadius() }, { "MinVal", min }, { "MaxVal", max }, { "Periodic", false }, { "Name", "scalar" }, { "ClipInput", false }, }); foreach (var i in inputSequence) { var result = encoder.Encode(i); sdrList.Add(result); int[,] twoDimenArray = ArrayUtils.Make2DArray(result, (int)Math.Sqrt(result.Length), (int)Math.Sqrt(result.Length)); var twoDimArray = ArrayUtils.Transpose(twoDimenArray); int counter = 0; if (File.Exists(outFolder + @"\\" + i + @".png")) { counter = 1; while (File.Exists(outFolder + @"\\" + i + @"-" + counter.ToString() + @".png")) { counter++; } } if (counter == 0) { NeoCortexUtils.DrawBitmap(twoDimArray, 1024, 1024, $"{outFolder}\\{i}.png", Color.Yellow, Color.Black, text: i.ToString()); } else { NeoCortexUtils.DrawBitmap(twoDimArray, 1024, 1024, $"{outFolder}\\{i}-{counter}.png", Color.Yellow, Color.Black, text: i.ToString()); } } return(sdrList); }
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)); }
private void ScalarEncoderTest(int[] inputs) { var outFolder = @"..\..\..\TestFiles\ScalarEncoderResults"; ScalarEncoder encoder = new ScalarEncoder(new Dictionary <string, object>() { { "W", 3 }, // 2% Approx { "N", 100 }, { "MinVal", (double)0 }, { "MaxVal", (double)99 }, { "Periodic", true }, { "Name", "Scalar Sequence" }, { "ClipInput", true }, }); Dictionary <double, int[]> sdrs = new Dictionary <double, int[]>(); foreach (double input in inputs) { int[] result = encoder.Encode(input); Console.WriteLine($"Input = {input}"); Console.WriteLine($"SDRs Generated = {NeoCortexApi.Helpers.StringifyVector(result)}"); Console.WriteLine($"SDR As Text = {NeoCortexApi.Helpers.StringifyVector(ArrayUtils.IndexWhere(result, k => k == 1))}"); int[,] twoDimenArray = ArrayUtils.Make2DArray <int>(result, (int)Math.Sqrt(result.Length), (int)Math.Sqrt(result.Length)); int[,] twoDimArray = ArrayUtils.Transpose(twoDimenArray); NeoCortexUtils.DrawBitmap(twoDimArray, 1024, 1024, $"{outFolder}\\{input}.png", Color.PaleGreen, Color.Blue, text: input.ToString()); sdrs.Add(input, result); } // <summary> /// Calculate all required results. /// 1. Overlap and Union of the Binary arrays of two scalar values /// It cross compares the binary arrays of any of the two scalar values User enters. /// 2. Creates bitmaps of the overlaping and non-overlaping regions of the two binary arrays selected by the User. /// </summary> Console.WriteLine("Encoder Binary array Created"); Console.WriteLine("Enter the two elements you want to Compare"); String a = Console.ReadLine(); String b = Console.ReadLine(); SimilarityResult(Convert.ToInt32(a), Convert.ToInt32(b), sdrs, outFolder); }
/// <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); }
/// <summary> /// Get SDR of a date time /// </summary> /// <param name="dateTime"></param> /// <returns></returns> public static int[] GetSDRofDateTime(DateTime dateTime) { int[] sdr = new int[0]; ScalarEncoder dayEncoder = FetchDayEncoder(); ScalarEncoder monthEncoder = FetchMonthEncoder(); ScalarEncoder segmentEncoder = FetchSegmentEncoder(); ScalarEncoder dayOfWeekEncoder = FetchWeekDayEncoder(); int day = dateTime.Day; int month = dateTime.Month; Slot result = CSVPRocessingMethods.GetSlot(dateTime.ToString("H:mm")); int segement = Convert.ToInt32(result.Segment); int dayOfWeek = (int)dateTime.DayOfWeek; sdr = sdr.Concat(dayEncoder.Encode(day)).ToArray(); sdr = sdr.Concat(monthEncoder.Encode(month)).ToArray(); sdr = sdr.Concat(segmentEncoder.Encode(segement)).ToArray(); sdr = sdr.Concat(dayOfWeekEncoder.Encode(dayOfWeek)).ToArray(); return(sdr); }
public void CreateSdrAsTextTest() { var outFolder = @"EncoderOutputImages\ScalerEncoderOutput"; int[] d = new int[] { 1, 4, 5, 7, 8, 9 }; this.ScalarEncoderTest(d); Directory.CreateDirectory(outFolder); Console.WriteLine("SDR Representation using ScalarEncoder"); for (int input = 1; input < (int)6; input++) { //double input = 1.10; ScalarEncoder encoder = new ScalarEncoder(new Dictionary <string, object>() { { "W", 25 }, { "N", (int)0 }, { "Radius", (double)2.5 }, { "MinVal", (double)1 }, { "MaxVal", (double)50 }, { "Periodic", false }, { "Name", "Scalar Encoder" }, { "ClipInput", false }, }); var result = encoder.Encode(input); Debug.WriteLine($"Input = {input}"); Debug.WriteLine($"SDRs Generated = {NeoCortexApi.Helpers.StringifyVector(result)}"); Debug.WriteLine($"SDR As Indices = {NeoCortexApi.Helpers.StringifyVector(ArrayUtils.IndexWhere(result, k => k == 1))}"); 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, $"{outFolder}\\{input}.png", Color.Yellow, Color.Black, text: input.ToString()); } }
/// <summary> /// Creating CSV file containing encoded input for the SP /// </summary> /// <param name="E_inputFilePath">Input CSV file path</param> /// <param name="E_outputFilePath">Output CSV file path</param> /// <param name="local_E_outFolder">Folder to store graphical representation of the Encoder's output</param> /// <param name="local_E_outBits">Number of the Scalar Encoder's output bits</param> private void Encoding(string E_inputFilePath, string E_outputFilePath, string local_E_outFolder, int local_E_outBits) { Dictionary <string, object> scalarEncoderSettings = GetScalarEncoderDefaultSettings(local_E_outBits); ScalarEncoder encoder = new ScalarEncoder(scalarEncoderSettings); using (StreamReader sr = new StreamReader(E_inputFilePath)) { string line; using (StreamWriter sw = new StreamWriter(E_outputFilePath)) { while ((line = sr.ReadLine()) != null) { List <int> E_output = new List <int>(); string[] tokens = line.Split(","); var E_result = encoder.Encode(tokens[1]); E_output.AddRange(E_result); E_output.AddRange(new int[local_E_outBits - E_output.Count]); var outArr = E_output.ToArray(); Debug.WriteLine($"-------------- {tokens[1]} --------------"); //int[,] E_twoDimenArray = ArrayUtils.Make2DArray<int>(outArr, 15, 31); //var E_twoDimArray = ArrayUtils.Transpose(E_twoDimenArray); //NeoCortexUtils.DrawBitmap(E_twoDimArray, 1024, 1024, $"{local_E_outFolder}\\{tokens[0].Replace("/", "-").Replace(":", "-")}.png", Color.Yellow, Color.Black, text: tokens[1]); sw.Write($"{tokens[1]},"); for (int i = 0; i < outArr.Length; i++) { sw.Write(outArr[i]); if (i < (outArr.Length - 1)) { sw.Write(","); } } sw.WriteLine(); } } } }
public List <int[]> GetEncodedSequence(double[] inputSequence, double min, double max) { List <int[]> sdrList = new List <int[]>(); string outFolder = nameof(NoiseUnitTests); Directory.CreateDirectory(outFolder); DateTime now = DateTime.Now; ScalarEncoder encoder = new ScalarEncoder(new Dictionary <string, object>() { { "W", 21 }, { "N", 1024 }, { "Radius", -1.0 }, { "MinVal", min }, { "MaxVal", max }, { "Periodic", false }, { "Name", "scalar" }, { "ClipInput", false }, }); foreach (var i in inputSequence) { var result = encoder.Encode(i); sdrList.Add(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, $"{outFolder}\\{i}.png", Color.Yellow, Color.Black, text: i.ToString()); } return(sdrList); }
/// <summary> /// Creating CSV file containing encoded input for the SP /// </summary> /// <param name="E_outBits"></param> private void Encoding(int local_E_outBits) { string E_inFile = "TestFiles\\sequence.csv"; string E_outFolder = "MyEncoderOutput"; string E_noisyinFile = "TestFiles\\noisy_sequence.csv"; string E_noisyoutFolder = "MyNoisyEncoderOutput"; Directory.CreateDirectory(E_outFolder); Directory.CreateDirectory(E_noisyoutFolder); string E_outFile = $"{E_outFolder}\\MyEncoderOut.csv"; string E_noisyoutFile = $"{E_noisyoutFolder}\\MyNoisyEncoderOut.csv"; Dictionary <string, object> scalarEncoderSettings = getScalarEncoderDefaultSettings(local_E_outBits); ScalarEncoder encoder = new ScalarEncoder(scalarEncoderSettings); ScalarEncoder noisyencoder = new ScalarEncoder(scalarEncoderSettings); using (StreamReader sr = new StreamReader(E_inFile)) { string line; using (StreamWriter sw = new StreamWriter(E_outFile)) { while ((line = sr.ReadLine()) != null) { List <int> E_output = new List <int>(); string[] tokens = line.Split(","); var E_result = encoder.Encode(tokens[1]); E_output.AddRange(E_result); E_output.AddRange(new int[local_E_outBits - E_output.Count]); var outArr = E_output.ToArray(); Debug.WriteLine($"-------------- {tokens[1]} --------------"); int[,] E_twoDimenArray = ArrayUtils.Make2DArray(outArr, 9, 47); var E_twoDimArray = ArrayUtils.Transpose(E_twoDimenArray); NeoCortexUtils.DrawBitmap(E_twoDimArray, 1024, 1024, $"{E_outFolder}\\{tokens[0].Replace("/", "-").Replace(":", "-")}.png", Color.Yellow, Color.Black, text: tokens[1]); sw.Write($"{tokens[1]},"); for (int i = 0; i < outArr.Length; i++) { sw.Write(outArr[i]); if (i < outArr.Length - 1) { sw.Write(","); } } sw.WriteLine(); } } } using (StreamReader sr = new StreamReader(E_noisyinFile)) { string line; using (StreamWriter sw = new StreamWriter(E_noisyoutFile)) { while ((line = sr.ReadLine()) != null) { List <int> E_output = new List <int>(); string[] tokens = line.Split(","); var E_result = noisyencoder.Encode(tokens[1]); E_output.AddRange(E_result); E_output.AddRange(new int[local_E_outBits - E_output.Count]); var outArr = E_output.ToArray(); Debug.WriteLine($"-------------- {tokens[1]} --------------"); int[,] E_twoDimenArray = ArrayUtils.Make2DArray(outArr, 9, 47); var E_twoDimArray = ArrayUtils.Transpose(E_twoDimenArray); NeoCortexUtils.DrawBitmap(E_twoDimArray, 1024, 1024, $"{E_noisyoutFolder}\\{tokens[0].Replace("/", "-").Replace(":", "-")}.png", Color.Yellow, Color.Black, text: tokens[1]); sw.Write($"{tokens[1]},"); for (int i = 0; i < outArr.Length; i++) { sw.Write(outArr[i]); if (i < outArr.Length - 1) { sw.Write(","); } } sw.WriteLine(); } } } }
public void SimilarityExperimentWithEncoder() { int stableStateCnt = 100; double minOctOverlapCycles = 1.0; double maxBoost = 10.0; int inputBits = 100; var colDims = new int[] { 64 * 64 }; int numOfActCols = colDims[0]; int numColumns = colDims[0]; string TestOutputFolder = $"Output-{nameof(ImageSimilarityExperiment)}"; Directory.CreateDirectory($"{nameof(ImageSimilarityExperiment)}"); //int counter = 0; //var parameters = GetDefaultParams(); ////parameters.Set(KEY.DUTY_CYCLE_PERIOD, 20); ////parameters.Set(KEY.MAX_BOOST, 1); ////parameters.setInputDimensions(new int[] { imageSize[imSizeIndx], imageSize[imSizeIndx] }); ////parameters.setColumnDimensions(new int[] { topologies[topologyIndx], topologies[topologyIndx] }); ////parameters.setNumActiveColumnsPerInhArea(0.02 * numOfActCols); //parameters.Set(KEY.NUM_ACTIVE_COLUMNS_PER_INH_AREA, 0.06 * 4096); // TODO. Experiment with different sizes //parameters.Set(KEY.POTENTIAL_RADIUS, inputBits); //parameters.Set(KEY.POTENTIAL_PCT, 1.0); //parameters.Set(KEY.GLOBAL_INHIBITION, true); // TODO: Experiment with local inhibition too. Note also the execution time of the experiment. //// Num of active synapces in order to activate the column. //parameters.Set(KEY.STIMULUS_THRESHOLD, 50.0); //parameters.Set(KEY.SYN_PERM_INACTIVE_DEC, 0.008); //parameters.Set(KEY.SYN_PERM_ACTIVE_INC, 0.05); //parameters.Set(KEY.INHIBITION_RADIUS, (int)0.15 * inputBits); // TODO. check if this has influence in a case of the global inhibition. ALso check how this parameter influences the similarity of SDR. //parameters.Set(KEY.SYN_PERM_CONNECTED, 0.2); //parameters.Set(KEY.MIN_PCT_OVERLAP_DUTY_CYCLES, 1.0); //parameters.Set(KEY.MIN_PCT_ACTIVE_DUTY_CYCLES, 0.001); //parameters.Set(KEY.DUTY_CYCLE_PERIOD, 100); //parameters.Set(KEY.MAX_BOOST, 10); //parameters.Set(KEY.WRAP_AROUND, true); //parameters.Set(KEY.SEED, 1969); //parameters.setInputDimensions(new int[] {inputBits }); //parameters.setColumnDimensions(colDims); Parameters p = Parameters.getAllDefaultParameters(); p.Set(KEY.RANDOM, new ThreadSafeRandom(42)); p.Set(KEY.INPUT_DIMENSIONS, new int[] { inputBits }); p.Set(KEY.COLUMN_DIMENSIONS, colDims); p.Set(KEY.CELLS_PER_COLUMN, 10); p.Set(KEY.MAX_BOOST, maxBoost); p.Set(KEY.DUTY_CYCLE_PERIOD, 50); p.Set(KEY.MIN_PCT_OVERLAP_DUTY_CYCLES, minOctOverlapCycles); // Global inhibition // N of 40 (40= 0.02*2048 columns) active cells required to activate the segment. p.Set(KEY.GLOBAL_INHIBITION, true); p.setNumActiveColumnsPerInhArea(0.02 * numColumns); p.Set(KEY.POTENTIAL_RADIUS, (int)(.7 * inputBits)); p.Set(KEY.LOCAL_AREA_DENSITY, -1); // In a case of global inhibition. //p.setInhibitionRadius( Automatically set on the columns pace in a case of global inhibition.); // Activation threshold is 10 active cells of 40 cells in inhibition area. p.setActivationThreshold(10); // Max number of synapses on the segment. p.setMaxNewSynapsesPerSegmentCount((int)(0.02 * numColumns)); double max = 20; Dictionary <string, object> settings = new Dictionary <string, object>() { { "W", 15 }, { "N", inputBits }, { "Radius", -1.0 }, { "MinVal", 0.0 }, { "Periodic", false }, { "Name", "scalar" }, { "ClipInput", false }, { "MaxVal", max } }; var encoder = new ScalarEncoder(settings); bool isInStableState = false; var mem = new Connections(); p.apply(mem); var inputs = new int[] { 0, 1, 2, 3, 4, 5 }; HomeostaticPlasticityController hpa = new HomeostaticPlasticityController(mem, inputs.Length * 150, (isStable, numPatterns, actColAvg, seenInputs) => { // Event should only be fired when entering the stable state. // Ideal SP should never enter unstable state after stable state. Assert.IsTrue(isStable); //Assert.IsTrue(numPatterns == inputs.Length); isInStableState = true; Debug.WriteLine($"Entered STABLE state: Patterns: {numPatterns}, Inputs: {seenInputs}, iteration: {seenInputs / numPatterns}"); }); SpatialPooler sp = new SpatialPoolerMT(hpa); sp.Init(mem, UnitTestHelpers.GetMemory()); string outFolder = $"{TestOutputFolder}"; Directory.CreateDirectory(outFolder); string outputHamDistFile = $"{outFolder}\\hamming.txt"; string outputActColFile = $"{outFolder}\\activeCol.txt"; using (StreamWriter swHam = new StreamWriter(outputHamDistFile)) { using (StreamWriter swActCol = new StreamWriter(outputActColFile)) { int cycle = 0; Dictionary <string, int[]> sdrs = new Dictionary <string, int[]>(); while (!isInStableState) { foreach (var digit in inputs) { int[] activeArray = new int[numOfActCols]; int[] oldArray = new int[activeArray.Length]; List <double[, ]> overlapArrays = new List <double[, ]>(); List <double[, ]> bostArrays = new List <double[, ]>(); var inputVector = encoder.Encode(digit); sp.compute(inputVector, activeArray, true); string actColFileName = Path.Combine(outFolder, $"{digit}.actcols.txt"); if (cycle == 0 && File.Exists(actColFileName)) { File.Delete(actColFileName); } var activeCols = ArrayUtils.IndexWhere(activeArray, (el) => el == 1); using (StreamWriter swCols = new StreamWriter(actColFileName, true)) { swCols.WriteLine(Helpers.StringifyVector(activeCols)); } Debug.WriteLine($"'Cycle: {cycle} - {digit}'"); Debug.WriteLine($"IN :{Helpers.StringifyVector(inputVector)}"); Debug.WriteLine($"OUT:{Helpers.StringifyVector(activeCols)}\n"); if (isInStableState) { if (--stableStateCnt <= 0) { return; } } /* * if (isInStableState) * { * swActCol.WriteLine($"\nDigit {digit}"); * * sdrs.Add(digit.ToString(), activeCols); * * // * // To be sure that same input produces the same output after entered the stable state. * for (int i = 0; i < 100; i++) * { * activeArray = new int[numOfActCols]; * * sp.compute(inputVector, activeArray, true); * * var distance = MathHelpers.GetHammingDistance(oldArray, activeArray, true); * * var actColsIndxes = ArrayUtils.IndexWhere(activeArray, i => i == 1); * var oldActColsIndxes = ArrayUtils.IndexWhere(oldArray, i => i == 1); * * var similarity = MathHelpers.CalcArraySimilarity(actColsIndxes, oldActColsIndxes); * * swHam.Write($"Digit {digit}: Dist/Similarity: {distance} | {similarity}\t"); * Debug.Write($"Digit {digit}: Dist/Similarity: {distance} | {similarity}\t"); * Debug.WriteLine($"{Helpers.StringifyVector(actColsIndxes)}"); * * if (i > 5 && similarity < 100) * { * * } * * oldArray = new int[numOfActCols]; * activeArray.CopyTo(oldArray, 0); * } * } * * Debug.WriteLine($"Cycle {cycle++}");*/ } cycle++; } CalculateSimilarity(sdrs, null);//todo } } }
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); }
public void TestScalarEncoder() { SetUp(); InitSe(); int[] empty = se.Encode(Encoder <double> .SENTINEL_VALUE_FOR_MISSING_DATA); Console.WriteLine("\nEncoded missing data as: " + Arrays.ToString(empty)); int[] expected = new int[14]; Assert.IsTrue(Arrays.AreEqual(expected, empty)); }