static void SensorGaborFilterTest(int maxIterations)
{
string TrainingSetPath = Path.Combine("O:", "clean");
var filter = new Gabor2DFilter();
var writer = new MatrixToBitmapFileWriter("");
var sensor = new BitmapPicture2DSensor(presentationsPerInput: 1, pathSpeed: 2, useRandomOrigin: true);
sensor.SetTrainingFolder(TrainingSetPath);
sensor.AddFilter(filter);
sensor.OnFilteredMatrixOutput += writer.OutputWriterHandler;
int nbIterations = 0;
foreach (var input in sensor.GetTrainingInputs(true))
{
foreach (var iteration in input)
{
nbIterations++;
if (nbIterations >= maxIterations)
break;
}
if (nbIterations >= maxIterations)
break;
}
}
public void CanGetTrainingInputsWithTransformationsAndGaborFilterInNormalOrder()
{
var sensor = new BitmapPicture2DSensor(pathSpeed: 10, useRandomOrigin: true);
sensor.SetTrainingFolder(TrainingSetPath);
sensor.AddFilter(new Gabor2DFilter());
var nbInputs = 0;
var nbIterations = 0;
foreach (var input in sensor.GetTrainingInputs(true))
{
Assert.IsNotNull(input.CurrentFile);
Assert.IsFalse(string.IsNullOrWhiteSpace(input.CategoryName));
nbInputs++;
foreach (var iteration in input)
{
if (!iteration.IsBlank())
nbIterations++;
}
}
Assert.AreEqual(TrainingSetSize, nbInputs, "nbInputs");
Assert.IsTrue(nbIterations >= TrainingSetSize, "nbIterations");
}
public void CanGetTrainingInputsWithTransformationsNoFiltersInNormalOrder()
{
var sensor = new BitmapPicture2DSensor();
sensor.SetTrainingFolder(TrainingSetPath);
var nbInputs = 0;
foreach (var input in sensor.GetTrainingInputs(true))
{
Assert.IsNotNull(input.CurrentFile);
Assert.IsFalse(string.IsNullOrWhiteSpace(input.CategoryName));
foreach (var iteration in input)
{
nbInputs++;
}
}
Assert.IsTrue(nbInputs > TrainingSetSize);
}
public void CanGetTrainingInputsNoTransformationsWithoutFiltersInNormalOrder()
{
int nbRepetitions = 2;
var sensor = new BitmapPicture2DSensor(Default.AutomaticSize, Default.AutomaticSize, 0, nbRepetitions, TrainingOrder.Normal);
sensor.SetTrainingFolder(TrainingSetPath);
var nbInputs = 0;
foreach (var input in sensor.GetTrainingInputs(false))
{
Assert.IsNotNull(input.CurrentFile);
Assert.IsFalse(string.IsNullOrWhiteSpace(input.CategoryName));
foreach (var iteration in input)
{
nbInputs++;
}
}
Assert.AreEqual(nbRepetitions * TrainingSetSize, nbInputs);
}
public void CanGetTrainingInputsNoTransformationsWithoutFiltersInRandomAllOrder()
{
int nbRepetitions = 2;
var sensor = new BitmapPicture2DSensor(Default.AutomaticSize, Default.AutomaticSize, 0, nbRepetitions, TrainingOrder.RandomAll);
sensor.SetTrainingFolder(TrainingSetPath);
var nbInputs = 0;
var categories = new List<string>();
foreach (var input in sensor.GetTrainingInputs(false))
{
Assert.IsNotNull(input.CurrentFile);
Assert.IsFalse(string.IsNullOrWhiteSpace(input.CategoryName));
categories.Add(input.CategoryName);
foreach (var iteration in input)
{
nbInputs++;
Debug.WriteLine("RandomAll order: " + input.CategoryName);
}
}
Assert.AreEqual(nbRepetitions * TrainingSetSize, nbInputs);
// Compare with normal order sequence
var randomCategories = new List<string>();
var randomSensor = new BitmapPicture2DSensor(Default.AutomaticSize, Default.AutomaticSize, 0, nbRepetitions, TrainingOrder.Random);
randomSensor.SetTrainingFolder(sensor.TrainingFolder.FullName);
foreach (var input in randomSensor.GetTrainingInputs(false))
{
randomCategories.Add(input.CategoryName);
foreach (var iteration in input)
{
Debug.WriteLine("Random order: " + input.CategoryName);
}
}
Assert.IsFalse(categories.SequenceEqual(randomCategories));
}
public void CanOutputBitmapFilesFromSensorGeneratedImagesUsingTwoSensorsAndOneOutputFolder()
{
var sensor = new BitmapPicture2DSensor(presentationsPerInput: 1, pathSpeed: 2);
sensor.SetTrainingFolder(TrainingSetPath);
var writer = new MatrixToBitmapFileWriter("SameFolder");
sensor.OnTransformedMatrixOutput += writer.OutputWriterHandler;
var nbIterations = 0;
foreach (var input in sensor.GetTrainingInputs(true))
{
foreach (var iteration in input)
{
nbIterations++;
}
}
Assert.AreEqual(nbIterations, writer.OutputFolder.GetFiles().Length);
var sensor2 = new BitmapPicture2DSensor(presentationsPerInput: 1, pathSpeed: 2);
sensor2.SetTrainingFolder(TrainingSetPath);
var writer2 = new MatrixToBitmapFileWriter("sameFolder");
sensor2.OnTransformedMatrixOutput += writer2.OutputWriterHandler;
var nbIterations2 = 0;
foreach (var input in sensor2.GetTrainingInputs(true))
{
foreach (var iteration in input)
{
nbIterations2++;
}
}
Assert.AreEqual(nbIterations2, writer2.OutputFolder.GetFiles().Length);
}
public void SpatialLayer2DGaussianCanLearnAndInferFromBitmapPicture2DSensor()
{
var sensor = new BitmapPicture2DSensor(presentationsPerInput: 1, pathSpeed: 2, useRandomOrigin: false);
sensor.SetTrainingFolder(TrainingSetPath);
var layer = new Spatial2DLayer(SpatialLayerType.Gaussian, 16, 16, 0.1, true);
foreach (var input in sensor.GetTrainingInputs(true))
{
foreach (var iteration in input)
{
layer.Learn(iteration);
}
}
Assert.IsTrue(((SpatialNode2DGaussian)layer.ClonedNode).CoincidencesFrequencies.Keys.Count > 0);
}
public void GenerateInputsAlwaysInsideSensor()
{
var sensor = new BitmapPicture2DSensor(pathSpeed: 100);
sensor.SetTrainingFolder(TrainingSetPath);
var writer = new MatrixToBitmapFileWriter();
sensor.OnTransformedMatrixOutput += writer.OutputWriterHandler;
var nbInputIterationsOutside = 0;
foreach (var input in sensor.GetTrainingInputs(true))
{
Assert.IsNotNull(input.CurrentFile);
Assert.IsFalse(string.IsNullOrWhiteSpace(input.CategoryName));
foreach (var iteration in input)
{
if (sensor.IsCurrentInputOutsideField())
nbInputIterationsOutside++;
}
}
Assert.AreEqual(0, nbInputIterationsOutside);
}
public void CanOutputFilteredInputsFromGabor2DFilter()
{
var filter = new Gabor2DFilter();
var writer = new MatrixToBitmapFileWriter("");
var sensor = new BitmapPicture2DSensor(presentationsPerInput: 1, pathSpeed: 2, useRandomOrigin: true);
sensor.SetTrainingFolder(TrainingSetPath);
sensor.AddFilter(filter);
sensor.OnFilteredMatrixOutput += writer.OutputWriterHandler;
int maxIterations = 100, nbIterations = 0;
var begin = DateTime.Now;
foreach (var input in sensor.GetTrainingInputs(true))
{
foreach (var iteration in input)
{
nbIterations++;
if (nbIterations >= maxIterations)
break;
}
if (nbIterations >= maxIterations)
break;
}
var end = DateTime.Now;
Debug.WriteLine(begin);
Debug.WriteLine("{0} (duration: {1:D} ms)", end, (int)(end - begin).TotalMilliseconds);
Assert.AreEqual(maxIterations, writer.OutputFolder.GetFiles().Length);
}
public void CanOutputBitmapFilesFromSensorTransformedInputsWithTranslationRotationAndScaling()
{
var sensor = new BitmapPicture2DSensor(presentationsPerInput: 1, pathSpeed: 2,
rotationAngleMaxDegrees:180.0f, rotationSpeed:10.0f, scalingMin:0.5f, scalingMax:2.0f, scalingSpeed:0.1f);
sensor.SetTrainingFolder(TrainingSetPath);
var writer = new MatrixToBitmapFileWriter("");
sensor.OnTransformedMatrixOutput += writer.OutputWriterHandler;
var nbIterations = 0;
foreach (var input in sensor.GetTrainingInputs(true))
{
foreach (var iteration in input)
{
nbIterations++;
}
}
Assert.AreEqual(nbIterations, writer.OutputFolder.GetFiles().Length);
}
public void ErrorWhenTrainingFolderNotFound()
{
var sensor = new BitmapPicture2DSensor();
sensor.SetTrainingFolder("stuff.xyz");
try
{
foreach (var input in sensor.GetTrainingInputs())
{
}
Assert.Fail("No exception thrown while parsing training inputs with inexistent training folder");
}
catch (Exception e)
{
Assert.IsInstanceOfType(e, typeof(DirectoryNotFoundException), e.ToString());
}
}
public void ShouldGetTestInputsInSameOrderWhenTrainingOrderSetToRandom()
{
var sensor = new BitmapPicture2DSensor(Default.AutomaticSize, Default.AutomaticSize, 0, 1, TrainingOrder.Random);
sensor.AddTestFolder(TrainingSetPath);
var nbInputs = 0;
var categories = new List<string>();
foreach (var input in sensor.GetTestInputs())
{
Assert.IsNotNull(input.CurrentFile);
//Debug.WriteLine(input.CurrentFile);
Assert.IsFalse(string.IsNullOrWhiteSpace(input.CategoryName));
categories.Add(input.CategoryName);
foreach (var iteration in input)
{
nbInputs++;
}
}
Assert.AreEqual(TrainingSetSize, nbInputs);
// Compare with normal order sequence
var normalCategories = new List<string>();
var normalSensor = new BitmapPicture2DSensor(Default.AutomaticSize, Default.AutomaticSize, 0, 1, TrainingOrder.Normal);
normalSensor.AddTestFolder(TrainingSetPath);
foreach (var input in normalSensor.GetTestInputs(false))
{
normalCategories.Add(input.CategoryName);
}
Assert.IsTrue(categories.SequenceEqual(normalCategories));
}
public void ShouldGetTestInputsInNormalAlphabeticalOrder()
{
var sensor = new BitmapPicture2DSensor();
sensor.AddTestFolder(TrainingSetPath);
var nbInputs = 0;
var prevInput = "";
foreach (var input in sensor.GetTestInputs())
{
Assert.IsNotNull(input.CurrentFile);
Assert.IsFalse(string.IsNullOrWhiteSpace(input.CategoryName));
Assert.IsTrue(input.CurrentFile.Name.CompareTo(prevInput) > 0);
prevInput = input.CurrentFile.Name;
foreach (var iteration in input)
{
nbInputs++;
}
}
Assert.AreEqual(TrainingSetSize, nbInputs);
}
public void SensorGeneratesNoBlankOutput()
{
var sensor = new BitmapPicture2DSensor(pathSpeed: 1000);
sensor.SetTrainingFolder(TrainingSetPath);
foreach (var input in sensor.GetTrainingInputs(true))
{
Assert.IsNotNull(input.CurrentFile);
Assert.IsFalse(string.IsNullOrWhiteSpace(input.CategoryName));
foreach (var iteration in input)
{
Assert.AreEqual(false, iteration.IsBlank());
}
}
}
public void NoErrorWhenTrainingFolderEmpty()
{
var sensor = new BitmapPicture2DSensor();
var emptyFolder = Directory.CreateDirectory("empty");
sensor.SetTrainingFolder(emptyFolder.FullName);
try
{
foreach (var input in sensor.GetTrainingInputs())
{
Assert.Fail("This folder should be empty for testing purposes: " + sensor.TrainingFolder);
}
}
catch (Exception e)
{
Assert.Fail("Should not throw an exception when an empty folder is used for training: " + e.ToString());
}
}
public void ErrorWhenTrainingFolderNotSet()
{
var sensor = new BitmapPicture2DSensor();
try
{
foreach (var input in sensor.GetTrainingInputs())
{
}
Assert.Fail("No exception thrown while parsing training inputs with no training folder set");
}
catch (Exception e)
{
Assert.IsInstanceOfType(e, typeof(HtmException), e.Message);
}
}
public void CanOutputBitmapFilesFromSensorTransformedInputsWithTranslation()
{
var sensor = new BitmapPicture2DSensor(presentationsPerInput: 1, pathSpeed: 2, useRandomOrigin: false);
sensor.SetTrainingFolder(TrainingSetPath);
var writer = new MatrixToBitmapFileWriter("");
sensor.OnTransformedMatrixOutput += writer.OutputWriterHandler;
var realNbInputs = sensor.TrainingFolder.EnumerateFiles("*.bmp", SearchOption.AllDirectories).Count();
var nbIterations = 0;
var nbInputs = 0;
foreach (var input in sensor.GetTrainingInputs(true))
{
bool newInput = true;
foreach (var iteration in input)
{
if (newInput)
{
nbInputs++;
newInput = false;
}
nbIterations++;
}
}
Assert.AreEqual(realNbInputs, nbInputs, "nbInputs");
Assert.AreEqual(nbIterations, writer.OutputFolder.GetFiles().Length, "nbIterations");
}
public void CheckTrainingInputsAreInReverseOrder()
{
int nbRepetitions = 1;
var sensor = new BitmapPicture2DSensor(Default.AutomaticSize, Default.AutomaticSize, 0, nbRepetitions, TrainingOrder.Reverse);
sensor.SetTrainingFolder(TrainingSetPath);
var nbInputs = 0;
var categories = new List<string>();
foreach (var input in sensor.GetTrainingInputs(false))
{
Assert.IsNotNull(input.CurrentFile);
Assert.IsFalse(string.IsNullOrWhiteSpace(input.CategoryName));
categories.Add(input.CategoryName);
foreach (var iteration in input)
{
nbInputs++;
}
}
Assert.AreEqual(nbRepetitions * TrainingSetSize, nbInputs);
Assert.IsTrue(categories.SequenceEqual(categories.OrderByDescending(s => s)));
}
