public void Build(int inputsCount,
int[] hiddenLayersSpec,
int outputsCount,
ActivationFunction activationFunction,
double maximumAbsoluteWeight)
{
layers = new List<ILayer>();
inputLayer = new InputLayer();
for (int i = 0; i < inputsCount; i++)
inputLayer.AddNeuron(new Neuron());
isBipolar = activationFunction == Neuron.BipolarActivationFunction;
layers.Add((Layer)inputLayer);
if (hiddenLayersSpec != null)
for (int i = 0; i < hiddenLayersSpec.Length; i++)
{
ILayer layer = new Layer();
for (int j = 0; j < hiddenLayersSpec[i]; j++)
{
layer.AddNeuron(new Neuron(activationFunction));
}
layers.Add(layer);
}
outputLayer = new Layer();
for (int i = 0; i < outputsCount; i++)
{
outputLayer.AddNeuron(new Neuron(activationFunction));
}
layers.Add(outputLayer);
ConnectLayers(maximumAbsoluteWeight);
}
public override MidiInputChannel GetInputChannel(IInputLayer parent)
{
if (this.c == null)
{
this.c = new ButtonInputChannel(this, parent);
}
return(this.c);
}
public override MidiInputChannel GetInputChannel(IInputLayer parent)
{
if (this.c == null)
{
this.c = new MidiRangeInputChannel(parent, this);
}
return(this.c);
}
public void InputLayer_WithSortOrder_InitializesProperty()
{
// Arrange
_layer = new InputLayer(5);
// Assert
Assert.IsTrue(_layer.SortOrder == 5);
}
public void Initialize()
{
_network = new DFFNeuralNetwork(_inputLayerNeuronCount, _hiddenLayersCount, _hiddenLayerNeuronCount, _outputLayerNeuronCount);
_inputLayer = _network.Layers.OfType <IInputLayer>().First();
_outputLayer = _network.Layers.OfType <IOutputLayer>().First();
_hiddenLayer = _network.Layers.OfType <IHiddenLayer>().First();
_trainingIterations = new List <INetworkTrainingIteration>();
}
public static IDisposable BindTo(this IObservable <bool> This, IInputLayer inputLayer, string reason)
{
var disableDisposable = new SerialDisposable();
return(new CompositeDisposable(
disableDisposable,
This.DistinctUntilChanged()
.Subscribe(x => disableDisposable.Disposable = x
? null
: inputLayer.Disable(reason))));
}
static void Evaluate(Func<Tuple<INetwork, IFactory>> GetNetwork, bool verbose)
{
var StartTimingLayer = new TimingLayer() {StartCounters = new string[] { "Prediction-Time" } };
var StopTimingLayer = new TimingLayer() {StopCounters = new string[] { "Prediction-Time" } };
IInputLayer ReaderLayer = null;
var NetworkAndFactory = GetNetwork();
var Network = NetworkAndFactory.Item1;
var Factory = NetworkAndFactory.Item2;
{
var p = Network;
while (!(p.GetSource() is EncryptLayer)) p = p.GetSource();
StartTimingLayer.Source = p.GetSource();
var b = p as BaseLayer;
b.Source = StartTimingLayer;
// find the reader
while (p.GetSource() != null) p = p.GetSource();
ReaderLayer = p as IInputLayer;
// stop the timing counters after computing the entire network
StopTimingLayer.Source = Network;
Network = StopTimingLayer;
p = Network;
while (p != null)
{
p.Factory = Factory;
if (p is BaseLayer bas) bas.Verbose = verbose;
p = p.GetSource();
}
Network.PrepareNetwork();
}
int errs = 0;
for (int i = 0; i < 10000; i++)
{
using (var m = Network.GetNext())
{
var l = ReaderLayer.Labels[0];
int pred = 0;
Utils.ProcessInEnv(env =>
{
var dec = m.Decrypt(env);
for (int j = 0; j < 10; j++)
if (dec[j, 0] > dec[pred, 0]) pred = j;
if (pred != l) errs++;
}, Factory);
Console.WriteLine("errs {0}/{1} accuracy {2:0.000}% {3} prediction {4} label {5}", errs, i + 1, 100 - (100.0 * errs / (i + 1)), TimingLayer.GetStats(), pred, l);
}
}
Network.DisposeNetwork();
}
public NetworkTopology()
{
hiddenLayers = null;
inputLayer = null;
outputLayer = null;
preProcessor = null;
postProcessor = null;
TrainingPreProcessor = null;
TrainingAlgorithm = null;
}
public NetworkTopology()
{
hiddenLayers = null;
inputLayer = null;
outputLayer = null;
preProcessor = null;
postProcessor = null;
TrainingPreProcessor = null;
TrainingAlgorithm = null;
}
public void InputLayer_WithSortOrderAndNeurons_InitializesProperty()
{
// Arrange
var inputNeuron = new InputNeuron();
_layer = new InputLayer(5, new List <IInputNeuron>()
{
inputNeuron
});
// Assert
Assert.IsTrue(_layer.Neurons.Count() == 1);
Assert.IsTrue(_layer.Neurons.First() == inputNeuron);
}
public MidiInputChannel(IInputLayer parent, DeviceRule rule, bool registerValueChange = true, bool registerFB = true) : base(rule.GUID, parent)
{
base.AutofireChangedEvent = true;
rule.NameChanged += new EventHandler(this.HandleNameChanged);
base.Name = rule.Name;
if (registerValueChange)
{
rule.ValueChanged += new EventHandler <ValueChangedEventArgs>(this.HandleValueChanged);
}
if (registerFB)
{
this.FeedbackCB = new InputLayerChangedCallback(this.HandleFeedback);
}
this.rule = rule;
this.Changed += HandleChanged;
}
public Network(
IConfiguration configuration,
IInputLayer inputLayer,
IOutputReader <T> outputLayer
)
{
if (configuration.HiddenLayerCount <= 0)
{
throw new ArgumentException("Layer count should be positive");
}
if (configuration.NeuronPerLayer <= 0)
{
throw new ArgumentException("Neuron per layer should be positive");
}
_configuration = configuration;
randomSource = new Random();
_inputLayer = inputLayer;
_outputLayer = outputLayer;
_layers = new Layer[configuration.HiddenLayerCount + 2];
AttachInput(inputLayer);
CreateHiddenLayer();
AttachOutput(outputLayer, configuration.HiddenLayerCount + 1);
BindAllNeuron();
UpdateWeight();
if (configuration.SaveToDisk)
{
_dal = new DataAccessLibrary <T>();
_dal.CreateDatabase();
_dal.SaveNetwork(this);
}
}
public InputLayer(string name, IInputLayer parent = null)
{
Name = name;
var isEnabledObservable = _refCount.Select(x => x == 0);
// Also take parent's state into account, if any
if (parent != null)
{
((InputLayer)parent)._children.Add(this);
isEnabledObservable = isEnabledObservable
.CombineLatest(parent.IsEnabled, (x, y) => x && y);
}
_isEnabled = isEnabledObservable.ToReactiveProperty();
if (Log.IsDebugEnabled)
{
_isEnabled
.DistinctUntilChanged()
.Subscribe(x => Log.Debug($"{Name} IsEnabled: {x}"));
}
}
public abstract MidiInputChannel GetInputChannel(IInputLayer parent);
public static IObservable <T> DisableLayerUntilCompleted <T>(this IObservable <T> This, IInputLayer layer, string reason) =>
Observable.Defer(() =>
{
var disposable = layer.Disable(reason);
return(This.Finally(() => disposable.Dispose()));
});
public KohonenNetwork(IInputLayer inputLayer, IInnerLayer outputLayer)
{
_inputLayer = inputLayer;
KohonenLayer = outputLayer;
}
public void Initialize()
{
_layer = new InputLayer(1);
}
public static IDisposable BindStateTo(this IPresenter This, IInputLayer inputLayer) => This.State .Select(x => x == PresenterState.Ready) .BindTo(inputLayer, "Navigating");
protected TwoLayersNetwork(IInputLayer inputLayer, ILayer <INode> outputLayer)
: base(inputLayer, outputLayer)
{
_outputLayer = outputLayer;
}
/// <summary>
/// Creates an object for a specified datatype
/// </summary>
/// <typeparam name="TObject">Interface that will be implimented and returned</typeparam>
/// <param name="objectName">The name of the data type that will be instantiated
/// and returned.</param>
/// <param name="buildParam">The paramater that will be used to create the object</param>
/// <returns>Returns a finished object instance</returns>
public TObject CreateUserObject <TObject>(
string objectName, Dictionary <string, string> buildParam)
{
switch (objectName)
{
case "BasicNode":
string[] rawModifiers = ParseList(buildParam["combinationWeights"]);
float[] modifiers = new float[rawModifiers.Length];
for (int i = 0; i < rawModifiers.Length; i++)
{
float.TryParse(rawModifiers[i], out modifiers[i]);
}
BasicNode node = new BasicNode();
node.MetaData = buildParam;
node.Weights = modifiers;
if (buildParam.ContainsKey("activationFunction"))
{
node.ActivationFunc = getActivationFunction(buildParam["activationFunction"]);
}
INode tempNode = node;
return((TObject)tempNode);
case "CustomizableNode":
rawModifiers = ParseList(buildParam["combinationWeights"]);
modifiers = new float[rawModifiers.Length];
for (int i = 0; i < rawModifiers.Length; i++)
{
float.TryParse(rawModifiers[i], out modifiers[i]);
}
CustomizableNode custNode = new CustomizableNode();
custNode.MetaData = buildParam;
custNode.Weights = modifiers;
if (buildParam.ContainsKey("activationFunction"))
{
custNode.ActivationFunc =
getActivationFunction(buildParam["activationFunction"]);
}
if (buildParam.ContainsKey("combinationFunction"))
{
custNode.ComboFunction =
getCombinationFunction(buildParam["combinationFunction"]);
}
tempNode = custNode;
return((TObject)tempNode);
case "BasicInputLayer":
BasicInputLayer input = new BasicInputLayer();
input.MetaData = buildParam;
string[] rawValues = ParseList(buildParam["inputIndexes"]);
int[] values = new int[rawValues.Length];
for (int i = 0; i < rawValues.Length; i++)
{
int.TryParse(rawValues[i], out values[i]);
}
input.ValueIndexes = values;
IInputLayer tempIn = input;
return((TObject)tempIn);
case "BasicOutputLayer":
IOutputLayer tempOut = new BasicOutputLayer();
tempOut.MetaData = buildParam;
return((TObject)tempOut);
case "BasicLayer":
int count;
int.TryParse(buildParam["nodeCount"], out count);
IHiddenLayer tempHidden = new BasicLayer(new INode[count]);
tempHidden.MetaData = buildParam;
return((TObject)tempHidden);
case "ThreadedHiddenLayer":
int.TryParse(buildParam["nodeCount"], out count);
tempHidden = new ThreadedHiddenLayer(new INode[count]);
tempHidden.MetaData = buildParam;
return((TObject)tempHidden);
case "HillClimbAlgo":
ITrainingAlgorithm algo = new HillClimbAlgo();
return((TObject)algo);
default:
return(default(TObject));
}
}
public MidiRangeInputChannel(IInputLayer parent, DeviceRule r) : base(parent, r, true, true)
{
}
public ButtonInputChannel(DeviceRule d, IInputLayer parent) : base(parent, d, true, true)
{
}
