C# BasicMLData.Clear方法代码示例

 public virtual IMLData Compute(IMLData input)
 {
     int num;
     int num2;
     int num3;
     int num4;
     double num5;
     double weight;
     double output;
     IMLData data = new BasicMLData(this._outputCount);
     goto Label_0271;
     Label_001B:
     num4++;
     Label_0021:
     if (num4 < this._neurons.Count)
     {
         NEATNeuron neuron = this._neurons[num4];
         num5 = 0.0;
         foreach (NEATLink link in neuron.InboundLinks)
         {
             weight = link.Weight;
             do
             {
                 output = link.FromNeuron.Output;
             }
             while ((((uint) weight) - ((uint) num2)) < 0);
             num5 += weight * output;
         }
         double[] d = new double[] { num5 / neuron.ActivationResponse };
         this._activationFunction.ActivationFunction(d, 0, d.Length);
         this._neurons[num4].Output = d[0];
         if (neuron.NeuronType == NEATNeuronType.Output)
         {
             data[num3++] = neuron.Output;
             if ((((uint) num2) - ((uint) num4)) < 0)
             {
                 goto Label_0206;
             }
             if (-1 == 0)
             {
                 goto Label_025D;
             }
         }
         goto Label_001B;
     }
     num2++;
     Label_0037:
     if (num2 < num)
     {
         num3 = 0;
         if ((((uint) weight) - ((uint) weight)) >= 0)
         {
             if (1 != 0)
             {
                 num4 = 0;
                 data.Clear();
                 while (this._neurons[num4].NeuronType == NEATNeuronType.Input)
                 {
                     this._neurons[num4].Output = input[num4];
                     num4++;
                 }
                 goto Label_01BB;
             }
             goto Label_001B;
         }
         if (((uint) output) <= uint.MaxValue)
         {
             goto Label_0271;
         }
         goto Label_0239;
     }
     Label_003E:
     this._outputActivationFunction.ActivationFunction(data.Data, 0, data.Count);
     return data;
     Label_01BB:
     this._neurons[num4++].Output = 1.0;
     if (((uint) output) <= uint.MaxValue)
     {
         goto Label_0021;
     }
     Label_0206:
     num2 = 0;
     goto Label_0037;
     Label_0239:
     num = this._networkDepth;
     if ((((uint) num5) | 0x7fffffff) == 0)
     {
         goto Label_003E;
     }
     goto Label_0206;
     Label_025D:
     if (this._neurons.Count == 0)
     {
         throw new NeuralNetworkError("This network has not been evolved yet, it has no neurons in the NEAT synapse.");
     }
     num = 1;
     if (this._snapshot)
     {
         goto Label_0239;
     }
//.........这里部分代码省略.........

        /// <summary>
        /// Compute the output from this synapse.
        /// </summary>
        ///
        /// <param name="input">The input to this synapse.</param>
        /// <returns>The output from this synapse.</returns>
        public virtual IMLData Compute(IMLData input)
        {
            IMLData result = new BasicMLData(_outputCount);

            if (_neurons.Count == 0)
            {
                throw new NeuralNetworkError(
                    "This network has not been evolved yet, it has no neurons in the NEAT synapse.");
            }

            int flushCount = 1;

            if (_snapshot)
            {
                flushCount = _networkDepth;
            }

            // iterate through the network FlushCount times
            for (int i = 0; i < flushCount; ++i)
            {
                int outputIndex = 0;
                int index = 0;

                result.Clear();

                // populate the input neurons
                while (_neurons[index].NeuronType == NEATNeuronType.Input)
                {
                    _neurons[index].Output = input[index];

                    index++;
                }

                // set the bias neuron
                _neurons[index++].Output = 1;

                while (index < _neurons.Count)
                {
                    NEATNeuron currentNeuron = _neurons[index];

                    double sum = 0;

                    foreach (NEATLink link  in  currentNeuron.InboundLinks)
                    {
                        double weight = link.Weight;
                        double neuronOutput = link.FromNeuron.Output;
                        sum += weight*neuronOutput;
                    }

                    var d = new double[1];
                    d[0] = sum/currentNeuron.ActivationResponse;
                    _activationFunction.ActivationFunction(d, 0, d.Length);

                    _neurons[index].Output = d[0];

                    if (currentNeuron.NeuronType == NEATNeuronType.Output)
                    {
                        result[outputIndex++] = currentNeuron.Output;
                    }
                    index++;
                }
            }

            _outputActivationFunction.ActivationFunction(result.Data, 0,
                                                        result.Count);

            return result;
        }

        /// <inheritdoc/>
        public IMLMethod Decode(NEATPopulation pop, Substrate.Substrate substrate,
                IGenome genome)
        {
            // obtain the CPPN
            NEATCODEC neatCodec = new NEATCODEC();
            NEATNetwork cppn = (NEATNetwork)neatCodec.Decode(genome);

            List<NEATLink> linkList = new List<NEATLink>();

            IActivationFunction[] afs = new IActivationFunction[substrate.NodeCount];

            IActivationFunction af = new ActivationSteepenedSigmoid();
            // all activation functions are the same
            for (int i = 0; i < afs.Length; i++)
            {
                afs[i] = af;
            }

            double c = this.MaxWeight / (1.0 - this.MinWeight);
            BasicMLData input = new BasicMLData(cppn.InputCount);

            // First create all of the non-bias links.
            foreach (SubstrateLink link in substrate.Links)
            {
                SubstrateNode source = link.Source;
                SubstrateNode target = link.Target;

                int index = 0;
                foreach (double d in source.Location)
                {
                    input.Data[index++] = d;
                }
                foreach (double d in target.Location)
                {
                    input.Data[index++] = d;
                }
                IMLData output = cppn.Compute(input);

                double weight = output[0];
                if (Math.Abs(weight) > this.MinWeight)
                {
                    weight = (Math.Abs(weight) - this.MinWeight) * c
                            * Math.Sign(weight);
                    linkList.Add(new NEATLink(source.ID, target.ID,
                            weight));
                }
            }

            // now create biased links
            input.Clear();
            int d2 = substrate.Dimensions;
            IList<SubstrateNode> biasedNodes = substrate.GetBiasedNodes();
            foreach (SubstrateNode target in biasedNodes)
            {
                for (int i = 0; i < d2; i++)
                {
                    input.Data[d2 + i] = target.Location[i];
                }

                IMLData output = cppn.Compute(input);

                double biasWeight = output[1];
                if (Math.Abs(biasWeight) > this.MinWeight)
                {
                    biasWeight = (Math.Abs(biasWeight) - this.MinWeight) * c
                            * Math.Sign(biasWeight);
                    linkList.Add(new NEATLink(0, target.ID, biasWeight));
                }
            }

            // check for invalid neural network
            if (linkList.Count == 0)
            {
                return null;
            }

            linkList.Sort();

            NEATNetwork network = new NEATNetwork(substrate.InputCount,
                    substrate.OutputCount, linkList, afs);

            network.ActivationCycles = substrate.ActivationCycles;
            return network;
        }