This class will extract the "long term memory" of a neural network, that is the weights and bias values into an array. This array can be used to view the neural network as a linear array of doubles. These values can then be modified and copied back into the neural network. This is very useful for simulated annealing, as well as genetic algorithms.
Документация по классу NetworkCODEC
Пример #1
0
        /// <summary>
        /// Use an array to populate the memory of the neural network.
        /// </summary>
        /// <param name="array">An array of doubles.</param>
        /// <param name="network">The network to encode.</param>
        public static void ArrayToNetwork(double[] array,
                                          BasicNetwork network)
        {
            int index = 0;

            foreach (ILayer layer in network.Structure.Layers)
            {
                index = NetworkCODEC.ProcessLayer(network, layer, array, index);
            }

            network.Structure.FlatUpdate = FlatUpdateNeeded.Flatten;
        }
Пример #2
0
        /// <summary>
        /// Flatten the weights of a neural network.
        /// </summary>
        public void FlattenWeights()
        {
            if (this.flat != null)
            {
                this.flatUpdate = FlatUpdateNeeded.Flatten;

                double[] targetWeights = this.flat.Weights;
                double[] sourceWeights = NetworkCODEC.NetworkToArray(this.network);

                EngineArray.ArrayCopy(sourceWeights, targetWeights);
                this.flatUpdate = FlatUpdateNeeded.None;

                // update context layers
                foreach (ILayer layer in this.layers)
                {
                    if (layer is ContextLayer)
                    {
                        ContextLayer context = (ContextLayer)layer;
                        if (context.FlatContextIndex != -1)
                        {
                            EngineArray.ArrayCopy(
                                context.Context.Data,
                                0,
                                this.flat.LayerOutput,
                                context.FlatContextIndex,
                                context.Context.Count);
                        }
                    }
                }


                // handle limited connection networks
                if (this.connectionLimited)
                {
                    this.flat.ConnectionLimit = this.connectionLimit;
                }
                else
                {
                    this.flat.ClearConnectionLimit();
                }
            }
        }
Пример #3
0
        /// <summary>
        /// Determine if the two neural networks are equal.
        /// </summary>
        /// <param name="network1">The first network.</param>
        /// <param name="network2">The second network.</param>
        /// <param name="precision">How many decimal places to check.</param>
        /// <returns>True if the two networks are equal.</returns>
        public static bool Equals(BasicNetwork network1,
                                  BasicNetwork network2, int precision)
        {
            double[] array1 = NetworkCODEC.NetworkToArray(network1);
            double[] array2 = NetworkCODEC.NetworkToArray(network2);

            if (array1.Length != array2.Length)
            {
                return(false);
            }

            double test = Math.Pow(10.0, precision);

            if (double.IsInfinity(test) || (test > long.MaxValue))
            {
                String str = "Precision of " + precision
                             + " decimal places is not supported.";
#if logging
                if (NetworkCODEC.LOGGER.IsErrorEnabled)
                {
                    NetworkCODEC.LOGGER.Error(str);
                }
#endif
                throw new NeuralNetworkError(str);
            }

            foreach (double element in array1)
            {
                long l1 = (long)(element * test);
                long l2 = (long)(element * test);
                if (l1 != l2)
                {
                    return(false);
                }
            }

            return(true);
        }
Пример #4
0
 /// <summary>
 /// Calculate the size that an array should be to hold all of the weights and
 /// bias values.
 /// </summary>
 ///
 /// <returns>The size of the calculated array.</returns>
 public int CalculateSize()
 {
     return(NetworkCODEC.NetworkSize(_network));
 }