public void SparseSingleMnistImageTest(string trainingFolder, string digit, int imageSize, int columnTopology)
{
//Thread.Sleep(3000);
string TestOutputFolder = $"Output-{nameof(SparseSingleMnistImageTest)}";
var trainingImages = Directory.GetFiles(Path.Combine(trainingFolder, digit));
//if (Directory.Exists(TestOutputFolder))
// Directory.Delete(TestOutputFolder, true);
Directory.CreateDirectory(TestOutputFolder);
Directory.CreateDirectory($"{TestOutputFolder}\\{digit}");
int counter = 0;
var numOfActCols = columnTopology * columnTopology;
ThreadSafeRandom rnd = new ThreadSafeRandom(42);
var parameters = Parameters.getAllDefaultParameters();
parameters.Set(KEY.POTENTIAL_RADIUS, imageSize * imageSize);
parameters.Set(KEY.POTENTIAL_PCT, 1.0);
parameters.Set(KEY.GLOBAL_INHIBITION, true);
parameters.Set(KEY.RANDOM, rnd);
parameters.Set(KEY.NUM_ACTIVE_COLUMNS_PER_INH_AREA, 0.02 * 64 * 64);
parameters.Set(KEY.LOCAL_AREA_DENSITY, -1);
parameters.Set(KEY.POTENTIAL_RADIUS, imageSize * imageSize);
parameters.Set(KEY.POTENTIAL_PCT, 1.0);
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.STIMULUS_THRESHOLD, 0.0); //***
//parameters.Set(KEY.SYN_PERM_INACTIVE_DEC, 0.0); //***
//parameters.Set(KEY.SYN_PERM_ACTIVE_INC, 0.0); //***
parameters.Set(KEY.INHIBITION_RADIUS, (int)0.025 * imageSize * imageSize);
parameters.Set(KEY.SYN_PERM_CONNECTED, 0.2);
parameters.Set(KEY.MIN_PCT_OVERLAP_DUTY_CYCLES, 0.001);
parameters.Set(KEY.MIN_PCT_ACTIVE_DUTY_CYCLES, 0.001);
parameters.Set(KEY.DUTY_CYCLE_PERIOD, 1000);
parameters.Set(KEY.MAX_BOOST, 100);
parameters.Set(KEY.WRAP_AROUND, true);
parameters.Set(KEY.SEED, -1);
parameters.setInputDimensions(new int[] { imageSize, imageSize });
parameters.setColumnDimensions(new int[] { columnTopology, columnTopology });
var sp = new SpatialPoolerParallel();
var mem = new Connections();
parameters.apply(mem);
Stopwatch sw = new Stopwatch();
sw.Start();
sp.init(mem, UnitTestHelpers.GetMemory(new HtmConfig()));
sw.Stop();
Debug.WriteLine($"Init time: {sw.ElapsedMilliseconds}");
int actiColLen = numOfActCols;
int[] activeArray = new int[actiColLen];
string outFolder = $"{TestOutputFolder}\\{digit}\\{columnTopology}x{columnTopology}";
Directory.CreateDirectory(outFolder);
string outputHamDistFile = $"{outFolder}\\digit{digit}_{columnTopology}_hamming.txt";
string outputActColFile = $"{outFolder}\\digit{digit}_{columnTopology}_activeCol.txt";
using (StreamWriter swHam = new StreamWriter(outputHamDistFile))
{
using (StreamWriter swActCol = new StreamWriter(outputActColFile))
{
foreach (var mnistImage in trainingImages)
{
FileInfo fI = new FileInfo(mnistImage);
string outputImage = $"{outFolder}\\digit_{digit}_cycle_{counter}_{columnTopology}_{fI.Name}";
string testName = $"{outFolder}\\digit_{digit}_{fI.Name}_{columnTopology}";
string inputBinaryImageFile = Helpers.BinarizeImage($"{mnistImage}", imageSize, testName);
//Read input csv file into array
int[] inputVector = NeoCortexUtils.ReadCsvFileTest(inputBinaryImageFile).ToArray();
int numIterationsPerImage = 5;
int[] oldArray = new int[activeArray.Length];
List <double[, ]> overlapArrays = new List <double[, ]>();
List <double[, ]> bostArrays = new List <double[, ]>();
for (int k = 0; k < numIterationsPerImage; k++)
{
sw.Reset();
sw.Start();
sp.compute(inputVector, activeArray, true);
sw.Stop();
Debug.WriteLine($"Compute time: {sw.ElapsedMilliseconds}");
var activeCols = ArrayUtils.IndexWhere(activeArray, (el) => el == 1);
var distance = MathHelpers.GetHammingDistance(oldArray, activeArray);
swHam.WriteLine($"{counter++}|{distance} ");
oldArray = new int[actiColLen];
activeArray.CopyTo(oldArray, 0);
//var mem = sp.GetMemory(layer);
overlapArrays.Add(ArrayUtils.Make2DArray <double>(ArrayUtils.toDoubleArray(mem.Overlaps), columnTopology, columnTopology));
bostArrays.Add(ArrayUtils.Make2DArray <double>(mem.BoostedOverlaps, columnTopology, columnTopology));
}
var activeStr = Helpers.StringifyVector(activeArray);
swActCol.WriteLine("Active Array: " + activeStr);
int[,] twoDimenArray = ArrayUtils.Make2DArray <int>(activeArray, columnTopology, columnTopology);
twoDimenArray = ArrayUtils.Transpose(twoDimenArray);
List <int[, ]> arrays = new List <int[, ]>();
arrays.Add(twoDimenArray);
arrays.Add(ArrayUtils.Transpose(ArrayUtils.Make2DArray <int>(inputVector, (int)Math.Sqrt(inputVector.Length), (int)Math.Sqrt(inputVector.Length))));
const int OutImgSize = 1024;
NeoCortexUtils.DrawBitmaps(arrays, outputImage, Color.Yellow, Color.Gray, OutImgSize, OutImgSize);
//NeoCortexUtils.DrawHeatmaps(overlapArrays, $"{outputImage}_overlap.png", OutImgSize, OutImgSize, 150, 50, 5);
//NeoCortexUtils.DrawHeatmaps(bostArrays, $"{outputImage}_boost.png", OutImgSize, OutImgSize, 150, 50, 5);
}
}
}
}
public void SPInitTest(PoolerMode poolerMode)
{
//Thread.Sleep(2000);
int numOfColsInDim = 12;
int numInputs = 128;
Parameters parameters = Parameters.getAllDefaultParameters();
parameters.Set(KEY.POTENTIAL_RADIUS, 5);
parameters.Set(KEY.POTENTIAL_PCT, 0.5);
parameters.Set(KEY.GLOBAL_INHIBITION, false);
parameters.Set(KEY.LOCAL_AREA_DENSITY, -1.0);
parameters.Set(KEY.NUM_ACTIVE_COLUMNS_PER_INH_AREA, 3.0);
parameters.Set(KEY.STIMULUS_THRESHOLD, 0.0);
parameters.Set(KEY.SYN_PERM_INACTIVE_DEC, 0.01);
parameters.Set(KEY.SYN_PERM_ACTIVE_INC, 0.1);
parameters.Set(KEY.SYN_PERM_CONNECTED, 0.1);
parameters.Set(KEY.MIN_PCT_OVERLAP_DUTY_CYCLES, 0.1);
parameters.Set(KEY.MIN_PCT_ACTIVE_DUTY_CYCLES, 0.1);
parameters.Set(KEY.DUTY_CYCLE_PERIOD, 10);
parameters.Set(KEY.MAX_BOOST, 10.0);
parameters.Set(KEY.RANDOM, new ThreadSafeRandom(42));
parameters.Set(KEY.INPUT_DIMENSIONS, new int[] { numInputs, numInputs });
parameters.Set(KEY.COLUMN_DIMENSIONS, new int[] { numOfColsInDim, numOfColsInDim });
parameters.setPotentialRadius(5);
//This is 0.3 in Python version due to use of dense
// permanence instead of sparse (as it should be)
parameters.setPotentialPct(0.5);
parameters.setGlobalInhibition(false);
parameters.setLocalAreaDensity(-1.0);
parameters.setNumActiveColumnsPerInhArea(3);
parameters.setStimulusThreshold(1);
parameters.setSynPermInactiveDec(0.01);
parameters.setSynPermActiveInc(0.1);
parameters.setMinPctOverlapDutyCycles(0.1);
parameters.setMinPctActiveDutyCycles(0.1);
parameters.setDutyCyclePeriod(10);
parameters.setMaxBoost(10);
parameters.setSynPermTrimThreshold(0);
//This is 0.5 in Python version due to use of dense
// permanence instead of sparse (as it should be)
parameters.setPotentialPct(1);
parameters.setSynPermConnected(0.1);
//SpatialPooler sp = UnitTestHelpers.CreatePooler(poolerMode) ;
var sp = new SpatialPoolerParallel();
var mem = new Connections();
parameters.apply(mem);
sp.Init(mem, UnitTestHelpers.GetMemory(mem.HtmConfig));
//sp.init(mem);
//int[] inputVector = new int[] { 1, 0, 1, 0, 1, 0, 0, 1, 1 };
//int[] activeArray = new int[] { 0, 0, 0, 0, 0 };
//for (int i = 0; i < 20; i++)
//{
// sp.compute(mem, inputVector, activeArray, true);
//}
}
public void InitDistributedTest(bool isMultinode)
{
Thread.Sleep(5000);
for (int test = 0; test < 3; test++)
{
Stopwatch sw = new Stopwatch();
sw.Start();
int inputBits = 1024;
int numOfColumns = 4096;
ThreadSafeRandom rnd = new ThreadSafeRandom(42);
var parameters = Parameters.getAllDefaultParameters();
parameters.Set(KEY.POTENTIAL_RADIUS, inputBits);
parameters.Set(KEY.POTENTIAL_PCT, 1.0);
parameters.Set(KEY.GLOBAL_INHIBITION, true);
parameters.Set(KEY.RANDOM, rnd);
parameters.Set(KEY.NUM_ACTIVE_COLUMNS_PER_INH_AREA, 0.02 * numOfColumns);
parameters.Set(KEY.LOCAL_AREA_DENSITY, -1);
parameters.Set(KEY.POTENTIAL_RADIUS, inputBits);
parameters.Set(KEY.POTENTIAL_PCT, 1.0);
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.025 * inputBits);
parameters.Set(KEY.SYN_PERM_CONNECTED, 0.2);
parameters.Set(KEY.MIN_PCT_OVERLAP_DUTY_CYCLES, 0.001);
parameters.Set(KEY.MIN_PCT_ACTIVE_DUTY_CYCLES, 0.001);
parameters.Set(KEY.DUTY_CYCLE_PERIOD, 1000);
parameters.Set(KEY.MAX_BOOST, 100);
parameters.Set(KEY.WRAP_AROUND, true);
parameters.Set(KEY.SEED, 1956);
int[] inputDims = new int[] { (int)Math.Sqrt(inputBits), (int)Math.Sqrt(inputBits) };
parameters.setInputDimensions(inputDims);
int[] colDims = new int[] { (int)Math.Sqrt(numOfColumns), (int)Math.Sqrt(numOfColumns) };
parameters.setColumnDimensions(colDims);
SpatialPooler sp;
if (isMultinode)
{
sp = new SpatialPoolerParallel();
}
else
{
sp = new SpatialPoolerMT();
}
var mem = new Connections();
parameters.apply(mem);
if (isMultinode)
{
sp.init(mem, UnitTestHelpers.GetMemory(mem.HtmConfig));
}
else
{
sp.init(mem, UnitTestHelpers.GetMemory());
}
sw.Stop();
Console.Write($"{(float)sw.ElapsedMilliseconds / (float)1000} | ");
}
}
