public virtual LayerConstruct Copy()
{
LayerConstruct copy = new LayerConstruct(Name, _layerClassType)
{
Parameters = (IRegistry)Parameters.DeepCopy(),
ExternalInputs = (string[])ExternalInputs.Clone(),
ExternalOutputs = (string[])ExternalOutputs.Clone(),
UpdateBeforeInstantiationEvent = UpdateBeforeInstantiationEvent,
ValidateEvent = ValidateEvent
};
return(copy);
}
public void AddInput(LayerConstruct input, string alias = "default")
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (Inputs.ContainsKey(alias))
{
throw new ArgumentException($"Attempted to add duplicate output to construct {Name} with alias {alias}.");
}
Inputs.Add(alias, input);
}
/// <inheritdoc />
public void Initialise(IComputationHandler handler)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
if (Architecture == null)
{
throw new InvalidOperationException("Cannot initialise network before assigning a network architecture.");
}
_logger.Debug($"Initialising network \"{Name}\" for handler {handler} containing {Architecture.LayerCount} layers...");
_associatedHandler = handler;
ITaskObserver prepareTask = SigmaEnvironment.TaskManager.BeginTask(TaskType.Prepare);
Architecture.ResolveAllNames();
_orderedLayerBuffers.Clear();
_externalInputsLayerBuffers.Clear();
_externalOutputsLayerBuffers.Clear();
Dictionary <Tuple <LayerConstruct, LayerConstruct>, IRegistry> mappedRegistriesByInOutputs = new Dictionary <Tuple <LayerConstruct, LayerConstruct>, IRegistry>();
foreach (LayerConstruct layerConstruct in Architecture.YieldLayerConstructsOrdered())
{
ILayer layer = layerConstruct.InstantiateLayer(handler);
Dictionary <string, IRegistry> inputs = new Dictionary <string, IRegistry>();
foreach (string externalInputAlias in layerConstruct.ExternalInputs)
{
inputs[externalInputAlias] = new Registry(tags: "external_input");
}
foreach (string inputAlias in layerConstruct.Inputs.Keys)
{
inputs[inputAlias] = mappedRegistriesByInOutputs[new Tuple <LayerConstruct, LayerConstruct>(layerConstruct.Inputs[inputAlias], layerConstruct)];
}
Dictionary <string, IRegistry> outputs = new Dictionary <string, IRegistry>();
foreach (string externalOutputAlias in layerConstruct.ExternalOutputs)
{
outputs[externalOutputAlias] = new Registry(tags: "external_output");
}
foreach (string outputAlias in layerConstruct.Outputs.Keys)
{
LayerConstruct outputConstruct = layerConstruct.Outputs[outputAlias];
Tuple <LayerConstruct, LayerConstruct> inOuTuple = new Tuple <LayerConstruct, LayerConstruct>(layerConstruct, outputConstruct);
Registry outRegistry = new Registry(tags: "internal");
mappedRegistriesByInOutputs.Add(inOuTuple, outRegistry);
outputs[outputAlias] = outRegistry;
}
InternalLayerBuffer layerBuffer = new InternalLayerBuffer(layer, layerConstruct.Parameters, inputs, outputs,
layerConstruct.ExternalInputs, layerConstruct.ExternalOutputs);
_orderedLayerBuffers.Add(layerBuffer);
if (layerConstruct.ExternalInputs.Length > 0)
{
_externalInputsLayerBuffers.Add(layerBuffer);
}
if (layerConstruct.ExternalOutputs.Length > 0)
{
_externalOutputsLayerBuffers.Add(layerBuffer);
}
}
_orderedLayers = _orderedLayerBuffers.ConvertAll(buffer => buffer.Layer);
UpdateRegistry();
SigmaEnvironment.TaskManager.EndTask(prepareTask);
_initialised = true;
_logger.Debug($"Done initialising network \"{Name}\" for handler {handler} containing {Architecture.LayerCount} layers.");
}
internal LayerConstructEventArgs(LayerConstruct self)
{
Self = self;
}
/// <summary>
/// Check if the type of two layer constructs is equal.
/// </summary>
/// <param name="other">The other layer construct.</param>
/// <returns>A boolean indicating whether or not the two layer construct types are equal.</returns>
public bool TypeEquals(LayerConstruct other)
{
return(other != null && other._layerClassType == _layerClassType);
}
