public void CanMakeLayerListWithContent()
{
Layer layer = new Layer(new double[, ] {
{ 1 }
});
LayerChain layerlist = new LayerChain(layer);
Assert.AreNotEqual(null, layerlist);
}
public void UnrunNetworkHasZeroOutput()
{
Layer layer = new Layer(new double[, ] {
{ 1 }, { 2 }, { 3 }
});
LayerChain layerlist = new LayerChain(layer);
NetworkVector outputCheck = new NetworkVector(new double[] { 0, 0, 0 });
Assert.AreEqual(outputCheck, layerlist.Output);
}
public void CanRunWithZeroInput()
{
Layer layer = new Layer(new double[, ] {
{ 1 }
});
LayerChain layerlist = new LayerChain(layer);
NetworkVector vector = new NetworkVector(new double[] { 0 });
layerlist.Run(vector);
Assert.AreEqual(vector, layerlist.Output);
}
public void CanBackPropagateTwoLayerNetGradient1()
{
Layer inputlayer = new Layer(new double[, ] {
{ 1, 1, 1 }, { 1, 1, 1 }
});
Layer outputlayer = new Layer(new double[, ] {
{ 1, 1 }
});
LayerChain network = new LayerChain();
network.Add(inputlayer);
network.Add(outputlayer);
NetworkVector inputvector = new NetworkVector(new double[] { 1, 0, 0 });
NetworkVector outputgradient = new NetworkVector(new double[] { 1 });
network.Run(inputvector);
network.BackPropagate(outputgradient);
LayerState inputState = network.State[0];
LayerState outputState = network.State[1];
double[,] inputWeights = inputState.Weights;
double[,] inputWeightsCheck = new double[, ] {
{ 0, 1, 1 }, { 0, 1, 1 }
};
double[] inputBiases = inputState.Biases;
double[] inputBiasesCheck = new double[] { -1, -1 };
for (int i = 0; i < inputWeights.GetLength(0); i++)
{
Assert.AreEqual(inputBiasesCheck[i], inputBiases[i]);
for (int j = 0; j < inputWeights.GetLength(1); j++)
{
Assert.AreEqual(inputWeights[i, j], inputWeights[i, j]);
}
}
double[,] outputWeights = outputState.Weights;
double[,] outputWeightsCheck = new double[, ] {
{ 0, 0 }
};
double[] outputBiases = outputState.Biases;
double[] outputBiasesCheck = new double[] { -1 };
for (int i = 0; i < outputWeights.GetLength(0); i++)
{
Assert.AreEqual(outputBiasesCheck[i], outputBiases[i]);
for (int j = 0; j < outputWeights.GetLength(1); j++)
{
Assert.AreEqual(outputWeightsCheck[i, j], outputWeights[i, j]);
}
}
}
public void CannotRunWithInputOfWrongSize()
{
Layer layer = new Layer(new double[, ] {
{ 1 }
});
LayerChain layerlist = new LayerChain(layer);
NetworkVector input = new NetworkVector(new double[] { 0, 0 });
try
{
layerlist.Run(input);
Assert.Fail("Run should throw an ArgumentException for input of the wrong size, but did not.");
}
catch (ArgumentException)
{ }
}
public void CanCountLayers()
{
Layer layer = new Layer(new double[, ] {
{ 1 }
});
LayerChain layerlist = new LayerChain();
Assert.AreEqual(0, layerlist.NumberOfComponents);
for (int i = 1; i < 10; i++)
{
layerlist.Add(layer);
Assert.AreEqual(i, layerlist.NumberOfComponents);
}
}
public void CanRunTwoLayersWithZeroInput()
{
Layer layer1 = new Layer(new double[, ] {
{ 1, 1 }, { 1, 1 }
});
Layer layer2 = new Layer(new double[, ] {
{ 1, 1 }
});
LayerChain layerlist = new LayerChain(layer1);
layerlist.Add(layer2);
NetworkVector vector = new NetworkVector(new double[] { 0, 0 });
layerlist.Run(vector);
Assert.AreEqual(0, layerlist.Output.ToArray()[0]);
}
public void CannotAddLayerOfWrongSize()
{
Layer layer1 = new Layer(new double[, ] {
{ 1 }
});
Layer layer2 = new Layer(new double[, ] {
{ 1, 2 }
});
LayerChain layerlist = new LayerChain(layer1);
try
{
layerlist.Add(layer2);
Assert.Fail("Add should throw and ArgumentException if when trying to add a layer of the wrong size, but did not.");
}
catch (ArgumentException)
{ }
Assert.AreNotEqual(null, layerlist);
}
public void CanRunTwoLayerNetWithOneInput()
{
Layer inputlayer = new Layer(new double[, ] {
{ 1, 1, 1 }, { 1, 1, 1 }
});
Layer outputlayer = new Layer(new double[, ] {
{ 1, 1 }
});
LayerChain network = new LayerChain();
network.Add(inputlayer);
network.Add(outputlayer);
NetworkVector inputvector = new NetworkVector(new double[] { 1, 0, 0 });
network.Run(inputvector);
double output = network.Output.ToArray()[0];
Assert.AreEqual(2, output);
}
public void CannotAddNonLayer()
{
Layer layer = new Layer(new double[, ] {
{ 1 }
});
NetworkComponent layer_component = new Layer(new double[, ] {
{ 2 }
});
NetworkComponent non_layer_component = new SoftMaxUnit(1);
LayerChain lChain = new LayerChain();
lChain.Add(layer);
lChain.Add(layer_component);
try
{
lChain.Add(non_layer_component);
Assert.Fail("Attempt to add a network component that cannot be cast as Layer failed to throw an ArgumentException.");
}
catch (ArgumentException) { }
}
public Tree Interpret(Tree frame)
{
if (_interpreter != null)
{
Tree tree = LayerChain.InterpretChain(_layers, frame);
MutableTree mutable = MutableTree.FromTree(tree);
PrefabSingleInterpretArgs args = new PrefabSingleInterpretArgs(mutable, Storage);
try
{
_interpreter.Interpret(args);
}
catch (Exception e)
{
mutable["interpretation_exception"] = e;
}
return(Tree.FromMutable(mutable));
}
return(frame);
}
public void CanMakeLayerList()
{
LayerChain layerlist = new LayerChain();
Assert.AreNotEqual(null, layerlist);
}
public Tree Interpret(Tree frame)
{
return(LayerChain.InterpretChain(_layers, frame));
}
