public LinearNetworkArchitecture AppendStart(LinearNetworkArchitecture other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
if (other.LayerCount == 0)
{
return(this);
}
if (LayerCount > 0)
{
LayerConstruct firstOwn = _layerConstructs.First();
LayerConstruct lastOther = other._layerConstructs.Last();
lastOther.AddOutput(firstOwn);
firstOwn.AddInput(lastOther);
}
for (int i = other._layerConstructs.Count - 1; i >= 0; i--)
{
_layerConstructs.Insert(0, other._layerConstructs[i]);
}
UpdateRegistry();
return(this);
}
public LinearNetworkArchitecture AppendEnd(LinearNetworkArchitecture other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
if (other.LayerCount == 0)
{
return(this);
}
if (LayerCount > 0)
{
LayerConstruct lastOwn = _layerConstructs.Last();
LayerConstruct firstOther = other._layerConstructs.First();
lastOwn.AddOutput(firstOther);
firstOther.AddInput(lastOwn);
}
_layerConstructs.AddRange(other._layerConstructs);
UpdateRegistry();
return(this);
}
protected static LayerConstruct InitialiseBaseConstruct(LayerConstruct construct, double costImportance, string externalTargetsAlias, string externalCostAlias)
{
construct.ExternalInputs = new[] { externalTargetsAlias };
construct.ExternalOutputs = new[] { externalCostAlias };
construct.Parameters["external_targets_alias"] = externalTargetsAlias;
construct.Parameters["external_cost_alias"] = externalCostAlias;
construct.Parameters["cost_importance"] = costImportance;
return(construct);
}
public static LayerConstruct Construct(string name, string inputAlias, params long[] shape)
{
NDArrayUtils.CheckShape(shape);
LayerConstruct construct = new LayerConstruct(name, typeof(InputLayer));
construct.ExternalInputs = new[] { inputAlias };
construct.Parameters["external_input_alias"] = inputAlias;
construct.Parameters["shape"] = shape;
construct.Parameters["size"] = (int)ArrayUtils.Product(shape);
return(construct);
}
public static LayerConstruct Construct(int size, string activation = "sigmoid", string name = "#-fullyconnected")
{
LayerConstruct construct = new LayerConstruct(name, typeof(FullyConnectedLayer));
construct.Parameters["size"] = size;
construct.Parameters["activation"] = activation;
// input size is required for instantiation but not known at construction time, so update before instantiation
construct.UpdateBeforeInstantiationEvent +=
(sender, args) => args.Self.Parameters["default_input_size"] = args.Self.Inputs["default"].Parameters["size"];
return(construct);
}
public static LayerConstruct Construct(double dropoutProbability, string name = "#-dropout")
{
if (dropoutProbability < 0.0 || dropoutProbability >= 1.0)
{
throw new ArgumentException($"Dropout probability must be in range 0.0 <= x < 1.0 but was {dropoutProbability}.");
}
LayerConstruct construct = new LayerConstruct(name, typeof(DropoutLayer));
construct.Parameters["dropout_probability"] = dropoutProbability;
construct.UpdateBeforeInstantiationEvent +=
(sender, args) => args.Self.Parameters["size"] = args.Self.Inputs["default"].Parameters["size"];
return(construct);
}
public virtual object DeepCopy()
{
Dictionary <LayerConstruct, LayerConstruct> mappedConstructCopies = new Dictionary <LayerConstruct, LayerConstruct>();
List <LayerConstruct> copiedConstructs = _layerConstructs.ConvertAll(construct =>
{
LayerConstruct copy = construct.Copy();
mappedConstructCopies.Add(construct, copy);
return(copy);
});
foreach (LayerConstruct original in _layerConstructs)
{
LayerConstruct copy = mappedConstructCopies[original];
foreach (string inputAlias in original.Inputs.Keys)
{
LayerConstruct input = original.Inputs[inputAlias];
if (mappedConstructCopies.ContainsKey(input))
{
input = mappedConstructCopies[input];
}
copy.AddInput(input, inputAlias);
}
foreach (string outputAlias in original.Outputs.Keys)
{
LayerConstruct output = original.Outputs[outputAlias];
if (mappedConstructCopies.ContainsKey(output))
{
output = mappedConstructCopies[output];
}
copy.AddOutput(output, outputAlias);
}
}
return(new LinearNetworkArchitecture(copiedConstructs));
}
public static LayerConstruct Construct(int size, string activation = "tanh", string name = "#-elementwise")
{
LayerConstruct construct = new LayerConstruct(name, typeof(ElementwiseLayer));
construct.Parameters["size"] = size;
construct.Parameters["activation"] = activation;
construct.ValidateEvent += (sender, args) =>
{
if (Convert.ToDecimal(args.Self.Inputs["default"].Parameters["size"]) != Convert.ToDecimal(args.Self.Parameters["size"]))
{
throw new InvalidNetworkArchitectureException(
$"Element-wise layer must be connected to input layer of input size, but own (\"{args.Self.Name}\") size {args.Self.Parameters["size"]} " +
$"does not match size of default input (\"{args.Self.Inputs["default"].Name}\") {args.Self.Inputs["default"].Parameters["size"]}.");
}
};
return(construct);
}
public static LayerConstruct Construct(string name = "#-squaredcost", double importance = 1.0, string externalTargetsAlias = "external_targets", string externalCostAlias = "external_cost")
{
LayerConstruct construct = new LayerConstruct(name, typeof(SquaredDifferenceCostLayer));
return(InitialiseBaseConstruct(construct, importance, externalTargetsAlias, externalCostAlias));
}
public static LayerConstruct Construct(string name = "#-softmaxcecost", double importance = 1.0, string externalTargetsAlias = "external_targets", string externalCostAlias = "external_cost")
{
LayerConstruct construct = new LayerConstruct(name, typeof(SoftMaxCrossEntropyCostLayer));
return(InitialiseBaseConstruct(construct, importance, externalTargetsAlias, externalCostAlias));
}
