/// <summary>
/// Constrains the weights in the specified layer from being updated. This prevents weights in pretrained layers from being updated.
/// </summary>
/// <param name="network">Current network.</param>
/// <param name="layer">The layer of weights to constrain. To prevent all weights from being changed specify the global value of -1.</param>
/// <param name="constrain">Sets the <see cref="Neuron.Constrained"/> value to true/false.</param>
/// <returns></returns>
public static Network Constrain(this Network network, int layer = -1, bool constrain = true)
{
var nodes = (layer >= 0 ? network.GetNodes(layer) : network.GetVertices());
foreach (Neuron node in nodes)
{
node.Constrained = constrain;
}
return(network);
}
/// <summary>
/// Reindexes each node's layer and label in the network, starting from 0 (input layer).
/// </summary>
/// <param name="network">Network to reindex.</param>
/// <returns></returns>
public static Network Reindex(this Network network)
{
var nodes = network.GetVertices().OfType <Neuron>()
.GroupBy(g => g.LayerId)
.OrderBy(o => o.Key)
.ToArray();
int layer = 0;
foreach (var group in nodes)
{
int count = 0;
foreach (var node in group)
{
node.LayerId = layer;
// update labels.
if (node.IsInput)
{
node.Label = $"I{count}";
}
if (node.IsBias)
{
node.Label = $"B{layer}";
}
if (node.IsHidden)
{
node.Label = $"H{layer}.{count}";
}
if (node.IsOutput)
{
node.Label = $"O{count}";
}
count++;
}
layer++;
}
return(network);
}
/// <summary>
/// Stacks the given networks in order, on top of the current network, to create a fully connected deep neural network.
/// <para>This is useful in building pretrained multi-layered neural networks, where each layer is partially trained prior to stacking.</para>
/// </summary>
/// <param name="network">Current network.</param>
/// <param name="removeInputs">If true, the input nodes in additional layers are removed prior to stacking.
/// <para>This will link the previous network's output layer with the hidden units of the next layer.</para>
/// </param>
/// <param name="removeOutputs">If true, output nodes in the input and middle layers are removed prior to stacking.
/// <para>This will link the previous network's hidden or output layer with the input or hidden units (when <paramref name="removeInputs"/> is true) in the next layer.</para>
/// </param>
/// <param name="addBiases">If true, missing bias nodes are automatically added within new hidden layers.</param>
/// <param name="constrain">If true, the weights within each network are constrained leaving the new interconnecting network weights for training.</param>
/// <param name="networks">Network objects to stack on top of the current network. Each network is added downstream from the input nodes.</param>
public static Network Stack(this Network network, bool removeInputs = false, bool removeOutputs = false, bool addBiases = true,
bool constrain = true, params Network[] networks)
{
IFunction ident = new Ident();
// prune output layer on first (if pruning)
Network deep = (removeOutputs ? network.Prune(true, 1) : network);
if (constrain)
{
deep.Constrain();
}
// get the current network's output layer
List <Neuron> prevOutput = deep.Out.ToList();
for (int x = 0; x < networks.Length; x++)
{
Network net = networks[x];
if (constrain)
{
net.Constrain();
}
// remove input layer on next network (if pruning)
if (removeInputs)
{
net = net.Prune(false, 1);
}
// remove output layer on next (middle) network (if pruning)
if (removeOutputs && x < networks.Length - 1)
{
net = net.Prune(true, 1);
}
// add biases (for hidden network layers)
if (addBiases)
{
if (!prevOutput.Any(a => a.IsBias == true))
{
int layerId = prevOutput.First().LayerId;
var bias = new Neuron(true)
{
Label = $"B{layerId}",
ActivationFunction = ident,
NodeId = 0,
LayerId = layerId
};
// add to graph
deep.AddNode(bias);
// copy to previous network's output layer (for reference)
prevOutput.Insert(0, bias);
}
}
int deepLayers = deep.Layers;
Neuron[] prevLayer = null;
var layers = net.GetVertices().OfType <Neuron>()
.GroupBy(g => g.LayerId)
.ToArray();
for (int layer = 0; layer < layers.Count(); layer++)
{
// get nodes in current layer of current network
var nodes = layers.ElementAt(layer).ToArray();
// set new layer ID (relative to pos. in resulting graph)
int layerId = layer + deepLayers;
foreach (var node in nodes)
{
// set the new layer ID
node.LayerId = layerId;
// add to graph
deep.AddNode(node);
if (!node.IsBias)
{
// if not input layer in current network
if (layer > 0)
{
// add afferent edges to graph for current node
deep.AddEdges(net.GetInEdges(node).ToArray());
}
else
{
// add connections from previous network output layer to next input layer
foreach (var onode in prevOutput)
{
deep.AddEdge(Edge.Create(onode, node));
}
}
}
}
// nodes in last layer
if (prevLayer != null)
{
// add outgoing connections for each node in previous layer
foreach (var inode in prevLayer)
{
deep.AddEdges(net.GetOutEdges(inode).ToArray());
}
}
// remember last layer
prevLayer = nodes.ToArray();
}
// remember last network output nodes
prevOutput = deep.GetNodes(deep.Layers - 1).ToList();
}
deep.Reindex();
deep.In = deep.GetNodes(0).ToArray();
deep.Out = deep.GetNodes(deep.Layers - 1).ToArray();
return(deep);
}