private float[] _weights; // synapses weights #endregion Fields #region Constructors /// <summary> /// Constructor /// </summary> /// <param name = "inputs">Number of inputs of the neuron</param> public Neuron(int inputs) { _function = new SigmoidFunction(); _inputsCount = Math.Max(1, inputs); _weights = new float[_inputsCount]; Randomize(); }
/// <summary> /// Normalize in place desired output /// </summary> /// <param name = "function">Activation function used</param> /// <param name = "output">Normalize output</param> /// <returns>Normalized output</returns> public static double[] NormalizeOneDesiredOutputInPlace(IActivationFunction function, double[] output) { if (function is ActivationSigmoid) { for (int i = 0, n = output.Length; i < n; i++) { output[i] = (output[i] > 0 ? 0.8 : 0.2); } } else if (function is ActivationTANH) { for (int i = 0, n = output.Length; i < n; i++) { output[i] = (output[i] > 0.5 ? 0.5 : -0.5); } } else if (function is ActivationLinear) { /*do nothing*/ } else { throw new ArgumentException("Unknown activation function"); } return output; }
/// <summary> /// Constructor /// </summary> /// <param name = "inputs">Number of inputs of the neuron</param> /// <param name = "function">Activation function of the neuron</param> public Neuron(int inputs, IActivationFunction function) { _function = function; _inputsCount = Math.Max(1, inputs); _weights = new float[_inputsCount]; Randomize(); }
/// <summary> /// Normalize in place desired input /// </summary> /// <param name = "function">Activation function</param> /// <param name = "input">Input to normalize</param> /// <returns>Reference to normalized input</returns> public static double[] NormalizeDesiredInputInPlace(IActivationFunction function, double[] input) { if (function is ActivationTANH) { for (int i = 0, n = input.Length; i < n; i++) { input[i] = (input[i] == 0 ? 0.0f : (input[i] < 0 ? -0.8f : 0.8f)); } } else if (function is ActivationSigmoid) { for (int i = 0, n = input.Length; i < n; i++) { input[i] = (input[i] == 0 ? 0.0f : (input[i] < 0 ? 0.2f : 0.8f)); } } else if (function is ActivationLinear) { /*do nothing*/ } else { throw new ArgumentException("Unknown activation function"); } return input; }
public Substrate(uint input, uint output, uint hidden, IActivationFunction function) { weightRange = HyperNEATParameters.weightRange; threshold = HyperNEATParameters.threshold; inputCount = input; outputCount = output; hiddenCount = hidden; activationFunction = function; inputDelta = 2.0f / (inputCount); if (hiddenCount != 0) hiddenDelta = 2.0f / (hiddenCount); else hiddenDelta = 0; outputDelta = 2.0f / (outputCount); //SharpNEAT requires that the neuronlist be input|bias|output|hidden neurons=new NeuronGeneList((int)(inputCount + outputCount+ hiddenCount)); //setup the inputs for (uint a = 0; a < inputCount; a++) { neurons.Add(new NeuronGene(a, NeuronType.Input, activationFunction)); } //setup the outputs for (uint a = 0; a < outputCount; a++) { neurons.Add(new NeuronGene(a + inputCount, NeuronType.Output, activationFunction)); } for (uint a = 0; a < hiddenCount; a++) { neurons.Add(new NeuronGene(a + inputCount+outputCount, NeuronType.Hidden, activationFunction)); } }
static public INetwork DecodeToConcurrentNetwork(NeatGenome.NeatGenome g, IActivationFunction activationFn) { //----- Loop the neuronGenes. Create Neuron for each one. // Store a table of neurons keyed by their id. Hashtable neuronTable = new Hashtable(g.NeuronGeneList.Count); NeuronList neuronList = new NeuronList(); foreach(NeuronGene neuronGene in g.NeuronGeneList) { Neuron newNeuron = new Neuron(activationFn, neuronGene.NeuronType, neuronGene.InnovationId); neuronTable.Add(newNeuron.Id, newNeuron); neuronList.Add(newNeuron); } //----- Loop the connection genes. Create a Connection for each one and bind them to the relevant Neurons. foreach(ConnectionGene connectionGene in g.ConnectionGeneList) { Connection newConnection = new Connection(connectionGene.SourceNeuronId, connectionGene.TargetNeuronId, connectionGene.Weight); // Bind the connection to it's source neuron. newConnection.SetSourceNeuron((Neuron)neuronTable[connectionGene.SourceNeuronId]); // Store the new connection against it's target neuron. ((Neuron)(neuronTable[connectionGene.TargetNeuronId])).ConnectionList.Add(newConnection); } return new ConcurrentNetwork(neuronList); }
/// <summary> /// Construct a starting NEAT population. /// </summary> /// /// <param name="inputCount">The input neuron count.</param> /// <param name="outputCount">The output neuron count.</param> /// <param name="populationSize">The population size.</param> public NEATPopulation(int inputCount, int outputCount, int populationSize) : base(populationSize) { _neatActivationFunction = new ActivationSigmoid(); _outputActivationFunction = new ActivationLinear(); InputCount = inputCount; OutputCount = outputCount; if (populationSize == 0) { throw new NeuralNetworkError( "Population must have more than zero genomes."); } // create the initial population for (int i = 0; i < populationSize; i++) { var genome = new NEATGenome(AssignGenomeID(), inputCount, outputCount); Add(genome); } // create initial innovations var genome2 = (NEATGenome) Genomes[0]; Innovations = new NEATInnovationList(this, genome2.Links, genome2.Neurons); }
public Neuron(Neuron neuron) { m_inputsCount = neuron.m_inputsCount; m_weights = (double[])neuron.m_weights.Clone(); m_function = neuron.m_function; m_threshold = neuron.m_threshold; }
public Neuron(int inputCount, double[] weights, IActivationFunction function, double threshold) { m_inputsCount = inputCount; m_weights = weights; m_function = function; m_threshold = threshold; }
public Neuron(int inputCount, IActivationFunction function) { m_inputsCount = inputCount; m_function = function; m_weights = new double[inputCount + 1]; SetRandomWeights(); }
public FlatLayer(IActivationFunction activation, int count, double biasActivation) { this.Activation = activation; this._x10f4d88af727adbc = count; this._x25922738b86264c8 = biasActivation; this._x4d51c0aa16352a14 = null; }
/// <summary> /// Set new activation function for all neurons of the network. /// </summary> /// /// <param name="function">Activation function to set.</param> /// /// <remarks><para>The method sets new activation function for all neurons by calling /// <see cref="ActivationLayer.SetActivationFunction"/> method for each layer of the network.</para></remarks> /// public void SetActivationFunction( IActivationFunction function ) { for ( int i = 0; i < layers.Length; i++ ) { ( (ActivationLayer) layers[i] ).SetActivationFunction( function ); } }
/// <summary> /// Construct with a single IActivationFunction. /// </summary> /// <param name="activationFn"></param> public NeatActivationFunctionLibrary(IActivationFunction activationFn) { _activationFn = activationFn; _activationFnInfo = new ActivationFunctionInfo(0, 1.0, activationFn); _activationFnInfoList = new List<ActivationFunctionInfo>(1); _activationFnInfoList.Add(_activationFnInfo); }
/// <summary> /// Constructs a FastCyclicNetwork with the provided pre-built FastConnection array and /// associated data. /// </summary> public FastCyclicNetwork(FastConnection[] connectionArray, IActivationFunction[] neuronActivationFnArray, double[][] neuronAuxArgsArray, int neuronCount, int inputNeuronCount, int outputNeuronCount, int timestepsPerActivation) { _connectionArray = connectionArray; _neuronActivationFnArray = neuronActivationFnArray; _neuronAuxArgsArray = neuronAuxArgsArray; // Create neuron pre- and post-activation signal arrays. _preActivationArray = new double[neuronCount]; _postActivationArray = new double[neuronCount]; // Wrap sub-ranges of the neuron signal arrays as input and output arrays for IBlackBox. // Offset is 1 to skip bias neuron (The value at index 1 is the first black box input). _inputSignalArrayWrapper = new SignalArray(_postActivationArray, 1, inputNeuronCount); // Offset to skip bias and input neurons. Output neurons follow input neurons in the arrays. _outputSignalArrayWrapper = new SignalArray(_postActivationArray, inputNeuronCount+1, outputNeuronCount); // Store counts for use during activation. _inputNeuronCount = inputNeuronCount; _inputAndBiasNeuronCount = inputNeuronCount+1; _outputNeuronCount = outputNeuronCount; _timestepsPerActivation = timestepsPerActivation; // Initialise the bias neuron's fixed output value. _postActivationArray[0] = 1.0; }
public Neuron(IActivationFunction activationFunc, double charge) { Charge = charge; Error = 0; Activation = activationFunc; In = new Dictionary<Neuron, double>(); }
/// <summary> /// Copy constructor. /// </summary> /// <param name="copyFrom"></param> public NeuronGene(NeuronGene copyFrom) { this.innovationId = copyFrom.innovationId; this.neuronType = copyFrom.neuronType; this.activationFunction = copyFrom.activationFunction; this.Layer = copyFrom.Layer; }
/// <summary> /// Set new activation function for all neurons of the layer. /// </summary> /// /// <param name="function">Activation function to set.</param> /// /// <remarks><para>The methods sets new activation function for each neuron by setting /// their <see cref="ActivationNeuron.ActivationFunction"/> property.</para></remarks> /// public void SetActivationFunction( IActivationFunction function ) { for ( int i = 0; i < neurons.Length; i++ ) { ( (ActivationNeuron) neurons[i] ).ActivationFunction = function; } }
/// <summary> /// Initializes a new instance of the <see cref="ActivationLayer"/> class. /// </summary> /// /// <param name="neuronsCount">Layer's neurons count.</param> /// <param name="inputsCount">Layer's inputs count.</param> /// <param name="function">Activation function of neurons of the layer.</param> /// /// <remarks>The new layer is randomized (see <see cref="ActivationNeuron.Randomize"/> /// method) after it is created.</remarks> /// public ActivationLayer( int neuronsCount, int inputsCount, IActivationFunction function ) : base( neuronsCount, inputsCount ) { // create each neuron for ( int i = 0; i < neurons.Length; i++ ) neurons[i] = new ActivationNeuron( inputsCount, function ); }
/// <summary> /// Construct a neuron gene. /// </summary> /// <param name="type">The neuron type.</param> /// <param name="theActivationFunction">The activation function.</param> /// <param name="id">The neuron id.</param> /// <param name="innovationId">The innovation id.</param> public NEATNeuronGene(NEATNeuronType type, IActivationFunction theActivationFunction, long id, long innovationId) { NeuronType = type; InnovationId = innovationId; Id = id; ActivationFunction = theActivationFunction; }
/// <summary> /// Not used for this type of plugin. /// </summary> /// /// <param name="gradients">Not used.</param> /// <param name="layerOutput">Not used.</param> /// <param name="weights">Not used.</param> /// <param name="layerDelta">Not used.</param> /// <param name="af">Not used.</param> /// <param name="index">Not used.</param> /// <param name="fromLayerIndex">Not used.</param> /// <param name="fromLayerSize">Not used.</param> /// <param name="toLayerIndex">Not used.</param> /// <param name="toLayerSize">Not used.</param> public void CalculateGradient(double[] gradients, double[] layerOutput, double[] weights, double[] layerDelta, IActivationFunction af, int index, int fromLayerIndex, int fromLayerSize, int toLayerIndex, int toLayerSize) { }
public FloatFastConcurrentNetwork( int biasNeuronCount, int inputNeuronCount, int outputNeuronCount, int outputsPerPolicy, // Schrum: Added int totalNeuronCount, FloatFastConnection[] connectionArray, IActivationFunction[] activationFnArray) { this.biasNeuronCount = biasNeuronCount; this.inputNeuronCount = inputNeuronCount; this.totalInputNeuronCount = biasNeuronCount + inputNeuronCount; this.outputNeuronCount = outputNeuronCount; this.outputsPerPolicy = outputsPerPolicy; // Schrum: Added this.connectionArray = connectionArray; this.activationFnArray = activationFnArray; //----- Allocate the arrays that make up the neural network. // The neuron signals are initialised to 0 by default. Only bias nodes need setting to 1. neuronSignalArray = new float[totalNeuronCount]; _neuronSignalArray = new float[totalNeuronCount]; for(int i=0; i<biasNeuronCount; i++) neuronSignalArray[i] = 1.0F; }
public static FastConcurrentMultiplicativeNetwork DecodeToFastConcurrentMultiplicativeNetwork(NeatGenome.NeatGenome g, IActivationFunction activationFn) { int outputNeuronCount = g.OutputNeuronCount; int neuronGeneCount = g.NeuronGeneList.Count; // Slightly inefficient - determine the number of bias nodes. Fortunately there is not actually // any reason to ever have more than one bias node - although there may be 0. int neuronGeneIdx=0; for(; neuronGeneIdx<neuronGeneCount; neuronGeneIdx++) { if(g.NeuronGeneList[neuronGeneIdx].NeuronType != NeuronType.Bias) break; } int biasNodeCount = neuronGeneIdx; int inputNeuronCount = g.InputNeuronCount; // ConnectionGenes point to a neuron ID. We need to map this ID to a 0 based index for // efficiency. To do this we build a table of indexes (ints) keyed on neuron ID. // TODO: An alternative here would be to forgo the building of a table and do a binary // search directly on the NeuronGeneList - probably a good idea to use a heuristic based upon // neuroncount*connectioncount that decides on which technique to use. Small networks will // likely be faster to decode using the binary search. // Actually we can partly achieve the above optimzation by using HybridDictionary instead of Hashtable. // Although creating a table is a bit expensive. HybridDictionary neuronIndexTable = new HybridDictionary(neuronGeneCount); for(int i=0; i<neuronGeneCount; i++) neuronIndexTable.Add(g.NeuronGeneList[i].InnovationId, i); // Count how many of the connections are actually enabled. TODO: make faster - store disable count? int connectionGeneCount = g.ConnectionGeneList.Count; int connectionCount=connectionGeneCount; // for(int i=0; i<connectionGeneCount; i++) // { // if(g.ConnectionGeneList[i].Enabled) // connectionCount++; // } // Now we can build the connection array(s). FloatFastConnection[] connectionArray = new FloatFastConnection[connectionCount]; int connectionIdx=0; for(int connectionGeneIdx=0; connectionGeneIdx<connectionCount; connectionGeneIdx++) { ConnectionGene connectionGene = g.ConnectionGeneList[connectionIdx]; connectionArray[connectionIdx].sourceNeuronIdx = (int)neuronIndexTable[connectionGene.SourceNeuronId]; connectionArray[connectionIdx].targetNeuronIdx = (int)neuronIndexTable[connectionGene.TargetNeuronId]; connectionArray[connectionIdx].weight = (float)connectionGene.Weight; connectionIdx++; } // Now sort the connection array on sourceNeuronIdx, secondary sort on targetNeuronIdx. // TODO: custom sort routine to prevent boxing/unboxing required by Array.Sort(ValueType[]) //Array.Sort(connectionArray, fastConnectionComparer); QuickSortFastConnections(0, fastConnectionArray.Length-1); return new FastConcurrentMultiplicativeNetwork( biasNodeCount, inputNeuronCount, outputNeuronCount, neuronGeneCount, connectionArray, activationFn); }
/// <param name="activationFn">Not strictly part of a genome. But it is useful to document which function /// the genome is supposed to run against when decoded into a network.</param> public static void Write(XmlNode parentNode, NeatGenome genome, IActivationFunction activationFn) { //----- Start writing. Create document root node. XmlElement xmlGenome = XmlUtilities.AddElement(parentNode, "genome"); XmlUtilities.AddAttribute(xmlGenome, "id", genome.GenomeId.ToString()); XmlUtilities.AddAttribute(xmlGenome, "species-id", genome.SpeciesId.ToString()); XmlUtilities.AddAttribute(xmlGenome, "age", genome.GenomeAge.ToString()); XmlUtilities.AddAttribute(xmlGenome, "fitness", genome.Fitness.ToString("0.00")); XmlUtilities.AddAttribute(xmlGenome, "activation-fn-id", activationFn.FunctionId); //----- Write neurons. XmlElement xmlNeurons = XmlUtilities.AddElement(xmlGenome, "neurons"); foreach(NeuronGene neuronGene in genome.NeuronGeneList) WriteNeuron(xmlNeurons, neuronGene); //----- Write modules. XmlElement xmlModules = XmlUtilities.AddElement(xmlGenome, "modules"); foreach (ModuleGene moduleGene in genome.ModuleGeneList) WriteModule(xmlModules, moduleGene); //----- Write Connections. XmlElement xmlConnections = XmlUtilities.AddElement(xmlGenome, "connections"); foreach(ConnectionGene connectionGene in genome.ConnectionGeneList) WriteConnectionGene(xmlConnections, connectionGene); //----- Write beahavior if(genome.Behavior!=null) { if(genome.Behavior.behaviorList!=null) { XmlElement xmlBehavior = XmlUtilities.AddElement(xmlGenome, "behavior"); WriteBehavior(xmlBehavior,genome.Behavior); } } }
/// <summary> /// Construct a 2D convolution layer. /// </summary> /// <param name="theActivation">The activation function.</param> /// <param name="theNumFilters">The number of filters.</param> /// <param name="theFilterRows">The rows in each filter.</param> /// <param name="theFilterColumns">The columns in each filter.</param> public Conv2DLayer(IActivationFunction theActivation, int theNumFilters, int theFilterRows, int theFilterColumns) { Activation = theActivation; FilterRows = theFilterRows; FilterColumns = theFilterColumns; _numFilters = theNumFilters; }
public ActivationNeuron(double bias, IActivationFunction activationFunction) { Contract.Requires(activationFunction != null); ActivationFunction = activationFunction; Bias = bias; }
/// <summary> /// Construct with the provided id, selection probability and activation function. /// </summary> public ActivationFunctionInfo(int id, double selectionProbability, IActivationFunction activationFn) { _id = id; _selectionProbability = selectionProbability; _activationFn = activationFn; }
public ActivationLayer(int neuronsCount, int inputsCount, IActivationFunction function) : base(neuronsCount, inputsCount) { for (int i = 0; i < neuronsCount; i++) { this.neurons[i] = new ActivationNeuron(inputsCount, function); } }
/// <summary> /// Construct a flat layer. /// </summary> /// /// <param name="activation">The activation function.</param> /// <param name="count">The neuron count.</param> /// <param name="biasActivation">The bias activation.</param> public FlatLayer(IActivationFunction activation, int count, double biasActivation) { Activation = activation; _count = count; _biasActivation = biasActivation; _contextFedBy = null; }
public Neuron(int inputsCount, IActivationFunction function) { this.Output = 0.0; this.Threshold = 0.0; this.InputsCount = Math.Max(1, inputsCount); this.Weights = new List<double>(); this.ActivationFunction = function; }
/// <summary> /// Construct a flat layer. /// </summary> /// /// <param name="activation">The activation function.</param> /// <param name="count">The neuron count.</param> /// <param name="biasActivation">The bias activation.</param> /// <param name="paras">The parameters.</param> public FlatLayer(IActivationFunction activation, int count, double biasActivation, double[] paras) { this.activation = activation; this.count = count; this.biasActivation = biasActivation; this.contextFedBy = null; }
public void SingleLayerTest(int neuronCount, float[] inputs, float[] weightsAndBiases, IActivationFunction activationFunction) { var inCnt = inputs.Length; var outputs = new float[neuronCount]; var memIn = inputs.AsMemory(); var weMemFlat = weightsAndBiases.AsMemory(); var memOut = outputs.AsMemory(); var weMem = HelpersMisc.SliceArray(ref weMemFlat, inCnt + 1, neuronCount); var layer = new Layer(neuronCount, ref weMem, ref memIn, ref memOut, activationFunction); layer.CalculateWithoutNeuronParallel(); Assert.Multiple(() => { for (var i = 0; i < neuronCount; i++) { var wAndB = weMem[i].ToArray(); //var total = inputs.Select((t, j) => wAndB[j] * t).Sum(); var total = PrivateSum(inputs.Select((t, j) => wAndB[j] * t)); total += wAndB[inputs.Length]; var nOut = activationFunction.Forward(ref total); Assert.That(outputs[i], Is.EqualTo(nOut) /*.Within(.0001f)*/, $"Output is not as expected on neuron #{i}"); } }); }
public Neuron(IActivationFunction transferFunc, IWeightInputOperation operateFunc) { this.transferFunc = transferFunc; this.operateFunc = operateFunc; this.weights = new List <double>(); }
public void ResetEvaluator(IActivationFunction activationFn) { // populationEvaluator = new SingleFilePopulationEvaluator(new RobotDualNetworkEvaluator(), activationFn); populationEvaluator = new FoodGathererPopulationEvaluator(new FoodGathererNetworkEvaluator(), activationFn); }
/// <summary> /// Construct this layer with a non-default activation function, also /// determine if a bias is desired or not. /// </summary> /// /// <param name="activationFunction">The activation function to use.</param> /// <param name="neuronCount">How many neurons in this layer.</param> /// <param name="hasBias">True if this layer has a bias.</param> public BasicLayer(IActivationFunction activationFunction, bool hasBias, int neuronCount) : base(activationFunction, neuronCount, (hasBias) ? 1.0d : 0.0d) { }
/// <summary> /// Back Propagate /// </summary> /// <param name="neuralNetwork">Neural Network</param> /// <param name="expectedResults">Expected Results</param> /// <param name="activationFn">Activation Function</param> /// <param name="learningRate">Learning Rate (Not yet implemented)</param> private static void BackPropagate(NeuralNetwork neuralNetwork, double[] expectedResults, IActivationFunction activationFn, double learningRate) { // Calculate the error of each output neuron vs target for (int i = 0; i < neuralNetwork.OutputLayer.Count; i++) { neuralNetwork.OutputLayer[i].Error = activationFn.derivative(neuralNetwork.OutputLayer[i].Output) * (expectedResults[i] - neuralNetwork.OutputLayer[i].Output); } // Calc the global network error neuralNetwork.GlobalError = neuralNetwork.OutputLayer.Sum(x => x.Error); // Re-calc Output Layer weights for (int i = 0; i < neuralNetwork.OutputLayer.Count; i++) { AdjustNeuronWeights(neuralNetwork.OutputLayer[i], neuralNetwork.GlobalError); } // Recalc Hidden Layer weights // Calc Hidden Layer Errors for (int i = 0; i < neuralNetwork.HiddenLayer.Count; i++) { double totalError = 0; for (int j = 0; j < neuralNetwork.OutputLayer.Count; j++) { totalError += activationFn.derivative(neuralNetwork.HiddenLayer[i].Output) * neuralNetwork.GlobalError * neuralNetwork.OutputLayer[j].Weights[i]; } neuralNetwork.HiddenLayer[i].Error = totalError; } // then adjusts the hidden neurons' weights, based on their errors for (int i = 0; i < neuralNetwork.HiddenLayer.Count; i++) { AdjustNeuronWeights(neuralNetwork.HiddenLayer[i]); } }
static public List <Layer> BuildDense(int inputSize, int outputSize, int[] hiddenSize, int deep, double[] matrixInit, double[] biasInit, IActivationFunction <double> hidden, IActivationFunction <double> input = null, IActivationFunction <double> output = null) { List <Layer> layers = new List <Layer>(deep); input ??= new ReLU(); output ??= new ReLU(); if (deep < 1) { throw new Exception("Too few layers!"); } else if (deep == 1) { layers.Add(new Layer(inputSize, outputSize, matrixInit[0], biasInit[0], hidden)); } else { layers.Add(new Layer(hiddenSize[0], inputSize, matrixInit[0], biasInit[0], input)); for (int i = 1; i < deep - 1; i++) { layers.Add(new Layer(hiddenSize[i], hiddenSize[i - 1], matrixInit[i], biasInit[i], hidden)); } layers.Add(new Layer(outputSize, hiddenSize[deep - 2], matrixInit[deep - 1], biasInit[deep - 1], output)); } return(layers); }
private static void AssertMonotonic(IActivationFunction <double> actFn, bool strict) { Assert.IsTrue(TestUtils.IsMonotonicIncreasing(actFn.Fn, -6, 6, 0.01, strict)); }
private AxonFactory(IActivationFunction activationFunction) { _activationFunction = activationFunction; }
public static IAxonFactory GetInstance(IActivationFunction activationFunction) { return(new AxonFactory(activationFunction)); }
/// <summary> /// Construct a single dimension layer, this is usually used for non-convolutional neural networks. /// </summary> /// <param name="activation">The activation function. All layers, except input will have activation functions.</param> /// <param name="theHasBias">True, if this layer has a bias, all layers except the output have bias.</param> /// <param name="theCount">The neuron count.</param> public BasicLayer(IActivationFunction activation, bool theHasBias, int theCount) : this(activation, theHasBias, new[] { theCount }) { }
/// <summary> /// Initializes a new instance of the <see cref="Activation"/> class. /// </summary> /// /// <param name="activation">The activation function.</param> /// public Activation(IActivationFunction activation) { this.supports_masking = true; this.activation = activation; }
public RadialBasisFunctionLayer(IActivationFunction activationFunction, int neurons, int layer, int p) : this(activationFunction, neurons, layer) { this.p = p; }
public RadialBasisFunctionLayer(IActivationFunction activationFunction, int neurons, int layer) : this(neurons, layer) { this.activationFunction_ = activationFunction; }
/// <summary> /// Initalizes an ANeuronLayer. /// </summary> /// <param name="passedNumberOfNeurons">The Number of Neurons in the Layer.</param> /// <param name="passedNumberOfWeightsPerNeuron">The Number of Weights Per Neuron in the Layer.</param> /// <param name="passedActivationFunction">The Activation Function of all Neurons in the Layer.</param> public ANeuronLayer(uint passedNumberOfNeurons, uint passedNumberOfWeightsPerNeuron, IActivationFunction passedActivationFunction) { this._Neurons = new List <INeuron>((int)passedNumberOfNeurons); this._NumberOfWeightsPerNeuron = passedNumberOfWeightsPerNeuron; this._NumberOfNeurons = passedNumberOfNeurons; this._ActivationFunction = passedActivationFunction; CreateNeurons(); }
public Activation(int nodes, IActivationFunction activationFunction) : base(nodes, nodes) { this.activationFunction = activationFunction; }
static public Layer BuildDense(int inputSize, int outputSize, double matrixInit, double biasInit, IActivationFunction <double> f) { return(new Layer(outputSize, inputSize, matrixInit, biasInit, f)); }
public Activation(IActivationFunction activationFunction, Layer layer) : base(layer.Inputs, layer) { this.activationFunction = activationFunction; }
/// <summary> /// Construct a data description with an activation function, but no range. /// </summary> /// <param name="activationFunction">The activation function.</param> /// <param name="type">The type of data.</param> /// <param name="input">Used for input?</param> /// <param name="predict">Used for prediction?</param> public TemporalDataDescription(IActivationFunction activationFunction, Type type, bool input, bool predict) : this(activationFunction, 0, 0, type, input, predict) { }
static public List <Layer> BuildRandom(int inputSize, int outputSize, int hiddenSize, int deep, double mCenter = 0, double mOffset = 1, double bCenter = 0, double bOffset = 1, IActivationFunction <double> hidden = null, IActivationFunction <double> input = null, IActivationFunction <double> output = null) { List <Layer> layers = new List <Layer>(deep); input ??= new ReLU(); output ??= new ReLU(); hidden ??= new ReLU(); if (deep < 1) { throw new Exception("Too few layers!"); } else if (deep == 1) { layers.Add(BuildRandom(inputSize, outputSize, output, mCenter, mOffset, bCenter, bOffset)); } else { layers.Add(BuildRandom(inputSize, hiddenSize, input, mCenter, mOffset, bCenter, bOffset)); for (int i = 1; i < deep - 1; i++) { layers.Add(BuildRandom(hiddenSize, hiddenSize, hidden, mCenter, mOffset, bCenter, bOffset)); } layers.Add(BuildRandom(hiddenSize, outputSize, output, mCenter, mOffset, bCenter, bOffset)); } return(layers); }
/// <summary> /// Copy constructor. /// </summary> /// <param name="copyFrom"></param> public NeuronGene(NeuronGene copyFrom) { this.innovationId = copyFrom.innovationId; this.neuronType = copyFrom.neuronType; this.activationFunction = copyFrom.activationFunction; }
/// <summary> /// Конструктор нейрона по весам /// </summary> /// <param name="weights">Вектор весов</param> /// <param name="bias">Смещение - нулевой вес</param> /// <param name="af">Интерфейс функции активации</param> public Neuron(Vector weights, double bias, IActivationFunction af) { Weights = weights; Bias = bias; activationFunction = af; }
public NeuronGene(uint innovationId, NeuronType neuronType, IActivationFunction activationFunction) { this.innovationId = innovationId; this.neuronType = neuronType; this.activationFunction = activationFunction; }
/// <summary> /// Train Neural Network (N.B Do not train for just 1 example, always randomize training data) /// </summary> /// <param name="neuralNetwork">Neural Network</param> /// <param name="trainingData">Training Data</param> /// <param name="epochs">Number of Training Epochs</param> /// <param name="activationFn">Activation Function</param> /// <param name="learningRate">Learning Rate</param> /// <returns>Results Array</returns> public double[][] Train(NeuralNetwork neuralNetwork, TrainingDataDTO trainingData, int epochs, IActivationFunction activationFn, double learningRate) { // Get / create some inital vars for results obj int arrayWidth = trainingData.Inputs.GetLength(0) + trainingData.ExpectedResults.GetLength(0); double[][] results = new double[epochs * trainingData.Inputs.Length][]; int counter = 0; for (int i = 0; i < epochs; i++) { for (int j = 0; j < trainingData.Inputs.Length; j++) { double[] inputs = trainingData.Inputs[j]; double[] expectedResults = trainingData.ExpectedResults[j]; _neuralNetworkProcessingService.ProcessFeedForwardNeuralNetwork(neuralNetwork, inputs, activationFn); BackPropagate(neuralNetwork, expectedResults, activationFn, learningRate); // Populate results obj results[counter] = inputs.Concat(expectedResults) // Inputs and Expected Results .Concat(neuralNetwork.OutputLayer.Select(x => x.Output)) // Actual Outputs .Concat(new double[1] { neuralNetwork.GlobalError }).ToArray(); // Overall Global Network Error counter++; } } return(results); }
public Builder Activation(IActivationFunction activation) { this.activation = activation ?? throw new ArgumentNullException(nameof(activation)); return(this); }
/// <summary> /// Initalizes an ANeuralNetwork. /// </summary> /// <param name="passedNumberOfInputNeurons">The Number of Neurons in the Input Layer.</param> /// <param name="passedNumberOfNeuronsPerHiddenLayer">The Number of Neurons in the Hidden Layers.</param> /// <param name="passedNumberOfHiddenLayers">The Number of Hidden Layers.</param> /// <param name="passedNumberOfOutputNeurons">The Number of Neurons in the Output Layer.</param> /// <param name="passedNumberOfWeightsForInput">The Number of Weights for an Input Neuron.</param> /// <param name="passedActivationFunction">The Activation Function for all Neurons in the Network.</param> public ANeuralNetwork(uint passedNumberOfInputNeurons, uint passedNumberOfNeuronsPerHiddenLayer, uint passedNumberOfHiddenLayers, uint passedNumberOfOutputNeurons, uint passedNumberOfWeightsForInput, IActivationFunction passedActivationFunction) { //Initalize and Assign Input and Output Layers. INeuronLayer inputNeuronLayer = new NeuronLayer(passedNumberOfInputNeurons, passedNumberOfWeightsForInput, passedActivationFunction); INeuronLayer outputNeuronLayer = new NeuronLayer(passedNumberOfOutputNeurons, passedNumberOfNeuronsPerHiddenLayer, passedActivationFunction); IList <INeuronLayer> neuronLayers = new List <INeuronLayer>((int)(2 + passedNumberOfHiddenLayers)); neuronLayers.Add(inputNeuronLayer); for (int i = 1; i < passedNumberOfHiddenLayers; i++) { neuronLayers.Add(new NeuronLayer(passedNumberOfNeuronsPerHiddenLayer, neuronLayers[i - 1].NumberOfNeurons, passedActivationFunction)); } neuronLayers.Add(outputNeuronLayer); INeuronLayers l = new NeuronLayers(neuronLayers); }
/// <summary> /// Construct the activation summation. /// </summary> /// <param name="theActivationFunction">The activation function.</param> public BasicActivationSummation( IActivationFunction theActivationFunction) { ActivationFunction = theActivationFunction; }
public Neuron(IActivationFunction transferFunc) : this(transferFunc, MultiplyOperationFunction.Instance) { }
/// <summary> /// Initializes a new instance of the <see cref="ActivationNeuron"/> class. /// </summary> /// /// <param name="inputs">Neuron's inputs count.</param> /// <param name="function">Neuron's activation function.</param> /// public ActivationNeuron(int inputs, IActivationFunction function) : base(inputs) { this.function = function; }
public ActivationLayerBlueprint(int neuronCount, IActivationFunction activationFunction) : base(neuronCount) { this.activationFunction = activationFunction; }
public void ResetEvaluator(IActivationFunction activationFn) { populationEvaluator = new EveryonePopulationEvaluator(new CCEAGeomCtrlNetworkEvaluator(m_neatQTable)); }